genericfactory.h

#ifndef __tdeparts__genericfactory_h__
#define __tdeparts__genericfactory_h__
 
#include <tdeparts/factory.h>
#include <tdeparts/part.h>
#include <kgenericfactory.h>
#include <tdeaboutdata.h>
#include <kdebug.h>
 
namespace KParts
{
 
    template <class T>
    class GenericFactoryBase : public KParts::Factory
    {
    public:
        GenericFactoryBase()
        {
            if ( s_self )
                kdWarning() << "KParts::GenericFactory instantiated more than once!" << endl;
            s_self = this;
        }
        virtual ~GenericFactoryBase()
        {
            delete s_aboutData;
            delete s_instance;
            s_aboutData = 0;
            s_instance = 0;
            s_self = 0;
        }
 
        static TDEInstance *instance();
        static TDEAboutData *aboutData();
 
    protected:
        virtual TDEInstance *createInstance()
        {
            return new TDEInstance( aboutData() );
        }
 
        virtual void virtual_hook( int id, void *data )
        {
            if ( id != VIRTUAL_QUERY_INSTANCE_PARAMS ) {
                KParts::Factory::virtual_hook( id, data );
                return;
            }
 
            QueryInstanceParams *params = reinterpret_cast<QueryInstanceParams *>( data );
            params->instance = instance();
        }
 
    private:
        static GenericFactoryBase<T> *s_self;
        static TDEInstance *s_instance;
        static TDEAboutData *s_aboutData;
    };
 
    template <class T>
    class GenericFactory : public GenericFactoryBase<T>
    {
    public:
        GenericFactory() { }
 
        virtual KParts::Part *createPartObject( TQWidget *parentWidget, const char *widgetName,
                                                TQObject *parent, const char *name,
                                                const char *className,
                                                const TQStringList &args )
        {
            T *part = KDEPrivate::ConcreteFactory<T>::create( parentWidget,
                                                              widgetName,
                                                              parent,
                                                              name,
                                                              className,
                                                              args );
 
            if ( part && !qstrcmp( className, "KParts::ReadOnlyPart" ) )
            {
                KParts::ReadWritePart *rwp = dynamic_cast<KParts::ReadWritePart *>( part );
                if ( rwp )
                    rwp->setReadWrite( false );
            }
            return part;
        }
    };
 
    template <class T1, class T2>
    class GenericFactory< KTypeList<T1, T2> > : public GenericFactoryBase<T1>
    {
    public:
        GenericFactory() { }
 
        virtual KParts::Part *createPartObject( TQWidget *parentWidget, const char *widgetName,
                                                TQObject *parent, const char *name,
                                                const char *className,
                                                const TQStringList &args )
        {
            TQObject *object = KDEPrivate::MultiFactory< KTypeList<T1, T2> >::create( parentWidget,
                                                                                     widgetName,
                                                                                     parent, name,
                                                                                     className,
                                                                                     args );
 
            // (this cast is guaranteed to work...)
            KParts::Part *part = dynamic_cast<KParts::Part *>( object );
 
            if ( part && !qstrcmp( className, "KParts::ReadOnlyPart" ) )
            {
                KParts::ReadWritePart *rwp = dynamic_cast<KParts::ReadWritePart *>( part );
                if ( rwp )
                    rwp->setReadWrite( false );
            }
            return part;
        }
    };
 
    template <class T>
    GenericFactoryBase<T> *GenericFactoryBase<T>::s_self = 0;
 
    template <class T>
    TDEInstance *GenericFactoryBase<T>::s_instance = 0;
 
    template <class T>
    TDEAboutData *GenericFactoryBase<T>::s_aboutData = 0;
 
    template <class T>
    TDEInstance *GenericFactoryBase<T>::instance()
    {
        if ( !s_instance )
        {
            if ( s_self )
                s_instance = s_self->createInstance();
            else
                s_instance = new TDEInstance( aboutData() );
        }
        return s_instance;
    }
 
    template <class T>
    TDEAboutData *GenericFactoryBase<T>::aboutData()
    {
        if ( !s_aboutData )
            s_aboutData = T::createAboutData();
        return s_aboutData;
    }
 
}
 
#endif