Source: genericfactory.h

# Source: genericfactory.h |
Annotated List
Files
Globals
Hierarchy
Index

    #ifndef __kparts__genericfactory_h__
    #define __kparts__genericfactory_h__

    #include
    #include
    #include
    #include
    #include

    namespace KParts
    {

        /**
         * @internal
         */
        template
        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 KInstance *instance();
            static KAboutData *aboutData();

        protected:
            virtual KInstance *createInstance()
            {
                return new KInstance( aboutData() );
            }

        private:
            static GenericFactoryBase *s_self;
            static KInstance *s_instance;
            static KAboutData *s_aboutData;
        };

        /**
         * A template for a KParts::Factory implementation. It implements the pure virtual
         * createPartObject method by instantiating the template argument when requested
         * through the className field. In addition it is a container for a part's @ref KInstance
         * object, by providing a static KInstance *instance() method.
         *
         * The template argument has to inherit from KParts::Part and has to implement two methods:
         *  1) There needs to be a public constructor with the following signature:
         *         MyPart( QWidget *parentWidget, const char *widgetName, QObject *parent, const char *name, const QStringList& args )
         *
         *  2) It needs to provide one static method to create a @ref KAboutData object per
         *     request, holding information about the component's name, its authors, license, etc.
         *     The signature of that static method has to be
         *         KAboutData *createAboutData()
         *
         * The template will take care of memory management of the KInstance and the KAboutData object.
         *
         * For advanced use you can also inherit from the template and re-implement additionally the
         * virtual KInstance *createInstance() method, for example in case you want to extend the
         * paths of your instance's KStandardDirs object.
         *
         * If a KParts::ReadOnlyPart is requested through this factory and the template argument
         * implements a KParts::ReadWritePart then setReadWrite( false ) will automatically be
         * called in createPartObject.
         *
         * Use the factory through the K_EXPORT_COMPONENT_FACTORY macro, like that:
         *
         * typedef KParts::GenericFactory<YourKPart> YourKPartFactory;
         * K_EXPORT_COMPONENT_FACTORY( yourlibrary, YourKPartFactory );
         *
         * yourlibrary is the library name that you compiled your KPart into.
         */
        template
        class GenericFactory : public GenericFactoryBase
        {
        public:
            GenericFactory() { }

            virtual KParts::Part *createPartObject( QWidget *parentWidget, const char *widgetName,
                                                    QObject *parent, const char *name,
                                                    const char *className,
                                                    const QStringList &args )
            {
                T *part = KDEPrivate::ConcreteFactory::create( parentWidget,
                                                                  widgetName,
                                                                  parent,
                                                                  name,
                                                                  className,
                                                                  args );

                if ( part && !qstrcmp( className, "KParts::ReadOnlyPart" ) )
                {
                    KParts::ReadWritePart *rwp = dynamic_cast( part );
                    if ( rwp )
                        rwp->setReadWrite( false );
                }
                return part;
            }
        };

        template
        class GenericFactory< KTypeList > : public GenericFactoryBase
        {
        public:
            GenericFactory() { }

            virtual KParts::Part *createPartObject( QWidget *parentWidget, const char *widgetName,
                                                    QObject *parent, const char *name,
                                                    const char *className,
                                                    const QStringList &args )
            {
                QObject *object = KDEPrivate::MultiFactory< KTypeList >::create( parentWidget,
                                                                                         widgetName,
                                                                                         parent, name,
                                                                                         className,
                                                                                         args );

                // (this cast is guaranteed to work...)
                KParts::Part *part = dynamic_cast( object );

                if ( part && !qstrcmp( className, "KParts::ReadOnlyPart" ) )
                {
                    KParts::ReadWritePart *rwp = dynamic_cast( part );
                    if ( rwp )
                        rwp->setReadWrite( false );
                }
                return part;
            }
        };

        /**
         * @internal
         */
        template
        GenericFactoryBase *GenericFactoryBase::s_self = 0;

        /**
         * @internal
         */
        template
        KInstance *GenericFactoryBase::s_instance = 0;

        /**
         * @internal
         */
        template
        KAboutData *GenericFactoryBase::s_aboutData = 0;

        /**
         * @internal
         */
        template
        KInstance *GenericFactoryBase::instance()
        {
            if ( !s_instance )
            {
                if ( s_self )
                    s_instance = s_self->createInstance();
                else
                    s_instance = new KInstance( aboutData() );
            }
            return s_instance;
        }

        /**
         * @internal
         */
        template
        KAboutData *GenericFactoryBase::aboutData()
        {
            if ( !s_aboutData )
                s_aboutData = T::createAboutData();
            return s_aboutData;
        }

    }

    #endif

    /**
     * vim: et sw=4
     */

Generated by: root on macppc.ports.openbsd.org on Sat Sep 6 10:37:24 2003, using kdoc 2.0a54.