#i105323# added documentation to primitives

19 files changed, 332 insertions, 137 deletions

diff --git a/drawinglayer/inc/drawinglayer/primitive3d/baseprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/baseprimitive3d.hxx
index 73d28c82ebda..9bf56edb2c53 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/baseprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/baseprimitive3d.hxx
@@ -76,7 +76,9 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        /** Baseclass for all C++ implementations of com::sun::star::graphic::XPrimitive2D
+        /** BasePrimitive3D class
+
+            Baseclass for all C++ implementations of com::sun::star::graphic::XPrimitive2D
 
             The description/functionality is identical with the 2D case in baseprimitive2d.hxx,
             please see there for detailed information.
@@ -85,6 +87,8 @@ namespace drawinglayer
 
             - PolygonHairlinePrimitive3D (for 3D hairlines)
             - PolyPolygonMaterialPrimitive3D (for 3D filled plane polygons)
+
+            That's all for 3D!
          */
         class BasePrimitive3D
         :   private boost::noncopyable,
@@ -144,7 +148,9 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        /** Baseclass for all C++ implementations of com::sun::star::graphic::XPrimitive2D
+        /** BufferedDecompositionPrimitive3D class
+
+            Baseclass for all C++ implementations of com::sun::star::graphic::XPrimitive2D
 
             The description/functionality is identical with the 2D case in baseprimitive2d.hxx,
             please see there for detailed information
@@ -191,23 +197,24 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        // get B3DRange from a given Primitive3DReference
+        /// get B3DRange from a given Primitive3DReference
         basegfx::B3DRange getB3DRangeFromPrimitive3DReference(const Primitive3DReference& rCandidate, const geometry::ViewInformation3D& aViewInformation);
 
-        // get range3D from a given Primitive3DSequence
+        /// get range3D from a given Primitive3DSequence
         basegfx::B3DRange getB3DRangeFromPrimitive3DSequence(const Primitive3DSequence& rCandidate, const geometry::ViewInformation3D& aViewInformation);
 
-        // compare two Primitive2DReferences for equality, including trying to get implementations (BasePrimitive2D)
-        // and using compare operator
+        /** compare two Primitive2DReferences for equality, including trying to get implementations (BasePrimitive2D)
+            and using compare operator
+         */
         bool arePrimitive3DReferencesEqual(const Primitive3DReference& rA, const Primitive3DReference& rB);
 
-        // compare two Primitive3DReferences for equality, uses arePrimitive3DReferencesEqual internally
+        /// compare two Primitive3DReferences for equality, uses arePrimitive3DReferencesEqual internally
         bool arePrimitive3DSequencesEqual(const Primitive3DSequence& rA, const Primitive3DSequence& rB);
 
-        // concatenate sequence
+        /// concatenate sequence
         void appendPrimitive3DSequenceToPrimitive3DSequence(Primitive3DSequence& rDest, const Primitive3DSequence& rSource);
 
