API documentation

24 files changed, 795 insertions, 48 deletions

diff --git a/cppuhelper/inc/cppuhelper/compbase1.hxx b/cppuhelper/inc/cppuhelper/compbase1.hxx
index 911106ae2b29..5fe0b65b83bd 100644
--- a/cppuhelper/inc/cppuhelper/compbase1.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase1.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase1.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 1 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1 >
     class WeakComponentImplHelper1
         : public ::cppu::OWeakObject
@@ -83,6 +96,9 @@ namespace cppu
         static ClassData1 s_aCD;
     protected:
         ::cppu::OBroadcastHelper rBHelper;
+
+        /** Is called upon disposing the component.
+        */
         virtual void SAL_CALL disposing()
             {}
     public:
@@ -138,6 +154,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1 >
     class WeakAggComponentImplHelper1
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase10.hxx b/cppuhelper/inc/cppuhelper/compbase10.hxx
index d5780525f255..dc3bbec95205 100644
--- a/cppuhelper/inc/cppuhelper/compbase10.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase10.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase10.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 10 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10 >
     class WeakComponentImplHelper10
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10 >
     class WeakAggComponentImplHelper10
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase11.hxx b/cppuhelper/inc/cppuhelper/compbase11.hxx
index e5381a5bdd45..8cea77395c85 100644
--- a/cppuhelper/inc/cppuhelper/compbase11.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase11.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase11.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 11 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11 >
     class WeakComponentImplHelper11
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11 >
     class WeakAggComponentImplHelper11
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase12.hxx b/cppuhelper/inc/cppuhelper/compbase12.hxx
index fac0d4a81b29..09c18ec88012 100644
--- a/cppuhelper/inc/cppuhelper/compbase12.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase12.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase12.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 12 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11, class Ifc12 >
     class WeakComponentImplHelper12
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11, class Ifc12 >
     class WeakAggComponentImplHelper12
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase2.hxx b/cppuhelper/inc/cppuhelper/compbase2.hxx
index bd3f22dd8f09..9d69e369f94d 100644
--- a/cppuhelper/inc/cppuhelper/compbase2.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase2.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase2.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -75,6 +75,19 @@ __DEF_COMPIMPLHELPER( 2 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2 >
     class WeakComponentImplHelper2
         : public ::cppu::OWeakObject
@@ -139,6 +152,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2 >
     class WeakAggComponentImplHelper2
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase3.hxx b/cppuhelper/inc/cppuhelper/compbase3.hxx
index 7c7de0bcc915..a5376a787f7d 100644
--- a/cppuhelper/inc/cppuhelper/compbase3.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase3.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase3.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 3 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3 >
     class WeakComponentImplHelper3
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3 >
     class WeakAggComponentImplHelper3
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase4.hxx b/cppuhelper/inc/cppuhelper/compbase4.hxx
index c4d8a9e86ec3..2090ca7a650f 100644
--- a/cppuhelper/inc/cppuhelper/compbase4.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase4.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase4.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 4 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4 >
     class WeakComponentImplHelper4
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4 >
     class WeakAggComponentImplHelper4
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase5.hxx b/cppuhelper/inc/cppuhelper/compbase5.hxx
index 0bfc5613c777..5fa8338bc093 100644
--- a/cppuhelper/inc/cppuhelper/compbase5.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase5.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase5.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 5 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5 >
     class WeakComponentImplHelper5
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5 >
     class WeakAggComponentImplHelper5
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase6.hxx b/cppuhelper/inc/cppuhelper/compbase6.hxx
index faed33137379..26c8db5b1f29 100644
--- a/cppuhelper/inc/cppuhelper/compbase6.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase6.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase6.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 6 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6 >
     class WeakComponentImplHelper6
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6 >
     class WeakAggComponentImplHelper6
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase7.hxx b/cppuhelper/inc/cppuhelper/compbase7.hxx
index ed95a1400fa5..3fd25972d8aa 100644
--- a/cppuhelper/inc/cppuhelper/compbase7.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase7.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase7.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 7 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7 >
     class WeakComponentImplHelper7
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7 >
     class WeakAggComponentImplHelper7
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase8.hxx b/cppuhelper/inc/cppuhelper/compbase8.hxx
index b10b14128830..97df09ff7fbd 100644
--- a/cppuhelper/inc/cppuhelper/compbase8.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase8.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase8.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 8 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8 >
     class WeakComponentImplHelper8
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8 >
     class WeakAggComponentImplHelper8
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/compbase9.hxx b/cppuhelper/inc/cppuhelper/compbase9.hxx
index 069d53e0032b..094f4c1c48ec 100644
--- a/cppuhelper/inc/cppuhelper/compbase9.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase9.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: compbase9.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -74,6 +74,19 @@ __DEF_COMPIMPLHELPER( 9 )
 
 namespace cppu
 {
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9 >
     class WeakComponentImplHelper9
         : public ::cppu::OWeakObject
@@ -138,6 +151,19 @@ namespace cppu
                 rBHelper.removeListener( ::getCppuType( &xListener ), xListener );
             }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<>, com.sun.star.lang.XComponent
+        and ::cppu::OWeakAggObject, thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+        The template class expects a C++ mutex reference for synchronization in its ctor.
+        The com.sun.star.lang.XComponent implementation fires a final disposing() call
+        to the implementation when the component is to be disposed.  So implement disposing()
+        when sub-classing.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggComponentImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9 >
     class WeakAggComponentImplHelper9
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase1.hxx b/cppuhelper/inc/cppuhelper/implbase1.hxx
index 093abc97b3c4..6d8aa1a1901b 100644
--- a/cppuhelper/inc/cppuhelper/implbase1.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase1.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase1.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -83,6 +83,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1 >
     class ImplHelperBase1
         : public ::com::sun::star::lang::XTypeProvider
@@ -106,6 +116,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1 >
     class ImplHelper1
         : public ImplHelperBase1< Ifc1 >
@@ -119,6 +137,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1 >
     class WeakImplHelper1
         : public ::cppu::OWeakObject
@@ -140,6 +167,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1 >
     class WeakAggImplHelper1
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase10.hxx b/cppuhelper/inc/cppuhelper/implbase10.hxx
index baa11557b4a1..e3b531d9ef73 100644
--- a/cppuhelper/inc/cppuhelper/implbase10.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase10.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase10.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -85,6 +85,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10 >
     class ImplHelperBase10
         : public ::com::sun::star::lang::XTypeProvider
@@ -126,6 +136,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10 >
     class ImplHelper10
         : public ImplHelperBase10< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6, Ifc7, Ifc8, Ifc9, Ifc10 >
@@ -139,6 +157,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10 >
     class WeakImplHelper10
         : public ::cppu::OWeakObject
@@ -160,6 +187,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10 >
     class WeakAggImplHelper10
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase11.hxx b/cppuhelper/inc/cppuhelper/implbase11.hxx
index 37289279bd8b..79f1980e00e4 100644
--- a/cppuhelper/inc/cppuhelper/implbase11.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase11.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase11.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -85,6 +85,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11 >
     class ImplHelperBase11
         : public ::com::sun::star::lang::XTypeProvider
@@ -128,6 +138,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11 >
     class ImplHelper11
         : public ImplHelperBase11< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6, Ifc7, Ifc8, Ifc9, Ifc10, Ifc11 >
@@ -141,6 +159,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11 >
     class WeakImplHelper11
         : public ::cppu::OWeakObject
@@ -162,6 +189,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11 >
     class WeakAggImplHelper11
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase12.hxx b/cppuhelper/inc/cppuhelper/implbase12.hxx
index d148ccf1807b..e63b786d2883 100644
--- a/cppuhelper/inc/cppuhelper/implbase12.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase12.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase12.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -85,6 +85,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11, class Ifc12 >
     class ImplHelperBase12
         : public ::com::sun::star::lang::XTypeProvider
@@ -130,6 +140,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11, class Ifc12 >
     class ImplHelper12
         : public ImplHelperBase12< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6, Ifc7, Ifc8, Ifc9, Ifc10, Ifc11, Ifc12 >
@@ -143,6 +161,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11, class Ifc12 >
     class WeakImplHelper12
         : public ::cppu::OWeakObject
@@ -164,6 +191,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9, class Ifc10, class Ifc11, class Ifc12 >
     class WeakAggImplHelper12
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase2.hxx b/cppuhelper/inc/cppuhelper/implbase2.hxx
index 65cf7adc731c..88eaeb55b17b 100644
--- a/cppuhelper/inc/cppuhelper/implbase2.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase2.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase2.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -84,6 +84,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2 >
     class ImplHelperBase2
         : public ::com::sun::star::lang::XTypeProvider
@@ -109,6 +119,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2 >
     class ImplHelper2
         : public ImplHelperBase2< Ifc1, Ifc2 >
@@ -122,6 +140,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2 >
     class WeakImplHelper2
         : public ::cppu::OWeakObject
@@ -143,6 +170,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2 >
     class WeakAggImplHelper2
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase3.hxx b/cppuhelper/inc/cppuhelper/implbase3.hxx
index 939f02c838a4..830120bc8eae 100644
--- a/cppuhelper/inc/cppuhelper/implbase3.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase3.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase3.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -83,6 +83,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3 >
     class ImplHelperBase3
         : public ::com::sun::star::lang::XTypeProvider
@@ -110,6 +120,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3 >
     class ImplHelper3
         : public ImplHelperBase3< Ifc1, Ifc2, Ifc3 >
@@ -123,6 +141,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3 >
     class WeakImplHelper3
         : public ::cppu::OWeakObject
@@ -144,6 +171,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3 >
     class WeakAggImplHelper3
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase4.hxx b/cppuhelper/inc/cppuhelper/implbase4.hxx
index c74e212cc19f..b7319af97f12 100644
--- a/cppuhelper/inc/cppuhelper/implbase4.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase4.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase4.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -83,6 +83,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4 >
     class ImplHelperBase4
         : public ::com::sun::star::lang::XTypeProvider
@@ -112,6 +122,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4 >
     class ImplHelper4
         : public ImplHelperBase4< Ifc1, Ifc2, Ifc3, Ifc4 >
@@ -125,6 +143,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4 >
     class WeakImplHelper4
         : public ::cppu::OWeakObject
@@ -146,6 +173,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4 >
     class WeakAggImplHelper4
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase5.hxx b/cppuhelper/inc/cppuhelper/implbase5.hxx
index f62df07b1ca5..05c5804d4026 100644
--- a/cppuhelper/inc/cppuhelper/implbase5.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase5.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase5.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -84,6 +84,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5 >
     class ImplHelperBase5
         : public ::com::sun::star::lang::XTypeProvider
@@ -115,6 +125,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5 >
     class ImplHelper5
         : public ImplHelperBase5< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5 >
@@ -128,6 +146,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5 >
     class WeakImplHelper5
         : public ::cppu::OWeakObject
@@ -149,6 +176,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5 >
     class WeakAggImplHelper5
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase6.hxx b/cppuhelper/inc/cppuhelper/implbase6.hxx
index 3ee92ae0fc0e..55793bd23b8b 100644
--- a/cppuhelper/inc/cppuhelper/implbase6.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase6.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase6.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -84,6 +84,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6 >
     class ImplHelperBase6
         : public ::com::sun::star::lang::XTypeProvider
@@ -117,6 +127,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6 >
     class ImplHelper6
         : public ImplHelperBase6< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6 >
@@ -130,6 +148,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6 >
     class WeakImplHelper6
         : public ::cppu::OWeakObject
@@ -151,6 +178,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6 >
     class WeakAggImplHelper6
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase7.hxx b/cppuhelper/inc/cppuhelper/implbase7.hxx
index 31cc2510fef7..52dcb866658d 100644
--- a/cppuhelper/inc/cppuhelper/implbase7.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase7.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase7.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -84,6 +84,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7 >
     class ImplHelperBase7
         : public ::com::sun::star::lang::XTypeProvider
@@ -119,6 +129,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7 >
     class ImplHelper7
         : public ImplHelperBase7< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6, Ifc7 >
@@ -132,6 +150,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7 >
     class WeakImplHelper7
         : public ::cppu::OWeakObject
@@ -153,6 +180,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7 >
     class WeakAggImplHelper7
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase8.hxx b/cppuhelper/inc/cppuhelper/implbase8.hxx
index 186f1fc102ac..e807934b2888 100644
--- a/cppuhelper/inc/cppuhelper/implbase8.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase8.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase8.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -84,6 +84,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8 >
     class ImplHelperBase8
         : public ::com::sun::star::lang::XTypeProvider
@@ -121,6 +131,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8 >
     class ImplHelper8
         : public ImplHelperBase8< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6, Ifc7, Ifc8 >
@@ -134,6 +152,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8 >
     class WeakImplHelper8
         : public ::cppu::OWeakObject
@@ -155,6 +182,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8 >
     class WeakAggImplHelper8
         : public ::cppu::OWeakAggObject
diff --git a/cppuhelper/inc/cppuhelper/implbase9.hxx b/cppuhelper/inc/cppuhelper/implbase9.hxx
index 44969b428a12..e99dcae2809b 100644
--- a/cppuhelper/inc/cppuhelper/implbase9.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase9.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: implbase9.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: dbo $ $Date: 2001-03-15 15:47:29 $
+ *  last change: $Author: dbo $ $Date: 2001-05-14 11:58:06 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -86,6 +86,16 @@ namespace cppu
             : ClassDataBase( nClassCode )
             {}
     };
