diff --git a/kdecore/util/kgenericfactory.h b/kdecore/util/kgenericfactory.h
index 8d93a70ae4..96fd58ace5 100644
--- a/kdecore/util/kgenericfactory.h
+++ b/kdecore/util/kgenericfactory.h
@@ -1,360 +1,362 @@
 /* This file is part of the KDE project
  * Copyright (C) 2001 Simon Hausmann <hausmann@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 kgenericfactory_h
 #define kgenericfactory_h
 
 #include <klibloader.h>
 #include <kpluginfactory.h>
 #include <kpluginloader.h>
 #include <ktypelist.h>
 #include <kcomponentdata.h>
 #include <kgenericfactory.tcc>
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 
 #ifndef KDE_NO_DEPRECATED
 
 /* @internal */
 template <class T>
 class KGenericFactoryBase : public KPluginFactory
 {
 public:
     explicit KGenericFactoryBase(const char *componentName, const char *catalogName)
         : KPluginFactory(componentName, catalogName)
     {
         s_self = this;
         s_createComponentDataCalled = false;
     }
 
     explicit KGenericFactoryBase( const KAboutData *data )
         : KPluginFactory(data)
     {
         s_self = this;
         s_createComponentDataCalled = false;
     }
 
     virtual ~KGenericFactoryBase()
     {
         s_self = 0;
     }
 
     static KComponentData componentData()
     {
         Q_ASSERT(s_self);
         if (!s_createComponentDataCalled) {
             s_createComponentDataCalled = true;
 
             KComponentData *kcd = s_self->createComponentData();
             Q_ASSERT(kcd);
             s_self->setComponentData(*kcd);
             delete kcd;
         }
         return static_cast<KPluginFactory *>(s_self)->componentData();
     }
 
 protected:
     virtual KComponentData *createComponentData()
     {
         return new KComponentData(componentData());
     }
 
 private:
     static bool s_createComponentDataCalled;
     static KGenericFactoryBase<T> *s_self;
 };
 
 /* @internal */
 template <class T>
 KGenericFactoryBase<T> *KGenericFactoryBase<T>::s_self = 0;
 
 /* @internal */
 template <class T>
 bool KGenericFactoryBase<T>::s_createComponentDataCalled = false;
 
 /**
  * This template provides a generic implementation of a KLibFactory ,
  * for use with shared library components. It implements the pure virtual
  * createObject method of KLibFactory and instantiates objects of the
  * specified class (template argument) when the class name argument of
  * createObject matches a class name in the given hierarchy.
  *
  * In case you are developing a KParts component, skip this file and
  * go directly to KParts::GenericFactory .
  *
  * Note that the class specified as template argument needs to provide
  * a certain constructor:
  * <ul>
  *     <li>If the class is derived from QObject then it needs to have
  *         a constructor like:
  *         <code>MyClass( QObject *parent,
  *                        const QStringList &args );</code>
  *     <li>If the class is derived from QWidget then it needs to have
  *         a constructor like:
  *         <code>MyWidget( QWidget *parent,
  *                         const QStringList &args);</code>
  *     <li>If the class is derived from KParts::Part then it needs to have
  *         a constructor like:
  *         <code>MyPart( QWidget *parentWidget,
  *                       QObject *parent,
  *                       const QStringList &args );</code>
  * </ul>
  * The args QStringList passed to the constructor is the args string list
  * that the caller passed to KLibFactory's create method.
  *
  * In addition upon instantiation this template provides a central
  * KComponentData object for your component, accessible through the
  * static componentData() method. The componentName and catalogName arguments
  * of the KGenericFactory constructor are passed to the KComponentData object.
  *
  * The creation of the KComponentData object can be customized by inheriting
  * from this template class and re-implementing the virtual createComponentData
  * method. For example it could look like this:
  * \code
  *     KComponentData *MyFactory::createComponentData()
  *     {
  *         return new KComponentData( myAboutData );
  *     }
  * \endcode
  *
  * Example of usage of the whole template:
  * \code
  *     class MyPlugin : public KParts::Plugin
  *     {
  *         Q_ OBJECT
  *     public:
  *         MyPlugin( QObject *parent, const QStringList &args );
  *         ...
  *     };
  *
  *     K_EXPORT_COMPONENT_FACTORY( libmyplugin, KGenericFactory<MyPlugin> )
  * \endcode
+ *
+ * @deprecated use KPluginFactory
  */
 template <class Product, class ParentType = QObject>
 class KDE_DEPRECATED KGenericFactory : public KGenericFactoryBase<Product>
 {
 public:
     explicit KGenericFactory( const char *componentName = 0, const char *catalogName = 0 )
         : KGenericFactoryBase<Product>(componentName, catalogName)
     {}
 
     explicit KGenericFactory( const KAboutData *data )
         : KGenericFactoryBase<Product>(data)
     {}
 
 protected:
     virtual QObject *createObject( QObject *parent,
                                    const char *className, const QStringList &args )
     {
         return KDEPrivate::ConcreteFactory<Product, ParentType>
             ::create( 0, parent, className, args );
     }
 };
 
 /**
  * \class KGenericFactory kgenericfactory.h <KGenericFactory>
  * 
  * This template provides a generic implementation of a KLibFactory ,
  * for use with shared library components. It implements the pure virtual
  * createObject method of KLibFactory and instantiates objects of the
  * specified classes in the given typelist template argument when the class
  * name argument of createObject matches a class names in the given hierarchy
  * of classes.
  *
  * Note that each class in the specified in the typelist template argument
  * needs to provide a certain constructor:
  * <ul>
  *     <li>If the class is derived from QObject then it needs to have
  *         a constructor like:
  *         <code>MyClass( QObject *parent,
  *                        const QStringList &args );</code>
  *     <li>If the class is derived from QWidget then it needs to have
  *         a constructor like:
  *         <code>MyWidget( QWidget *parent,
  *                         const QStringList &args);</code>
  *     <li>If the class is derived from KParts::Part then it needs to have
  *         a constructor like:
  *         <code>MyPart( QWidget *parentWidget,
  *                       QObject *parent,
  *                       const QStringList &args );</code>
  * </ul>
  * The args QStringList passed to the constructor is the args string list
  * that the caller passed to KLibFactory's create method.
  *
  * In addition upon instantiation this template provides a central
  * KComponentData object for your component, accessible through the
  * static componentData() method. The componentName and catalogName arguments
  * of the KGenericFactory constructor are passed to the KComponentData object.
  *
  * The creation of the KComponentData object can be customized by inheriting
  * from this template class and re-implementing the virtual createComponentData
  * method. For example it could look like this:
  * \code
  *     KComponentData *MyFactory::createComponentData()
  *     {
  *         return new KComponentData( myAboutData );
  *     }
  * \endcode
  *
  * Example of usage of the whole template:
  * \code
  *     class MyPlugin : public KParts::Plugin
  *     {
  *         Q_ OBJECT
  *     public:
  *         MyPlugin( QObject *parent,
  *                   const QStringList &args );
  *         ...
  *     };
  *
  *     class MyDialogComponent : public KDialog
  *     {
  *         Q_ OBJECT
  *     public:
  *         MyDialogComponent( QWidget *parentWidget,
  *                            const QStringList &args );
  *         ...
  *     };
  *
  *     typedef K_TYPELIST_2( MyPlugin, MyDialogComponent ) Products;
  *     K_EXPORT_COMPONENT_FACTORY( libmyplugin, KGenericFactory<Products> )
  * \endcode
  */
 template <class Product, class ProductListTail>
 class KGenericFactory< KTypeList<Product, ProductListTail>, QObject >
     : public KGenericFactoryBase<KTypeList<Product, ProductListTail> >
 {
 public:
     explicit KGenericFactory( const char *componentName  = 0, const char *catalogName  = 0 )
         : KGenericFactoryBase<KTypeList<Product, ProductListTail> >(componentName, catalogName)
     {}
 
     explicit KGenericFactory( const KAboutData *data )
         : KGenericFactoryBase<KTypeList<Product, ProductListTail> >(data)
     {}
 
 
 protected:
     virtual QObject *createObject( QObject *parent,
                                    const char *className, const QStringList &args )
     {
         return KDEPrivate::MultiFactory< KTypeList< Product, ProductListTail > >
             ::create( 0, parent, className, args );
     }
 };
 
 /**
  * \class KGenericFactory kgenericfactory.h <KGenericFactory>
  * 
  * This template provides a generic implementation of a KLibFactory ,
  * for use with shared library components. It implements the pure virtual
  * createObject method of KLibFactory and instantiates objects of the
  * specified classes in the given typelist template argument when the class
  * name argument of createObject matches a class names in the given hierarchy
  * of classes.
  *
  * Note that each class in the specified in the typelist template argument
  * needs to provide a certain constructor:
  * <ul>
  *     <li>If the class is derived from QObject then it needs to have
  *         a constructor like:
  *         <code>MyClass( QObject *parent,
  *                        const QStringList &args );</code>
  *     <li>If the class is derived from QWidget then it needs to have
  *         a constructor like:
  *         <code>MyWidget( QWidget *parent,
  *                         const QStringList &args);</code>
  *     <li>If the class is derived from KParts::Part then it needs to have
  *         a constructor like:
  *         <code>MyPart( QWidget *parentWidget,
  *                       QObject *parent,
  *                       const QStringList &args );</code>
  * </ul>
  * The args QStringList passed to the constructor is the args string list
  * that the caller passed to KLibFactory's create method.
  *
  * In addition upon instantiation this template provides a central
  * KComponentData object for your component, accessible through the
  * static componentData() method. The componentName and catalogNames arguments
  * of the KGenericFactory constructor are passed to the KComponentData object.
  *
  * The creation of the KComponentData object can be customized by inheriting
  * from this template class and re-implementing the virtual createComponentData
  * method. For example it could look like this:
  * \code
  *     KComponentData *MyFactory::createComponentData()
  *     {
  *         return new KComponentData( myAboutData );
  *     }
  * \endcode
  *
  * Example of usage of the whole template:
  * \code
  *     class MyPlugin : public KParts::Plugin
  *     {
  *         Q_ OBJECT
  *     public:
  *         MyPlugin( QObject *parent,
  *                   const QStringList &args );
  *         ...
  *     };
  *
  *     class MyDialogComponent : public KDialog
  *     {
  *         Q_ OBJECT
  *     public:
  *         MyDialogComponent( QWidget *parentWidget,
  *                            const QStringList &args );
  *         ...
  *     };
  *
  *     typedef K_TYPELIST_2( MyPlugin, MyDialogComponent ) Products;
  *     K_EXPORT_COMPONENT_FACTORY( libmyplugin, KGenericFactory<Products> )
  * \endcode
  */
 template <class Product, class ProductListTail,
           class ParentType, class ParentTypeListTail>
 class KGenericFactory< KTypeList<Product, ProductListTail>,
                        KTypeList<ParentType, ParentTypeListTail> >
     : public KGenericFactoryBase<KTypeList<Product, ProductListTail> >
 {
 public:
     explicit KGenericFactory( const char *componentName  = 0, const char *catalogName  = 0 )
         : KGenericFactoryBase<KTypeList<Product, ProductListTail> >(componentName, catalogName)
     {}
     explicit KGenericFactory( const KAboutData *data )
         : KGenericFactoryBase<KTypeList<Product, ProductListTail> >(data)
     {}
 
 
 protected:
     virtual QObject *createObject( QObject *parent,
                                    const char *className, const QStringList &args )
     {
         return KDEPrivate::MultiFactory< KTypeList< Product, ProductListTail >,
                                          KTypeList< ParentType, ParentTypeListTail > >
                                        ::create( 0, 0, parent,
                                                  className, args );
     }
 };
 
 #endif
 #endif