-        // concatenate single Primitive3D
+        /// concatenate single Primitive3D
         void appendPrimitive3DReferenceToPrimitive3DSequence(Primitive3DSequence& rDest, const Primitive3DReference& rSource);
 
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/groupprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/groupprimitive3d.hxx
index 6912ff25b04d..69e406c75d67 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/groupprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/groupprimitive3d.hxx
@@ -44,7 +44,9 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        /** Baseclass for all grouping 3D primitives
+        /** GroupPrimitive3D class
+
+            Baseclass for all grouping 3D primitives
 
             The description/functionality is identical with the 2D case in groupprimitive2d.hxx,
             please see there for detailed information.
@@ -64,23 +66,23 @@ namespace drawinglayer
         class GroupPrimitive3D : public BasePrimitive3D
         {
         private:
-            // the children. Declared private since this shall never be changed at all after construction
+            /// the children. Declared private since this shall never be changed at all after construction
             Primitive3DSequence                             maChildren;
 
         public:
-            // constructor
+            /// constructor
             GroupPrimitive3D(const Primitive3DSequence& rChildren);
 
-            // data access
+            /// data read access
             Primitive3DSequence getChildren() const { return maChildren; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==( const BasePrimitive3D& rPrimitive ) const;
 
-            // local decomposition. Implementation will just return children
+            /// local decomposition. Implementation will just return children
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx
index 2e1d7e0b5fe4..2675a1284779 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx
@@ -44,7 +44,9 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        /** HatchTexturePrimitive3D is derived from GroupPrimitive3D, but implements
+        /** HatchTexturePrimitive3D class
+
+            HatchTexturePrimitive3D is derived from GroupPrimitive3D, but implements
             a decomposition which is complicated enough for buffering. Since the group
             primitive has no default buffering, it is necessary here to add a local
             buffering mechanism for the decomposition
@@ -52,7 +54,10 @@ namespace drawinglayer
         class HatchTexturePrimitive3D : public TexturePrimitive3D
         {
         private:
+            /// the hatch definition
             attribute::FillHatchAttribute                   maHatch;
+
+            /// the buffered decomposed hatch
             Primitive3DSequence                             maBuffered3DDecomposition;
 
         protected:
@@ -64,6 +69,7 @@ namespace drawinglayer
             void setBuffered3DDecomposition(const Primitive3DSequence& rNew) { maBuffered3DDecomposition = rNew; }
 
         public:
+            /// constructor
             HatchTexturePrimitive3D(
                 const attribute::FillHatchAttribute& rHatch,
                 const Primitive3DSequence& rChildren,
@@ -71,16 +77,16 @@ namespace drawinglayer
                 bool bModulate,
                 bool bFilter);
 
-            // get data
+            /// data read access
             const attribute::FillHatchAttribute& getHatch() const { return maHatch; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/hittestprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/hittestprimitive3d.hxx
index 0c5082699e8d..4779241033b0 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/hittestprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/hittestprimitive3d.hxx
@@ -44,31 +44,37 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        // This primitive is used to represent geometry for non-visible objects,
-        // e.g. a 3D cube without fill attributes. To still be able to use
-        // primitives for HitTest functionality, the 3d decompositions produce
-        // an as much as possible simplified fill geometry encapsulated in this
-        // primtive when there is no fill geometry. Currently, the 3d hit test
-        // uses only areas, so maybe in a further enchanced version this will change
-        // to 'if neither filled nor lines' creation criteria. The whole primitive
-        // decomposes to nothing, so no one not knowing it will be influenced. Only
-        // helper processors for hit test (and maybe BoundRect extractors) will
-        // use it and it's children subcontent.
+        /** HitTestPrimitive3D class
+
+            This primitive is used to represent geometry for non-visible objects,
+            e.g. a 3D cube without fill attributes. To still be able to use
+            primitives for HitTest functionality, the 3d decompositions produce
+            an as much as possible simplified fill geometry encapsulated in this
+            primtive when there is no fill geometry. Currently, the 3d hit test
+            uses only areas, so maybe in a further enchanced version this will change
+            to 'if neither filled nor lines' creation criteria. The whole primitive
+            decomposes to nothing, so no one not knowing it will be influenced. Only
+            helper processors for hit test (and maybe BoundRect extractors) will
+            use it and it's children subcontent.
+         */
         class HitTestPrimitive3D : public GroupPrimitive3D
         {
         public:
+            /// constructor
             HitTestPrimitive3D(const Primitive3DSequence& rChildren);
 
-            // despite returning an empty decomposition since it's no visualisation data,
-            // range calculation is intended to use invisible replacement geometry, so
-            // the local implementation will return the children's range
+            /** despite returning an empty decomposition since it's no visualisation data,
+                range calculation is intended to use invisible replacement geometry, so
+                the local implementation will return the children's range
+             */
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // local decomposition. Implementation will return empty Primitive3DSequence
-            // since this is no visualisation data
+            /** local decomposition. Implementation will return empty Primitive3DSequence
+                since this is no visualisation data
+             */
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx
index 0771e8117fc5..3840bf71a397 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx
@@ -45,23 +45,32 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** ModifiedColorPrimitive3D class
+
+            This primitive is a grouping primitive and allows to define
+            how the colors of it's child content shall be modified for
+            visualisation. Please see the ModifiedColorPrimitive2D
+            description for more info.
+         */
         class ModifiedColorPrimitive3D : public GroupPrimitive3D
         {
         private:
+            /// The ColorModifier to use
             basegfx::BColorModifier                 maColorModifier;
 
         public:
+            /// constructor
             ModifiedColorPrimitive3D(
                 const Primitive3DSequence& rChildren,
                 const basegfx::BColorModifier& rColorModifier);
 
-            // get data
+            /// data read access
             const basegfx::BColorModifier& getColorModifier() const { return maColorModifier; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx
index 9b97f60d3642..c73850e4f794 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx
@@ -48,28 +48,40 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** PolygonHairlinePrimitive3D class
+
+            This primitive defines a Hairline in 3D. Since hairlines are view-dependent,
+            this primitive is view-dependent, too.
+
+            This is one of the non-decomposable 3D primitives, so a renderer
+            should proccess it.
+         */
         class PolygonHairlinePrimitive3D : public BasePrimitive3D
         {
         private:
+            /// the hairline geometry
             basegfx::B3DPolygon                     maPolygon;
+
+            /// the hairline color
             basegfx::BColor                         maBColor;
 
         public:
+            /// constructor
             PolygonHairlinePrimitive3D(
                 const basegfx::B3DPolygon& rPolygon,
                 const basegfx::BColor& rBColor);
 
-            // get data
+            /// data read access
             const basegfx::B3DPolygon& getB3DPolygon() const { return maPolygon; }
             const basegfx::BColor& getBColor() const { return maBColor; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
@@ -81,36 +93,49 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** PolygonStrokePrimitive3D class
+
+            This primitive defines a 3D line with line width, line join, line color
+            and stroke attributes. It will be decomposed dependent on the definition
+            to the needed primitives, e.g. filled Tubes for fat lines.
+         */
         class PolygonStrokePrimitive3D : public BufferedDecompositionPrimitive3D
         {
         private:
+            /// the line geometry
             basegfx::B3DPolygon                     maPolygon;
+
+            /// the line attributes like width, join and color
             attribute::LineAttribute                maLineAttribute;
+
+            /// the line stroking (if used)
             attribute::StrokeAttribute              maStrokeAttribute;
 
         protected:
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             PolygonStrokePrimitive3D(
                 const basegfx::B3DPolygon& rPolygon,
                 const attribute::LineAttribute& rLineAttribute,
                 const attribute::StrokeAttribute& rStrokeAttribute);
 
+            /// constructor without stroking
             PolygonStrokePrimitive3D(
                 const basegfx::B3DPolygon& rPolygon,
                 const attribute::LineAttribute& rLineAttribute);
 
-            // get data
+            /// data read access
             basegfx::B3DPolygon getB3DPolygon() const { return maPolygon; }
             const attribute::LineAttribute& getLineAttribute() const { return maLineAttribute; }
             const attribute::StrokeAttribute& getStrokeAttribute() const { return maStrokeAttribute; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx
index 695d16ec7cf5..f5d45f7c1639 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx
@@ -52,13 +52,20 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** PolygonStrokePrimitive3D class
+
+            This 3D primitive extends a 3D hairline to a 3D tube which is
+            e.g. used for fat lines in 3D. It's decomposition will create all
+            3D objects needed for the line tubes and the edge roundings
+            in full 3D.
+         */
         class PolygonTubePrimitive3D : public PolygonHairlinePrimitive3D
         {
         private:
-            // hold the last decompositon since it's expensive
+            /// hold the last decompositon since it's expensive
             Primitive3DSequence                         maLast3DDecomposition;
 
-            // visualisation parameters
+            /// visualisation parameters
             double                                      mfRadius;
             double                                      mfDegreeStepWidth;
             double                                      mfMiterMinimumAngle;
@@ -72,10 +79,11 @@ namespace drawinglayer
             const Primitive3DSequence& getLast3DDecomposition() const { return maLast3DDecomposition; }
             void setLast3DDecomposition(const Primitive3DSequence& rNew) { maLast3DDecomposition = rNew; }
 
-            // local decomposition.
+            /// local decomposition.
             Primitive3DSequence impCreate3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             PolygonTubePrimitive3D(
                 const basegfx::B3DPolygon& rPolygon,
                 const basegfx::BColor& rBColor,
@@ -83,13 +91,13 @@ namespace drawinglayer
                 double fDegreeStepWidth = 10.0 * F_PI180,
                 double fMiterMinimumAngle = 15.0 * F_PI180);
 
-            // get data
+            /// data read access
             double getRadius() const { return mfRadius; }
             double getDegreeStepWidth() const { return mfDegreeStepWidth; }
             double getMiterMinimumAngle() const { return mfMiterMinimumAngle; }
             basegfx::B2DLineJoin getLineJoin() const { return maLineJoin; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
             /** local decomposition. Use own buffering since we are not derived from
@@ -97,7 +105,7 @@ namespace drawinglayer
              */
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
index 1c5b9e400bbb..091e8181e38f 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
@@ -46,33 +46,45 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** PolyPolygonMaterialPrimitive3D class
+
+            This primitive defines a planar 3D PolyPolygon filled with a single color.
+            This is one of the non-decomposable primitives, so a renderer
+            should proccess it.
+
+            It is assumed here that the PolyPolgon is a single plane in 3D.
+         */
         class PolyPolygonMaterialPrimitive3D : public BasePrimitive3D
         {
         private:
+            /// the PolyPolygon geometry
             basegfx::B3DPolyPolygon                     maPolyPolygon;
+
+            /// the fill parameters
             attribute::MaterialAttribute3D              maMaterial;
 
-            // bitfield
+            /// bitfield
             unsigned                                    mbDoubleSided : 1;
 
         public:
+            /// constructor
             PolyPolygonMaterialPrimitive3D(
                 const basegfx::B3DPolyPolygon& rPolyPolygon,
                 const attribute::MaterialAttribute3D& rMaterial,
                 bool bDoubleSided);
 
-            // get data
+            /// data read access
             const basegfx::B3DPolyPolygon& getB3DPolyPolygon() const { return maPolyPolygon; }
             const attribute::MaterialAttribute3D& getMaterial() const { return maMaterial; }
             bool getDoubleSided() const { return mbDoubleSided; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx
index 42a9ab94f327..b3a57f2677dc 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx
@@ -44,26 +44,33 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** SdrCubePrimitive3D class
+
+            This 3D primitive expands the SdrPrimitive3D to a 3D cube definition.
+            The cube is implicitely in unit coordinates and the given transformation
+            defines it's geometry in space.
+         */
         class SdrCubePrimitive3D : public SdrPrimitive3D
         {
         protected:
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             SdrCubePrimitive3D(
                 const basegfx::B3DHomMatrix& rTransform,
                 const basegfx::B2DVector& rTextureSize,
                 const attribute::SdrLineFillShadowAttribute& rSdrLFSAttribute,
                 const attribute::Sdr3DObjectAttribute& rSdr3DObjectAttribute);
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx
index 772e030781fe..5b793a6928f8 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx
@@ -42,6 +42,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 // predefines
+
 namespace basegfx {
     class B3DPolygon;
     class B3DPolyPolygon;
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx
index 43ae13d4625f..b80198d127d2 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx
@@ -53,7 +53,7 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
-        // Slice3D types
+        /** SliceType3D definition */
         enum SliceType3D
         {
             SLICETYPE3D_REGULAR,        // normal geoemtry Slice3D
@@ -61,7 +61,7 @@ namespace drawinglayer
             SLICETYPE3D_BACKCAP         // back cap
         };
 
-        // class to hold one Slice3D
+        /// class to hold one Slice3D
         class Slice3D
         {
         protected:
@@ -92,10 +92,10 @@ namespace drawinglayer
             SliceType3D getSliceType() const { return maSliceType; }
         };
 
-        // typedef for a group of Slice3Ds
+        /// typedef for a group of Slice3Ds
         typedef ::std::vector< Slice3D > Slice3DVector;
 
-        // helpers for creation
+        /// helpers for creation
         void createLatheSlices(
             Slice3DVector& rSliceVector,
             const basegfx::B2DPolyPolygon& rSource,
@@ -117,7 +117,7 @@ namespace drawinglayer
             bool bCloseFront,
             bool bCloseBack);
 
-        // helpers for geometry extraction
+        /// helpers for geometry extraction
         basegfx::B3DPolyPolygon extractHorizontalLinesFromSlice(const Slice3DVector& rSliceVector, bool bCloseHorLines);
         basegfx::B3DPolyPolygon extractVerticalLinesFromSlice(const Slice3DVector& rSliceVector);
 
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
index a5975b050797..a810e0f5ec8e 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
@@ -45,23 +45,34 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** SdrExtrudePrimitive3D class
+
+            This 3D primitive expands the SdrPrimitive3D to a 3D extrude definition.
+            The given 2D PolyPolygon geometry is imagined as lying on the XY-plane in 3D
+            and gets extruded in Z-Direction by Depth.
+
+            Various possibilities e.g. for creating diagonals (edge roudings in 3D)
+            and similar are given.
+
+            The decomposition will create all necessary 3D planes for visualisation.
+         */
         class SdrExtrudePrimitive3D : public SdrPrimitive3D
         {
         private:
-            // geometry helper for slices
+            /// geometry helper for slices
             basegfx::B2DPolyPolygon                     maCorrectedPolyPolygon;
             Slice3DVector                               maSlices;
 
-            // primitive data
+            /// primitive geometry data
             basegfx::B2DPolyPolygon                     maPolyPolygon;
             double                                      mfDepth;
             double                                      mfDiagonal;
             double                                      mfBackScale;
 
-            // decomposition data when ReducedLineGeometry is used, see get3DDecomposition
+            /// decomposition data when ReducedLineGeometry is used, see get3DDecomposition
             geometry::ViewInformation3D*                mpLastRLGViewInformation;
 
-            // bitfield
+            /// bitfield
             unsigned                                    mbSmoothNormals : 1; // Plane self
             unsigned                                    mbSmoothHorizontalNormals : 1; // always
             unsigned                                    mbSmoothLids : 1; // Front/back
@@ -69,17 +80,18 @@ namespace drawinglayer
             unsigned                                    mbCloseFront : 1;
             unsigned                                    mbCloseBack : 1;
 
-            // create slices
+            /// create slices
             void impCreateSlices();
 
-            // get (evtl. create) slices
+            /// get (evtl. create) slices
             const Slice3DVector& getSlices() const;
 
         protected:
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             SdrExtrudePrimitive3D(
                 const basegfx::B3DHomMatrix& rTransform,
                 const basegfx::B2DVector& rTextureSize,
@@ -97,7 +109,7 @@ namespace drawinglayer
                 bool bCloseBack);
             virtual ~SdrExtrudePrimitive3D();
 
-            // data access
+            /// data read access
             const basegfx::B2DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
             double getDepth() const { return mfDepth; }
             double getDiagonal() const { return mfDiagonal; }
@@ -109,16 +121,16 @@ namespace drawinglayer
             bool getCloseFront() const { return mbCloseFront; }
             bool getCloseBack() const { return mbCloseBack; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // Overloaded to allow for reduced line mode to decide if to buffer decomposition or not
+            /// Overloaded to allow for reduced line mode to decide if to buffer decomposition or not
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
index 7d80cbde015c..084ce5bce35e 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
@@ -45,14 +45,25 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** SdrLathePrimitive3D class
+
+            This 3D primitive expands the SdrPrimitive3D to a 3D rotation definition.
+            The given 2D PolyPolygon geometry is imagined as lying on the XY-plane in 3D
+            and gets rotated around the Y-Axis.
+
+            Various possibilities e.g. for creating diagonals (edge roudings in 3D)
+            and similar are given.
+
+            The decomposition will create all necessary 3D planes for visualisation.
+         */
         class SdrLathePrimitive3D : public SdrPrimitive3D
         {
         private:
-            // geometry helper for slices
+            /// geometry helper for slices
             basegfx::B2DPolyPolygon                     maCorrectedPolyPolygon;
             Slice3DVector                               maSlices;
 
-            // primitive data
+            /// primitive geometry data
             basegfx::B2DPolyPolygon                     maPolyPolygon;
             sal_uInt32                                  mnHorizontalSegments;
             sal_uInt32                                  mnVerticalSegments;
@@ -60,10 +71,10 @@ namespace drawinglayer
             double                                      mfBackScale;
             double                                      mfRotation;
 
-            // decomposition data when ReducedLineGeometry is used, see get3DDecomposition
+            /// decomposition data when ReducedLineGeometry is used, see get3DDecomposition
             geometry::ViewInformation3D*                mpLastRLGViewInformation;
 
-            // bitfield
+            /// bitfield
             unsigned                                    mbSmoothNormals : 1; // Plane self
             unsigned                                    mbSmoothHorizontalNormals : 1; // always
             unsigned                                    mbSmoothLids : 1; // Front/back
@@ -71,14 +82,14 @@ namespace drawinglayer
             unsigned                                    mbCloseFront : 1;
             unsigned                                    mbCloseBack : 1;
 
-            // create slices
+            /// create slices
             void impCreateSlices();
 
-            // get (evtl. create) slices
+            /// get (evtl. create) slices
             const Slice3DVector& getSlices() const;
 
         protected:
-            // local helpers
+            /// local helpers
             void impCreateOutlines(
                 const geometry::ViewInformation3D& rViewInformation,
                 const basegfx::B3DPolygon& rLoopA,
@@ -90,10 +101,11 @@ namespace drawinglayer
                 const basegfx::B2DPoint& rStart,
                 const basegfx::B2DPoint& rEnd) const;
 
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             SdrLathePrimitive3D(
                 const basegfx::B3DHomMatrix& rTransform,
                 const basegfx::B2DVector& rTextureSize,
@@ -113,7 +125,7 @@ namespace drawinglayer
                 bool bCloseBack);
             virtual ~SdrLathePrimitive3D();
 
-            // data access
+            /// data read access
             const basegfx::B2DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
             sal_uInt32 getHorizontalSegments() const { return mnHorizontalSegments; }
             sal_uInt32 getVerticalSegments() const { return mnVerticalSegments; }
@@ -127,16 +139,16 @@ namespace drawinglayer
             bool getCloseFront() const { return mbCloseFront; }
             bool getCloseBack() const { return mbCloseBack; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // Overloaded to allow for reduced line mode to decide if to buffer decomposition or not
+            /// Overloaded to allow for reduced line mode to decide if to buffer decomposition or not
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrpolypolygonprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrpolypolygonprimitive3d.hxx
index b0d7cc5c26a2..a6c68bd16da8 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrpolypolygonprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrpolypolygonprimitive3d.hxx
@@ -44,17 +44,28 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** SdrPolyPolygonPrimitive3D class
+
+            This 3D primitive defines a PolyPolgon in space which may have
+            Line- and FillStyles and extra 3D surface attributes. It is assumed
+            that the given 3D PolyPolgon (which may contain texture and normal
+            information) is planar in 3D.
+
+            The decomposition will include all needed 3D data for visualisation,
+            including FatLines and fill styles.
+         */
         class SdrPolyPolygonPrimitive3D : public SdrPrimitive3D
         {
         private:
-            // the polyPolygon evtl with normals and texture coordinates
+            /// the planar polyPolygon evtl with normals and texture coordinates
             basegfx::B3DPolyPolygon                 maPolyPolygon3D;
 
         protected:
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             SdrPolyPolygonPrimitive3D(
                 const basegfx::B3DPolyPolygon& rPolyPolygon3D,
                 const basegfx::B3DHomMatrix& rTransform,
@@ -62,16 +73,16 @@ namespace drawinglayer
                 const attribute::SdrLineFillShadowAttribute& rSdrLFSAttribute,
                 const attribute::Sdr3DObjectAttribute& rSdr3DObjectAttribute);
 
-            // data access
+            /// data access
             const basegfx::B3DPolyPolygon& getPolyPolygon3D() const { return maPolyPolygon3D; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx
index d2296968a000..4dd620848387 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx
@@ -47,43 +47,49 @@
 
 namespace drawinglayer
 {
-    /** base class for the more complicated geometric primitives, so
+    /** SdrPrimitive3D class
+
+        Base class for the more complicated geometric primitives, so
         derive from buffered primitive to allow overloading of
-        create3DDecomposition there
+        create3DDecomposition there.
      */
     namespace primitive3d
     {
         class SdrPrimitive3D : public BufferedDecompositionPrimitive3D
         {
         private:
+            /// object surface attributes
             basegfx::B3DHomMatrix                       maTransform;
             basegfx::B2DVector                          maTextureSize;
             attribute::SdrLineFillShadowAttribute       maSdrLFSAttribute;
             attribute::Sdr3DObjectAttribute             maSdr3DObjectAttribute;
 
         protected:
-            // Standard implementation for primitive3D which
-            // will use maTransform as range and expand by evtl. line width / 2
+            /** Standard implementation for primitive3D which
+                will use maTransform as range and expand by evtl. line width / 2
+             */
             basegfx::B3DRange getStandard3DRange() const;
 
-            // implementation for primitive3D which
-            // will use given Slice3Ds and expand by evtl. line width / 2
+            /** implementation for primitive3D which
+                will use given Slice3Ds and expand by evtl. line width / 2
+             */
             basegfx::B3DRange get3DRangeFromSlices(const Slice3DVector& rSlices) const;
 
         public:
+            /// constructor
             SdrPrimitive3D(
                 const basegfx::B3DHomMatrix& rTransform,
                 const basegfx::B2DVector& rTextureSize,
                 const attribute::SdrLineFillShadowAttribute& rSdrLFSAttribute,
                 const attribute::Sdr3DObjectAttribute& rSdr3DObjectAttribute);
 
-            // data access
+            /// data read access
             const basegfx::B3DHomMatrix& getTransform() const { return maTransform; }
             const basegfx::B2DVector& getTextureSize() const { return maTextureSize; }
             const attribute::SdrLineFillShadowAttribute& getSdrLFSAttribute() const { return maSdrLFSAttribute; }
             const attribute::Sdr3DObjectAttribute getSdr3DObjectAttribute() const { return maSdr3DObjectAttribute; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx
index 3e6349df0bb9..52e646e6b4dc 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx
@@ -44,17 +44,25 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** SdrSpherePrimitive3D class
+
+            This 3D primitive expands the SdrPrimitive3D to a 3D sphere definition.
+            The sphere is implicitely in unit coordinates and the given transformation
+            defines it's geometry in space.
+         */
         class SdrSpherePrimitive3D : public SdrPrimitive3D
         {
         private:
+            /// additional geometry definitions
             sal_uInt32                                  mnHorizontalSegments;
             sal_uInt32                                  mnVerticalSegments;
 
         protected:
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
         public:
+            /// constructor
             SdrSpherePrimitive3D(
                 const basegfx::B3DHomMatrix& rTransform,
                 const basegfx::B2DVector& rTextureSize,
@@ -63,17 +71,17 @@ namespace drawinglayer
                 sal_uInt32 nHorizontalSegments,
                 sal_uInt32 nVerticalSegments);
 
-            // data access
+            /// data read access
             sal_uInt32 getHorizontalSegments() const { return mnHorizontalSegments; }
             sal_uInt32 getVerticalSegments() const { return mnVerticalSegments; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx
index d511c89a9998..cb8e9cd385d0 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx
@@ -46,17 +46,29 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** ShadowPrimitive3D class
+
+            This 3D grouping primitive is used to define a shadow for
+            3d geometry by embedding it. The shadow of 3D objects are
+            2D polygons, so the shadow transformation is a 2D transformation.
+
+            If the Shadow3D flag is set, the shadow definition has to be
+            combined with the scene and camera definition to create the correct
+            projected shadow 2D-Polygons.
+         */
         class ShadowPrimitive3D : public GroupPrimitive3D
         {
         protected:
+            /// 2D shadow definition
             basegfx::B2DHomMatrix                   maShadowTransform;
             basegfx::BColor                         maShadowColor;
             double                                  mfShadowTransparence;
 
-            // bitfield
+            /// bitfield
             unsigned                                mbShadow3D : 1;
 
         public:
+            /// constructor
             ShadowPrimitive3D(
                 const basegfx::B2DHomMatrix& rShadowTransform,
                 const basegfx::BColor& rShadowColor,
@@ -64,16 +76,16 @@ namespace drawinglayer
                 bool bShadow3D,
                 const Primitive3DSequence& rChildren);
 
-            // get data
+            /// data read access
             const basegfx::B2DHomMatrix& getShadowTransform() const { return maShadowTransform; }
             const basegfx::BColor& getShadowColor() const { return maShadowColor; }
             double getShadowTransparence() const { return mfShadowTransparence; }
             bool getShadow3D() const { return mbShadow3D; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx
index a0c18f34788e..052d42f7290e 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx
@@ -47,31 +47,39 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** TexturePrimitive3D class
+
+            This 3D grouping primitive is used to define a texture for
+            3d geometry by embedding it. It is used as bae class for
+            extended texture definitions
+         */
         class TexturePrimitive3D : public GroupPrimitive3D
         {
         private:
+            /// texture geometry definition
             basegfx::B2DVector                          maTextureSize;
 
-            // bitfield
-            // flag if texture shall be modulated with white interpolated color
+            /// bitfield
+            /// flag if texture shall be modulated with white interpolated color
             unsigned                                    mbModulate : 1;
 
-            // flag if texture shall be filtered
+            /// flag if texture shall be filtered
             unsigned                                    mbFilter : 1;
 
         public:
+            /// constructor
             TexturePrimitive3D(
                 const Primitive3DSequence& rChildren,
                 const basegfx::B2DVector& rTextureSize,
                 bool bModulate,
                 bool bFilter);
 
-            // get data
+            /// data read access
             const basegfx::B2DVector& getTextureSize() const { return maTextureSize; }
             bool getModulate() const { return mbModulate; }
             bool getFilter() const { return mbFilter; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
         };
     } // end of namespace primitive3d
@@ -83,26 +91,34 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** UnifiedAlphaTexturePrimitive3D class
+
+            This 3D primitive expands TexturePrimitive3D to a unified
+            alpha (transparence) texture definition. All 3D primitives
+            embedded here will be shown with the given transparency.
+         */
         class UnifiedAlphaTexturePrimitive3D : public TexturePrimitive3D
         {
         private:
+            /// transparency definition
             double                                      mfTransparence;
 
         public:
+            /// constructor
             UnifiedAlphaTexturePrimitive3D(
                 double fTransparence,
                 const Primitive3DSequence& rChildren);
 
-            // get data
+            /// data read access
             double getTransparence() const { return mfTransparence; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // local decomposition.
+            /// local decomposition.
             virtual Primitive3DSequence get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
@@ -114,12 +130,20 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** GradientTexturePrimitive3D class
+
+            This 3D primitive expands TexturePrimitive3D to a gradient texture
+            definition. All 3D primitives embedded here will be shown with the
+            defined gradient.
+         */
         class GradientTexturePrimitive3D : public TexturePrimitive3D
         {
         private:
+            /// the gradient definition
             attribute::FillGradientAttribute        maGradient;
 
         public:
+            /// constructor
             GradientTexturePrimitive3D(
                 const attribute::FillGradientAttribute& rGradient,
                 const Primitive3DSequence& rChildren,
@@ -127,13 +151,13 @@ namespace drawinglayer
                 bool bModulate,
                 bool bFilter);
 
-            // get data
+            /// data read access
             const attribute::FillGradientAttribute& getGradient() const { return maGradient; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
@@ -145,12 +169,20 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** BitmapTexturePrimitive3D class
+
+            This 3D primitive expands TexturePrimitive3D to a bitmap texture
+            definition. All 3D primitives embedded here will be shown with the
+            defined bitmap (maybe tiled if defined).
+         */
         class BitmapTexturePrimitive3D : public TexturePrimitive3D
         {
         private:
+            /// bitmap fill attribute
             attribute::FillBitmapAttribute      maBitmap;
 
         public:
+            /// constructor
             BitmapTexturePrimitive3D(
                 const attribute::FillBitmapAttribute& rBitmap,
                 const Primitive3DSequence& rChildren,
@@ -158,13 +190,13 @@ namespace drawinglayer
                 bool bModulate,
                 bool bFilter);
 
-            // get data
+            /// data read access
             const attribute::FillBitmapAttribute& getBitmap() const { return maBitmap; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
@@ -176,18 +208,26 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** AlphaTexturePrimitive3D class
+
+            This 3D primitive expands TexturePrimitive3D to a alpha texture
+            definition. For alpha definition, a gradient is used. The values in
+            that gradient will be interpreted as luminance Alpha-Values. All 3D
+            primitives embedded here will be shown with the defined transparence.
+         */
         class AlphaTexturePrimitive3D : public GradientTexturePrimitive3D
         {
         public:
+            /// constructor
             AlphaTexturePrimitive3D(
                 const attribute::FillGradientAttribute& rGradient,
                 const Primitive3DSequence& rChildren,
                 const basegfx::B2DVector& rTextureSize);
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx
index 720f28445dec..bbf2b8444969 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx
@@ -45,26 +45,37 @@ namespace drawinglayer
 {
     namespace primitive3d
     {
+        /** TransformPrimitive3D class
+
+            This is one of the basic grouping 3D primitives and it provides
+            embedding a sequence of primitives (a geometry) into a
+            3D transformation.
+
+            Please see the description for TransformPrimitive2D since these
+            primitives are pretty similar.
+         */
         class TransformPrimitive3D : public GroupPrimitive3D
         {
         private:
+            // the 3D transformation to apply
             basegfx::B3DHomMatrix                   maTransformation;
 
         public:
+            /// constructor
             TransformPrimitive3D(
                 const basegfx::B3DHomMatrix& rTransformation,
                 const Primitive3DSequence& rChildren);
 
-            // get data
+            /// data read access
             const basegfx::B3DHomMatrix& getTransformation() const { return maTransformation; }
 
-            // compare operator
+            /// compare operator
             virtual bool operator==(const BasePrimitive3D& rPrimitive) const;
 
-            // get range
+            /// get range
             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
-            // provide unique ID
+            /// provide unique ID
             DeclPrimitrive3DIDBlock()
         };
     } // end of namespace primitive3d