+    /** This template class serves as a base class for all subsequent implementation helper classes.
+        It inherits from given interfaces (template parameters) and com.sun.star.lang.XTypeProvider.
+
+        Do not use this class directly, use
+               ImplHelperBaseN<>,
+               WeakImplHelperN<>,
+               WeakAggImplHelperN<>
+               WeakComponentImplHelperN<>,
+               WeakAggComponentImplHelperN<>.
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9 >
     class ImplHelperBase9
         : public ::com::sun::star::lang::XTypeProvider
@@ -125,6 +135,14 @@ namespace cppu
                 return rCD;
             }
     };
+    /** This template class inherits from ImplHelperBaseN<> and implements
+        com.sun.star.uno.XInterface::queryInterface() and the com.sun.star.lang.XTypeProvider
+        interface.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::ImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9 >
     class ImplHelper9
         : public ImplHelperBase9< Ifc1, Ifc2, Ifc3, Ifc4, Ifc5, Ifc6, Ifc7, Ifc8, Ifc9 >
@@ -138,6 +156,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly, using the
+        ::cppu::WeakReference<> template class.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9 >
     class WeakImplHelper9
         : public ::cppu::OWeakObject
@@ -159,6 +186,15 @@ namespace cppu
         virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException)
             { return getClassData( s_aCD ).getImplementationId(); }
     };
+    /** This template class inherits from ::cppu::ImplHelperBaseN<> and ::cppu::OWeakAggObject,
+        thus delegating life-cycle to that implementation.
+        Use this helper implementing an object, that can be held weakly using the
+        ::cppu::WeakReference<> template class and can be aggregated by other objects.
+
+        All other virtual functions (inherited from given template parameter interfaces)
+        have to be implemented by sub-classing from the templated class, e.g.
+        class MyImpl : public ::cppu::WeakAggImplHelperN<> { ... };
+    */
     template< class Ifc1, class Ifc2, class Ifc3, class Ifc4, class Ifc5, class Ifc6, class Ifc7, class Ifc8, class Ifc9 >
     class WeakAggImplHelper9
         : public ::cppu::OWeakAggObject