manager.h

/*
    This file is part of libtderesources.
 
    Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
    Copyright (c) 2002 Jan-Pascal van Best <janpascal@vanbest.org>
    Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/
 
#ifndef TDERESOURCES_MANAGER_H
#define TDERESOURCES_MANAGER_H
 
#include <tqdict.h>
#include <tqstringlist.h>
 
#include <kdebug.h>
#include <tderesources/factory.h>
#include <tderesources/managerimpl.h>
 
namespace KRES {
 
class Resource;

template<class T>
class ManagerObserver
{
  public:
    virtual void resourceAdded( T *resource ) = 0;
    virtual void resourceModified( T *resource ) = 0;
    virtual void resourceDeleted( T *resource ) = 0;
};

class ManagerNotifier
{
  public:
    virtual void notifyResourceAdded( Resource *resource ) = 0;
    virtual void notifyResourceModified( Resource *resource ) = 0;
    virtual void notifyResourceDeleted( Resource *resource ) = 0;
};

template<class T>
class Manager : private ManagerNotifier
{
  public:
    class Iterator
    {
        friend class Manager;
      public:
        Iterator() {};
        Iterator( const Iterator &it ) { mIt = it.mIt; }
 
        T *operator*() { return static_cast<T *>( *mIt ); }
        Iterator &operator++() { mIt++; return *this; }
        Iterator &operator++( int ) { mIt++; return *this; }
        Iterator &operator--() { mIt--; return *this; }
        Iterator &operator--( int ) { mIt--; return *this; }
        bool operator==( const Iterator &it ) { return mIt == it.mIt; }
        bool operator!=( const Iterator &it ) { return mIt != it.mIt; }
 
      private:
        Resource::List::Iterator mIt;
    };

    Iterator begin()
    {
      Iterator it;
      it.mIt = mImpl->resourceList()->begin();
      return it;
    }

    Iterator end()
    {
      Iterator it;
      it.mIt = mImpl->resourceList()->end();
      return it;
    }

    class ActiveIterator
    {
        friend class Manager;
      public:
        ActiveIterator() : mList( 0 ) {};
        ActiveIterator( const ActiveIterator &it )
        {
          mIt = it.mIt;
          mList = it.mList;
        }
 
        T *operator*() { return static_cast<T *>( *mIt ); }
        ActiveIterator &operator++()
        {
          do { mIt++; } while ( checkActive() );
          return *this;
        }
        ActiveIterator &operator++( int )
        {
          do { mIt++; } while ( checkActive() );
          return *this;
        }
        ActiveIterator &operator--()
        {
          do { mIt--; } while ( checkActive() );
          return *this;
        }
        ActiveIterator &operator--( int )
        {
          do { mIt--; } while ( checkActive() );
          return *this;
        }
        bool operator==( const ActiveIterator &it ) { return mIt == it.mIt; }
        bool operator!=( const ActiveIterator &it ) { return mIt != it.mIt; }
 
      private:
        bool checkActive()
        {
          if ( !mList || mIt == mList->end() ) return false;
          return !(*mIt)->isActive();
        }
 
        Resource::List::Iterator mIt;
        Resource::List *mList;
    };

    ActiveIterator activeBegin()
    {
      ActiveIterator it;
      it.mIt = mImpl->resourceList()->begin();
      it.mList = mImpl->resourceList();
      if ( it.mIt != mImpl->resourceList()->end() ) {
        if ( !(*it)->isActive() ) it++;
      }
      return it;
    }

    ActiveIterator activeEnd()
    {
      ActiveIterator it;
      it.mIt = mImpl->resourceList()->end();
      it.mList = mImpl->resourceList();
      return it;
    }

    bool isEmpty() const { return mImpl->resourceList()->isEmpty(); }

    Manager( const TQString &family )
    {
      mFactory = Factory::self( family );
      // The managerimpl will use the same Factory object as the manager
      // because of the Factory::self() pattern
      mImpl = new ManagerImpl( this, family );
      mObservers.setAutoDelete( false );
    }
 
    virtual ~Manager()
    {
      delete mImpl;
    }

    void readConfig( TDEConfig *cfg = 0 )
    {
      mImpl->readConfig( cfg );
    }

    void writeConfig( TDEConfig *cfg = 0 )
    {
      mImpl->writeConfig( cfg );
    }

    void add( Resource *resource )
    {
      if ( resource ) mImpl->add( resource );
    }

    void remove( Resource *resource )
    {
      if ( resource ) mImpl->remove( resource );
    }

    void change( T *resource )
    {
      mImpl->change( resource );
    }

    T *standardResource()
    {
      return static_cast<T *>( mImpl->standardResource() );
    }

    void setStandardResource( T *resource )
    {
      if ( resource ) mImpl->setStandardResource( resource );
    }

    void setActive( Resource *resource, bool active )
    {
      if ( resource ) mImpl->setActive( resource, active );
    }

    TQStringList resourceNames() const
    {
      return mImpl->resourceNames();
    }

    T *createResource( const TQString& type )
    {
      return dynamic_cast<T *>( mFactory->resource( type, 0 ) );
    }

    TQStringList resourceTypeNames() const
    {
      return mFactory->typeNames();
    }

    TQStringList resourceTypeDescriptions() const
    {
      TQStringList typeDescs;
      TQStringList types = mFactory->typeNames();
 
      for ( TQStringList::ConstIterator it = types.begin(); it != types.end();
            ++it ) {
        TQString desc = mFactory->typeName( *it );
        if ( !mFactory->typeDescription( *it ).isEmpty() )
          desc += TQString::fromLatin1(" (") + mFactory->typeDescription( *it ) + TQString::fromLatin1(")");
 
        typeDescs.append( desc );
      }
 
      return typeDescs;
    }

    void addObserver( ManagerObserver<T> *observer )
    {
      mObservers.append( observer );
    }

    void removeObserver( ManagerObserver<T> *observer )
    {
      mObservers.remove( observer );
    }
 
  private:
    void notifyResourceAdded( Resource *res )
    {
      kdDebug(5650) << "Manager::resourceAdded " << res->resourceName() << endl;
      T *resource = dynamic_cast<T *>( res );
      if ( resource ) {
        ManagerObserver<T> *observer;
        for ( observer = mObservers.first(); observer;
              observer = mObservers.next() )
          observer->resourceAdded( resource );
      }
    }

    void notifyResourceModified( Resource *res )
    {
      kdDebug(5650) << "Manager::resourceModified " << res->resourceName()
                    << endl;
      T *resource = dynamic_cast<T *>( res );
      if ( resource ) {
        ManagerObserver<T> *observer;
        for ( observer = mObservers.first(); observer;
              observer = mObservers.next() )
          observer->resourceModified( resource );
      }
    }

    void notifyResourceDeleted( Resource *res )
    {
      kdDebug(5650) << "Manager::resourceDeleted " << res->resourceName()
                    << endl;
      T *resource = dynamic_cast<T *>( res );
      if ( resource ) {
        ManagerObserver<T> *observer;
        for ( observer = mObservers.first(); observer;
              observer = mObservers.next() ) {
          kdDebug(5650) << "Notifying a observer to Manager..." << endl;
          observer->resourceDeleted( resource );
        }
      }
    }
 
  private:
    ManagerImpl *mImpl;
    Factory *mFactory;
    TQPtrList<ManagerObserver<T> > mObservers;
};
 
}
 
#endif