kparts Library API Documentation

genericfactory.h

00001 #ifndef __kparts__genericfactory_h__
00002 #define __kparts__genericfactory_h__
00003 
00004 #include <kparts/factory.h>
00005 #include <kparts/part.h>
00006 #include <kgenericfactory.h>
00007 #include <kaboutdata.h>
00008 #include <kdebug.h>
00009 
00010 namespace KParts
00011 {
00012 
00016     template <class T>
00017     class GenericFactoryBase : public KParts::Factory
00018     {
00019     public:
00020         GenericFactoryBase()
00021         {
00022             if ( s_self )
00023                 kdWarning() << "KParts::GenericFactory instantiated more than once!" << endl;
00024             s_self = this;
00025         }
00026         virtual ~GenericFactoryBase()
00027         {
00028             delete s_aboutData;
00029             delete s_instance;
00030             s_aboutData = 0;
00031             s_instance = 0;
00032             s_self = 0;
00033         }
00034 
00035         static KInstance *instance();
00036         static KAboutData *aboutData();
00037 
00038     protected:
00039         virtual KInstance *createInstance()
00040         {
00041             return new KInstance( aboutData() );
00042         }
00043 
00044         virtual void virtual_hook( int id, void *data )
00045         {
00046             if ( id != VIRTUAL_QUERY_INSTANCE_PARAMS )
00047                 return KParts::Factory::virtual_hook( id, data );
00048 
00049             QueryInstanceParams *params = reinterpret_cast<QueryInstanceParams *>( data );
00050             params->instance = instance();
00051         }
00052 
00053     private:
00054         static GenericFactoryBase<T> *s_self;
00055         static KInstance *s_instance;
00056         static KAboutData *s_aboutData;
00057     };
00058 
00092     template <class T>
00093     class GenericFactory : public GenericFactoryBase<T>
00094     {
00095     public:
00096         GenericFactory() { }
00097 
00098         virtual KParts::Part *createPartObject( QWidget *parentWidget, const char *widgetName,
00099                                                 QObject *parent, const char *name,
00100                                                 const char *className,
00101                                                 const QStringList &args )
00102         {
00103             T *part = KDEPrivate::ConcreteFactory<T>::create( parentWidget,
00104                                                               widgetName,
00105                                                               parent,
00106                                                               name,
00107                                                               className,
00108                                                               args );
00109 
00110             if ( part && !qstrcmp( className, "KParts::ReadOnlyPart" ) )
00111             {
00112                 KParts::ReadWritePart *rwp = dynamic_cast<KParts::ReadWritePart *>( part );
00113                 if ( rwp )
00114                     rwp->setReadWrite( false );
00115             }
00116             return part;
00117         }
00118     };
00119 
00120     template <class T1, class T2>
00121     class GenericFactory< KTypeList<T1, T2> > : public GenericFactoryBase<T1>
00122     {
00123     public:
00124         GenericFactory() { }
00125 
00126         virtual KParts::Part *createPartObject( QWidget *parentWidget, const char *widgetName,
00127                                                 QObject *parent, const char *name,
00128                                                 const char *className,
00129                                                 const QStringList &args )
00130         {
00131             QObject *object = KDEPrivate::MultiFactory< KTypeList<T1, T2> >::create( parentWidget,
00132                                                                                      widgetName,
00133                                                                                      parent, name,
00134                                                                                      className,
00135                                                                                      args );
00136 
00137             // (this cast is guaranteed to work...)
00138             KParts::Part *part = dynamic_cast<KParts::Part *>( object );
00139 
00140             if ( part && !qstrcmp( className, "KParts::ReadOnlyPart" ) )
00141             {
00142                 KParts::ReadWritePart *rwp = dynamic_cast<KParts::ReadWritePart *>( part );
00143                 if ( rwp )
00144                     rwp->setReadWrite( false );
00145             }
00146             return part;
00147         }
00148     };
00149 
00153     template <class T>
00154     GenericFactoryBase<T> *GenericFactoryBase<T>::s_self = 0;
00155 
00159     template <class T>
00160     KInstance *GenericFactoryBase<T>::s_instance = 0;
00161 
00165     template <class T>
00166     KAboutData *GenericFactoryBase<T>::s_aboutData = 0;
00167 
00171     template <class T>
00172     KInstance *GenericFactoryBase<T>::instance()
00173     {
00174         if ( !s_instance )
00175         {
00176             if ( s_self )
00177                 s_instance = s_self->createInstance();
00178             else
00179                 s_instance = new KInstance( aboutData() );
00180         }
00181         return s_instance;
00182     }
00183 
00187     template <class T>
00188     KAboutData *GenericFactoryBase<T>::aboutData()
00189     {
00190         if ( !s_aboutData )
00191             s_aboutData = T::createAboutData();
00192         return s_aboutData;
00193     }
00194 
00195 }
00196 
00197 #endif
00198 
KDE Logo
This file is part of the documentation for kparts Library Version 3.2.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Feb 4 12:35:36 2004 by doxygen 1.2.18 written by Dimitri van Heesch, © 1997-2003