#i39532#

author: Armin Weiss <aw@openoffice.org> 2006-08-09 15:39:25 +0000
committer: Armin Weiss <aw@openoffice.org> 2006-08-09 15:39:25 +0000
commit: 73679d08d7072f98065007b7014df46e45e2862e (patch)
tree: af4d42d577dd245a2fcbe4482770587f5684e4ef /drawinglayer
parent: b04c2937bbc5b3db538e9523e078b469f9899b67 (diff)
24 files changed, 1452 insertions, 246 deletions
diff --git a/drawinglayer/inc/drawinglayer/animation/animationtiming.hxx b/drawinglayer/inc/drawinglayer/animation/animationtiming.hxx
index 64d26b3779c5..4618fde632fe 100644
--- a/drawinglayer/inc/drawinglayer/animation/animationtiming.hxx
+++ b/drawinglayer/inc/drawinglayer/animation/animationtiming.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: animationtiming.hxx,v $
  *
- *  $Revision: 1.1 $
+ *  $Revision: 1.2 $
  *
- *  last change: $Author: aw $ $Date: 2006-05-12 11:46:15 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:39:25 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -120,7 +120,6 @@ namespace drawinglayer
 
         public:
             animationEntryList();
-            animationEntryList(const animationEntryList& rCandidate);
             virtual ~animationEntryList();
             virtual animationEntry* clone() const;
 
@@ -139,7 +138,7 @@ namespace drawinglayer
             sal_uInt32                                  mnRepeat;
 
         public:
-            animationEntryLoop(sal_uInt32 nRepeat);
+            animationEntryLoop(sal_uInt32 nRepeat = 0xffffffff);
             virtual ~animationEntryLoop();
             virtual animationEntry* clone() const;
 
diff --git a/drawinglayer/inc/drawinglayer/attribute/fillattribute.hxx b/drawinglayer/inc/drawinglayer/attribute/fillattribute.hxx
new file mode 100644
index 000000000000..e9705bb1daa3
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/fillattribute.hxx
@@ -0,0 +1,140 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: fillattribute.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:37 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLATTRIBUTE_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_FILLATTRIBUTE_HXX
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+class XHatch;
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        enum GradientStyle
+        {
+            GRADIENTSTYLE_LINEAR,
+            GRADIENTSTYLE_AXIAL,
+            GRADIENTSTYLE_RADIAL,
+            GRADIENTSTYLE_ELLIPTICAL,
+            GRADIENTSTYLE_SQUARE,
+            GRADIENTSTYLE_RECT
+        };
+
+        enum HatchStyle
+        {
+            HATCHSTYLE_SINGLE,
+            HATCHSTYLE_DOUBLE,
+            HATCHSTYLE_TRIPLE
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class fillGradientAttribute
+        {
+            basegfx::BColor                         maStartColor;
+            basegfx::BColor                         maEndColor;
+            double                                      mfBorder;
+            double                                      mfOffsetX;
+            double                                      mfOffsetY;
+            double                                      mfAngle;
+            GradientStyle                               meStyle;
+            sal_uInt16                                  mnSteps;
+
+        public:
+            fillGradientAttribute(
+                GradientStyle eStyle, double fBorder, double fOffsetX, double fOffsetY, double fAngle,
+                const basegfx::BColor& rStartColor, const basegfx::BColor& rEndColor, sal_uInt16 nSteps);
+            bool operator==(const fillGradientAttribute& rCandidate) const;
+
+            // data access
+            const basegfx::BColor& getStartColor() const { return maStartColor; }
+            const basegfx::BColor& getEndColor() const { return maEndColor; }
+            double getBorder() const { return mfBorder; }
+            double getOffsetX() const { return mfOffsetX; }
+            double getOffsetY() const { return mfOffsetY; }
+            double getAngle() const { return mfAngle; }
+            GradientStyle getStyle() const { return meStyle; }
+            sal_uInt16 getSteps() const { return mnSteps; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class fillHatchAttribute
+        {
+            double                                      mfDistance;
+            double                                      mfAngle;
+            basegfx::BColor                         maColor;
+            HatchStyle                                  meStyle;
+
+            // bitfield
+            unsigned                                    mbFillBackground : 1;
+
+        public:
+            fillHatchAttribute(HatchStyle eStyle, double fDistance, double fAngle, const basegfx::BColor& rColor, bool bFillBackground);
+            bool operator==(const fillHatchAttribute& rCandidate) const;
+
+            // data access
+            double getDistance() const { return mfDistance; }
+            double getAngle() const { return mfAngle; }
+            const basegfx::BColor& getColor() const { return maColor; }
+            HatchStyle getStyle() const { return meStyle; }
+            bool isFillBackground() const { return mbFillBackground; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_FILLATTRIBUTE_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/fillbitmapattribute.hxx b/drawinglayer/inc/drawinglayer/attribute/fillbitmapattribute.hxx
new file mode 100644
index 000000000000..7fd4891a12c8
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/fillbitmapattribute.hxx
@@ -0,0 +1,92 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: fillbitmapattribute.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:39 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLBITMAPATTRIBUTE_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_FILLBITMAPATTRIBUTE_HXX
+
+#ifndef _SV_BITMAP_HXX
+#include <vcl/bitmap.hxx>
+#endif
+
+#ifndef _BGFX_POINT_B2DPOINT_HXX
+#include <basegfx/point/b2dpoint.hxx>
+#endif
+
+#ifndef _BGFX_VECTOR_B2DVECTOR_HXX
+#include <basegfx/vector/b2dvector.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+class SfxItemSet;
+
+namespace basegfx {
+    class B2DRange;
+    class BColor;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class fillBitmapAttribute
+        {
+            Bitmap                                      maBitmap;
+            basegfx::B2DPoint                           maTopLeft;
+            basegfx::B2DVector                      maSize;
+
+            // bitfield
+            unsigned                                    mbTiling : 1;
+
+        public:
+            fillBitmapAttribute(const Bitmap& rBitmap, const basegfx::B2DPoint& rTopLeft, const basegfx::B2DVector& rSize, bool bTiling);
+            bool operator==(const fillBitmapAttribute& rCandidate) const;
+
+            // data access
+            const Bitmap& getBitmap() const { return maBitmap; }
+            const basegfx::B2DPoint& getTopLeft() const { return maTopLeft; }
+            const basegfx::B2DVector& getSize() const { return maSize; }
+            bool getTiling() const { return mbTiling; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_FILLBITMAPATTRIBUTE_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/materialattribute3d.hxx b/drawinglayer/inc/drawinglayer/attribute/materialattribute3d.hxx
new file mode 100644
index 000000000000..21d46c4454cc
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/materialattribute3d.hxx
@@ -0,0 +1,93 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: materialattribute3d.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:38 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_MATERIALATTRIBUTE3D_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_MATERIALATTRIBUTE3D_HXX
+
+#ifndef _SAL_TYPES_H_
+#include <sal/types.h>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+namespace drawinglayer { namespace {
+    class impMaterialAttribute3D;
+}}
+
+namespace basegfx {
+    class BColor;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class materialAttribute3D
+        {
+        private:
+            impMaterialAttribute3D*                             mpMaterialAttribute3D;
+
+        public:
+            // constructors/destructor
+            materialAttribute3D(const basegfx::BColor& rColor, const basegfx::BColor& rSpecular, const basegfx::BColor& rEmission, sal_uInt16 nSpecularIntensity);
+            materialAttribute3D(const basegfx::BColor& rColor);
+            materialAttribute3D();
+            materialAttribute3D(const materialAttribute3D& rCandidate);
+            ~materialAttribute3D();
+
+            // assignment operator
+            materialAttribute3D& operator=(const materialAttribute3D& rCandidate);
+
+            // compare operator
+            bool operator==(const materialAttribute3D& rCandidate) const;
+            bool operator!=(const materialAttribute3D& rCandidate) const { return !operator==(rCandidate); }
+
+            // data access
+            const basegfx::BColor& getColor() const;
+            const basegfx::BColor& getSpecular() const;
+            const basegfx::BColor& getEmission() const;
+            sal_uInt16 getSpecularIntensity() const;
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_MATERIALATTRIBUTE3D_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/sdrallattribute3d.hxx b/drawinglayer/inc/drawinglayer/attribute/sdrallattribute3d.hxx
new file mode 100644
index 000000000000..ace244dd8beb
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/sdrallattribute3d.hxx
@@ -0,0 +1,98 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrallattribute3d.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:37 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRALLATTRIBUTE3D_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_SDRALLATTRIBUTE3D_HXX
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+namespace drawinglayer { namespace attribute {
+    class sdrLineAttribute;
+    class sdrFillAttribute;
+    class sdrLineStartEndAttribute;
+    class sdrShadowAttribute;
+    class fillGradientAttribute;
+}}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrLineFillShadowAttribute
+        {
+            // shadow, line, lineStartEnd, fill, transGradient and compound3D attributes
+            sdrShadowAttribute*                 mpShadow;                   // shadow attributes (if used)
+            sdrLineAttribute*                   mpLine;                     // line attributes (if used)
+            sdrLineStartEndAttribute*           mpLineStartEnd;             // line start end (if used)
+            sdrFillAttribute*                   mpFill;                     // fill attributes (if used)
+            fillGradientAttribute*              mpFillFloatTransGradient;   // fill float transparence gradient (if used)
+
+        public:
+            sdrLineFillShadowAttribute(
+                sdrLineAttribute* pLine = 0L,
+                sdrFillAttribute* pFill = 0L,
+                sdrLineStartEndAttribute* pLineStartEnd = 0L,
+                sdrShadowAttribute* pShadow = 0L,
+                fillGradientAttribute* pFillFloatTransGradient = 0L);
+            ~sdrLineFillShadowAttribute();
+
+            // copy constructor and assigment operator
+            sdrLineFillShadowAttribute(const sdrLineFillShadowAttribute& rCandidate);
+            sdrLineFillShadowAttribute& operator=(const sdrLineFillShadowAttribute& rCandidate);
+
+            // compare operator
+            bool operator==(const sdrLineFillShadowAttribute& rCandidate) const;
+
+            // bool access
+            bool isVisible() const { return (mpFill || mpLine); }
+
+            // data access
+            const sdrShadowAttribute* getShadow() const { return mpShadow; }
+            const sdrLineAttribute* getLine() const { return mpLine; }
+            const sdrLineStartEndAttribute* getLineStartEnd() const { return mpLineStartEnd; }
+            const sdrFillAttribute* getFill() const { return mpFill; }
+            const fillGradientAttribute* getFillFloatTransGradient() const { return mpFillFloatTransGradient; }
+        };
+    } // end of namespace overlay
+} // end of namespace sdr
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif // _DRAWINGLAYER_ATTRIBUTE_SDRALLATTRIBUTE3D_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/sdrattribute.hxx b/drawinglayer/inc/drawinglayer/attribute/sdrattribute.hxx
new file mode 100644
index 000000000000..b6d90c36439b
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/sdrattribute.hxx
@@ -0,0 +1,229 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrattribute.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:38 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+
+#ifndef _BGFX_POLYGON_B2DLINEGEOMETRY_HXX
+#include <basegfx/polygon/b2dlinegeometry.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+#include <vector>
+
+#ifndef _BGFX_VECTOR_B2DVECTOR_HXX
+#include <basegfx/vector/b2dvector.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+class SdrTextObj;
+
+namespace drawinglayer { namespace attribute {
+    class sdrFillBitmapAttribute;
+    class fillHatchAttribute;
+    class fillGradientAttribute;
+}}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrLineAttribute
+        {
+            // line definitions
+            basegfx::tools::B2DLineJoin         meJoin;             // B2DLINEJOIN_* defines
+            double                                  mfWidth;            // 1/100th mm, 0.0==hair
+            double                                  mfTransparence;     // [0.0 .. 1.0], 0.0==no transp.
+            basegfx::BColor                     maColor;            // color of line
+            ::std::vector< double >                 maDotDashArray;     // array of double which defines the dot-dash pattern
+            double                                  mfFullDotDashLen;   // sum of maDotDashArray (for convenience)
+
+        public:
+            sdrLineAttribute(
+                basegfx::tools::B2DLineJoin eJoin, double fWidth, double fTransparence, const basegfx::BColor& rColor,
+                const ::std::vector< double >& rDotDashArray, double fFullDotDashLen);
+            ~sdrLineAttribute();
+
+            // compare operator
+            bool operator==(const sdrLineAttribute& rCandidate) const;
+
+            // bool access
+            bool isVisible() const { return (1.0 != mfTransparence); }
+            bool isDashed() const { return (0L != maDotDashArray.size()); }
+
+            // data access
+            basegfx::tools::B2DLineJoin getJoin() const { return meJoin; }
+            double getWidth() const { return mfWidth; }
+            double getTransparence() const { return mfTransparence; }
+            const basegfx::BColor& getColor() const { return maColor; }
+            const ::std::vector< double >& getDotDashArray() const { return maDotDashArray; }
+            double getFullDotDashLen() const { return mfFullDotDashLen; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrLineStartEndAttribute
+        {
+            // line arrow definitions
+            basegfx::B2DPolyPolygon             maStartPolyPolygon;     // start Line PolyPolygon
+            basegfx::B2DPolyPolygon             maEndPolyPolygon;       // end Line PolyPolygon
+            double                                  mfStartWidth;           // 1/100th mm
+            double                                  mfEndWidth;             // 1/100th mm
+
+            // bitfield
+            unsigned                                mbStartActive : 1L;     // start of Line is active
+            unsigned                                mbEndActive : 1L;       // end of Line is active
+            unsigned                                mbStartCentered : 1L;   // Line is centered on line start point
+            unsigned                                mbEndCentered : 1L;     // Line is centered on line end point
+
+        public:
+            sdrLineStartEndAttribute(
+                const basegfx::B2DPolyPolygon& rStartPolyPolygon, const basegfx::B2DPolyPolygon& rEndPolyPolygon,
+                double fStartWidth, double fEndWidth, bool bStartActive, bool bEndActive, bool bStartCentered, bool bEndCentered);
+            ~sdrLineStartEndAttribute();
+
+            // compare operator
+            bool operator==(const sdrLineStartEndAttribute& rCandidate) const;
+
+            // bool access
+            bool isStartActive() const { return mbStartActive; }
+            bool isEndActive() const { return mbEndActive; }
+            bool isStartCentered() const { return mbStartCentered; }
+            bool isEndCentered() const { return mbEndCentered; }
+            bool isVisible() const { return (isStartActive() || isEndActive()); }
+
+            // data access
+            const basegfx::B2DPolyPolygon& getStartPolyPolygon() const { return maStartPolyPolygon; }
+            const basegfx::B2DPolyPolygon& getEndPolyPolygon() const { return maEndPolyPolygon; }
+            double getStartWidth() const { return mfStartWidth; }
+            double getEndWidth() const { return mfEndWidth; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrShadowAttribute
+        {
+            // shadow definitions
+            basegfx::B2DVector                  maOffset;                   // shadow offset 1/100th mm
+            double                                  mfTransparence;             // [0.0 .. 1.0], 0.0==no transp.
+            basegfx::BColor                     maColor;                    // color of shadow
+
+        public:
+            sdrShadowAttribute(
+                const basegfx::B2DVector& rOffset, double fTransparence, const basegfx::BColor& rColor);
+            ~sdrShadowAttribute();
+
+            // compare operator
+            bool operator==(const sdrShadowAttribute& rCandidate) const;
+
+            // bool access
+            bool isVisible() const { return (1.0 != mfTransparence); }
+
+            // data access
+            const basegfx::B2DVector& getOffset() const { return maOffset; }
+            double getTransparence() const { return mfTransparence; }
+            const basegfx::BColor& getColor() const { return maColor; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrFillAttribute
+        {
+            // fill definitions
+            double                                  mfTransparence;     // [0.0 .. 1.0], 0.0==no transp.
+            basegfx::BColor                     maColor;            // fill color
+            fillGradientAttribute*                  mpGradient;         // fill gradient (if used)
+            fillHatchAttribute*                     mpHatch;            // fill hatch (if used)
+            sdrFillBitmapAttribute*                 mpBitmap;           // fill bitmap (if used)
+
+        public:
+            sdrFillAttribute(
+                double fTransparence, const basegfx::BColor& rColor, fillGradientAttribute* pGradient = 0L,
+                fillHatchAttribute* pHatch = 0L, sdrFillBitmapAttribute* pBitmap = 0L);
+            ~sdrFillAttribute();
+
+            // copy constructor and assigment operator
+            sdrFillAttribute(const sdrFillAttribute& rCandidate);
+            sdrFillAttribute& operator=(const sdrFillAttribute& rCandidate);
+
+            // compare operator
+            bool operator==(const sdrFillAttribute& rCandidate) const;
+
+            // bool access
+            bool isGradient() const { return (0L != mpGradient); }
+            bool isHatch() const { return (0L != mpHatch); }
+            bool isBitmap() const { return (0L != mpBitmap); }
+            bool isColor() const { return (!mpGradient && !mpHatch && !mpBitmap); }
+            bool isVisible() const { return (1.0 != mfTransparence); }
+
+            // data access
+            double getTransparence() const { return mfTransparence; }
+            const basegfx::BColor& getColor() const { return maColor; }
+            const fillGradientAttribute* getGradient() const { return mpGradient; }
+            const fillHatchAttribute* getHatch() const { return mpHatch; }
+            const sdrFillBitmapAttribute* getBitmap() const { return mpBitmap; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/sdrattribute3d.hxx b/drawinglayer/inc/drawinglayer/attribute/sdrattribute3d.hxx
new file mode 100644
index 000000000000..9319421f712f
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/sdrattribute3d.hxx
@@ -0,0 +1,244 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrattribute3d.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:37 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE3D_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE3D_HXX
+
+#ifndef _BGFX_VECTOR_B2DVECTOR_HXX
+#include <basegfx/vector/b2dvector.hxx>
+#endif
+
+#ifndef _COM_SUN_STAR_DRAWING_NORMALSKIND_HPP_
+#include <com/sun/star/drawing/NormalsKind.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_DRAWING_TEXTUREPROJECTIONMODE_HPP_
+#include <com/sun/star/drawing/TextureProjectionMode.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_DRAWING_PROJECTIONMODE_HPP_
+#include <com/sun/star/drawing/ProjectionMode.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_DRAWING_TEXTUREKIND2_HPP_
+#include <com/sun/star/drawing/TextureKind2.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_DRAWING_TEXTUREMODE_HPP_
+#include <com/sun/star/drawing/TextureMode.hpp>
+#endif
+
+#ifndef _BGFX_VECTOR_B3DVECTOR_HXX
+#include <basegfx/vector/b3dvector.hxx>
+#endif
+
+#ifndef _COM_SUN_STAR_DRAWING_SHADEMODE_HPP_
+#include <com/sun/star/drawing/ShadeMode.hpp>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_MATERIALATTRIBUTE3D_HXX
+#include <drawinglayer/attribute/materialattribute3d.hxx>
+#endif
+
+#include <vector>
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdr3DObjectAttribute
+        {
+            // 3D object attribute definitions
+            ::com::sun::star::drawing::NormalsKind              maNormalsKind;              // normals type (0..2)
+            ::com::sun::star::drawing::TextureProjectionMode    maTextureProjectionX;       // texture projection type X (0..2)
+            ::com::sun::star::drawing::TextureProjectionMode    maTextureProjectionY;       // texture projection type Y (0..2)
+            ::com::sun::star::drawing::TextureKind2             maTextureKind;              // texture kind (see uno API)
+            ::com::sun::star::drawing::TextureMode              maTextureMode;              // texture kind (see uno API)
+            materialAttribute3D                                 maMaterial;                 // object, specular and emissive colors, SpecularIntensity
+
+            // bitfield
+            unsigned                                            mbNormalsInvert : 1;        // invert normals
+            unsigned                                            mbDoubleSided : 1;          // surfaces are double sided
+            unsigned                                            mbShadow3D : 1;             // display shadow in 3D (if on), params for that are at scene
+            unsigned                                            mbTextureFilter : 1;        // filter texture to make more smooth
+
+        public:
+            sdr3DObjectAttribute(
+                ::com::sun::star::drawing::NormalsKind  aNormalsKind,
+                ::com::sun::star::drawing::TextureProjectionMode aTextureProjectionX,
+                ::com::sun::star::drawing::TextureProjectionMode aTextureProjectionY,
+                ::com::sun::star::drawing::TextureKind2 aTextureKind,
+                ::com::sun::star::drawing::TextureMode aTextureMode,
+                const materialAttribute3D& rMaterial,
+                bool bNormalsInvert,
+                bool bDoubleSided,
+                bool bShadow3D,
+                bool bTextureFilter);
+            ~sdr3DObjectAttribute();
+
+            // compare operator
+            bool operator==(const sdr3DObjectAttribute& rCandidate) const;
+
+            // data access
+            ::com::sun::star::drawing::NormalsKind getNormalsKind() const { return maNormalsKind; }
+            ::com::sun::star::drawing::TextureProjectionMode getTextureProjectionX() const { return maTextureProjectionX; }
+            ::com::sun::star::drawing::TextureProjectionMode getTextureProjectionY() const { return maTextureProjectionY; }
+            ::com::sun::star::drawing::TextureKind2 getTextureKind() const { return maTextureKind; }
+            ::com::sun::star::drawing::TextureMode getTextureMode() const { return maTextureMode; }
+            const materialAttribute3D& getMaterial() const { return maMaterial; }
+            bool getNormalsInvert() const { return mbNormalsInvert; }
+            bool getDoubleSided() const { return mbDoubleSided; }
+            bool getShadow3D() const { return mbShadow3D; }
+            bool getTextureFilter() const { return mbTextureFilter; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdr3DLightAttribute
+        {
+            // 3D light attribute definitions
+            basegfx::BColor                         maColor;
+            basegfx::B3DVector                      maDirection;
+
+            // bitfield
+            unsigned                                    mbSpecular : 1;
+
+        public:
+            sdr3DLightAttribute(const basegfx::BColor& rColor, const basegfx::B3DVector& rDirection, bool bSpecular);
+            ~sdr3DLightAttribute();
+
+            // compare operator
+            bool operator==(const sdr3DLightAttribute& rCandidate) const;
+
+            // data access
+            const basegfx::BColor& getColor() const { return maColor; }
+            const basegfx::B3DVector& getDirection() const { return maDirection; }
+            bool getSpecular() const { return mbSpecular; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrLightingAttribute
+        {
+            // 3D light attribute definitions
+            basegfx::BColor                         maAmbientLight;
+            ::std::vector< sdr3DLightAttribute >        maLightVector;
+
+        public:
+            sdrLightingAttribute(
+                const basegfx::BColor& rAmbientLight,
+                const ::std::vector< sdr3DLightAttribute >& rLightVector);
+            ~sdrLightingAttribute();
+
+            // compare operator
+            bool operator==(const sdrLightingAttribute& rCandidate) const;
+
+            // data access
+            const basegfx::BColor& getAmbientLight() const { return maAmbientLight; }
+            const ::std::vector< sdr3DLightAttribute >& getLightVector() const { return maLightVector; }
+
+            // color model solver
+            basegfx::BColor solveColorModel(const basegfx::B3DVector& rNormalInEyeCoordinates,
+                const basegfx::BColor& rColor, const basegfx::BColor& rSpecular,
+                const basegfx::BColor& rEmission, sal_uInt16 nSpecularIntensity) const;
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrSceneAttribute
+        {
+            // 3D scene attribute definitions
+            double                                      mfDistance;
+            double                                      mfShadowSlant;
+            ::com::sun::star::drawing::ProjectionMode   maProjectionMode;
+            ::com::sun::star::drawing::ShadeMode        maShadeMode;
+
+            // bitfield
+            unsigned                                    mbTwoSidedLighting : 1;
+
+        public:
+            sdrSceneAttribute(
+                double fDistance,
+                double fShadowSlant,
+                ::com::sun::star::drawing::ProjectionMode aProjectionMode,
+                ::com::sun::star::drawing::ShadeMode aShadeMode,
+                bool bTwoSidedLighting);
+            ~sdrSceneAttribute();
+
+            // compare operator
+            bool operator==(const sdrSceneAttribute& rCandidate) const;
+
+            // data access
+            double getDistance() const { return mfDistance; }
+            double getShadowSlant() const { return mfShadowSlant; }
+            ::com::sun::star::drawing::ProjectionMode getProjectionMode() const { return maProjectionMode; }
+            ::com::sun::star::drawing::ShadeMode getShadeMode() const { return maShadeMode; }
+            bool getTwoSidedLighting() const { return mbTwoSidedLighting; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE3D_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/sdrfillbitmapattribute.hxx b/drawinglayer/inc/drawinglayer/attribute/sdrfillbitmapattribute.hxx
new file mode 100644
index 000000000000..005753222ecc
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/sdrfillbitmapattribute.hxx
@@ -0,0 +1,97 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrfillbitmapattribute.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:39 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRFILLBITMAPATTRIBUTE_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_SDRFILLBITMAPATTRIBUTE_HXX
+
+#ifndef _SV_BITMAP_HXX
+#include <vcl/bitmap.hxx>
+#endif
+
+#ifndef _BGFX_VECTOR_B2DVECTOR_HXX
+#include <basegfx/vector/b2dvector.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+class SfxItemSet;
+
+namespace drawinglayer {    namespace attribute {
+    class fillBitmapAttribute;
+}}
+
+namespace basegfx {
+    class B2DRange;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class sdrFillBitmapAttribute
+        {
+            Bitmap                                      maBitmap;
+            basegfx::B2DVector                      maSize;
+            basegfx::B2DVector                      maOffset;
+            basegfx::B2DVector                      maOffsetPosition;
+            basegfx::B2DVector                      maRectPoint;
+
+            // bitfield
+            unsigned                                    mbTiling : 1;
+            unsigned                                    mbStretch : 1;
+            unsigned                                    mbLogSize : 1;
+
+        public:
+            sdrFillBitmapAttribute(
+                const Bitmap& rBitmap, const basegfx::B2DVector& rSize, const basegfx::B2DVector& rOffset,
+                const basegfx::B2DVector& rOffsetPosition, const basegfx::B2DVector& rRectPoint,
+                bool bTiling, bool bStretch, bool bLogSize);
+            bool operator==(const sdrFillBitmapAttribute& rCandidate) const;
+
+            // data access
+            const Bitmap& getBitmap() const { return maBitmap; }
+            bool getTiling() const { return mbTiling; }
+            fillBitmapAttribute getFillBitmapAttribute(const basegfx::B2DRange& rRange) const;
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_SDRFILLBITMAPATTRIBUTE_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/attribute/strokeattribute.hxx b/drawinglayer/inc/drawinglayer/attribute/strokeattribute.hxx
new file mode 100644
index 000000000000..79460945094f
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/attribute/strokeattribute.hxx
@@ -0,0 +1,125 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: strokeattribute.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:36:38 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_STROKEATTRIBUTE_HXX
+#define _DRAWINGLAYER_ATTRIBUTE_STROKEATTRIBUTE_HXX
+
+#ifndef _BGFX_POLYGON_B2DLINEGEOMETRY_HXX
+#include <basegfx/polygon/b2dlinegeometry.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+#include <vector>
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        class strokeAttribute
+        {
+            basegfx::BColor                         maColor;                // color
+            double                                      mfWidth;                // absolute line width
+            basegfx::tools::B2DLineJoin             meLineJoin;             // type of LineJoin
+            ::std::vector< double >                     maDotDashArray;         // array of double which defines the dot-dash pattern
+            double                                      mfFullDotDashLen;       // sum of maDotDashArray (for convenience)
+
+        public:
+            strokeAttribute(
+                const basegfx::BColor& rColor,
+                double fWidth,
+                basegfx::tools::B2DLineJoin aB2DLineJoin,
+                const ::std::vector< double >& rDotDashArray,
+                double fFullDotDashLen)
+            :   maColor(rColor),
+                mfWidth(fWidth),
+                meLineJoin(aB2DLineJoin),
+                maDotDashArray(rDotDashArray),
+                mfFullDotDashLen(fFullDotDashLen)
+            {
+            }
+
+            strokeAttribute(const strokeAttribute& rCandidate)
+            {
+                *this = rCandidate;
+            }
+
+            strokeAttribute& operator=(const strokeAttribute& rCandidate)
+            {
+                maColor = rCandidate.maColor;
+                mfWidth = rCandidate.mfWidth;
+                meLineJoin = rCandidate.meLineJoin;
+                maDotDashArray = rCandidate.maDotDashArray;
+                mfFullDotDashLen = rCandidate.mfFullDotDashLen;
+
+                return *this;
+            }
+
+            ~strokeAttribute()
+            {
+            }
+
+            // compare operator
+            bool operator==(const strokeAttribute& rCandidate) const
+            {
+                return (maColor == rCandidate.maColor
+                    && mfWidth == rCandidate.mfWidth
+                    && meLineJoin == rCandidate.meLineJoin
+                    && mfFullDotDashLen == rCandidate.mfFullDotDashLen
+                    && maDotDashArray == rCandidate.maDotDashArray);
+            }
+
+            // data access
+            const basegfx::BColor& getColor() const { return maColor; }
+            double getWidth() const { return mfWidth; }
+            basegfx::tools::B2DLineJoin getLineJoin() const { return meLineJoin; }
+            const ::std::vector< double >& getDotDashArray() { return maDotDashArray; }
+            double getFullDotDashLen() const { return mfFullDotDashLen; }
+        };
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_ATTRIBUTE_STROKEATTRIBUTE_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx
index bd46561cda06..9e21e8cb722a 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/hatchtextureprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: hatchtextureprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:58 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -44,38 +44,38 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class hatchTexturePrimitive3D : public texturePrimitive3D
         {
         protected:
-            fillHatchAttribute                          maHatch;
+            attribute::fillHatchAttribute                   maHatch;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
             // helpers
-            void impCreateDecomposition(const primitiveVector& rSource, primitiveVector& rDest);
+            void impCreateDecomposition(const primitiveVector3D& rSource, primitiveVector3D& rDest);
 
         public:
             hatchTexturePrimitive3D(
-                const fillHatchAttribute& rHatch,
-                const primitiveVector& rPrimitiveVector,
-                const ::basegfx::B2DVector& rTextureSize,
+                const attribute::fillHatchAttribute& rHatch,
+                const primitiveVector3D& rPrimitiveVector,
+                const basegfx::B2DVector& rTextureSize,
                 bool bModulate,
                 bool bFilter);
             virtual ~hatchTexturePrimitive3D();
 
             // get data
-            const fillHatchAttribute& getHatch() const { return maHatch; }
+            const attribute::fillHatchAttribute& getHatch() const { return maHatch; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx
new file mode 100644
index 000000000000..3b60baa7f6e6
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx
@@ -0,0 +1,80 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: modifiedcolorprimitive3d.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:14 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_MODIFIEDCOLORPRIMITIVE3D_HXX
+#define _DRAWINGLAYER_PRIMITIVE3D_MODIFIEDCOLORPRIMITIVE3D_HXX
+
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_VECTORPRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/vectorprimitive3d.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLORMODIFIER_HXX
+#include <basegfx/color/bcolormodifier.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace primitive3d
+    {
+        class modifiedColorPrimitive3D : public vectorPrimitive3D
+        {
+        protected:
+            basegfx::BColorModifier                 maColorModifier;
+
+        public:
+            modifiedColorPrimitive3D(
+                const primitiveVector3D& rPrimitiveVector,
+                const basegfx::BColorModifier& rColorModifier);
+            virtual ~modifiedColorPrimitive3D();
+
+            // get data
+            const basegfx::BColorModifier& getColorModifier() const { return maColorModifier; }
+
+            // compare operator
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
+
+            // id generator
+            virtual PrimitiveID getID() const;
+        };
+    } // end of namespace primitive3d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_PRIMITIVE3D_MODIFIEDCOLORPRIMITIVE3D_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx
index 15f15006f082..d75c051f41d6 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/polygonprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: polygonprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:58 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,8 +36,8 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_POLYGONPRIMITIVE3D_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_POLYGONPRIMITIVE3D_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_PRIMITIVE_HXX
-#include <drawinglayer/primitive/primitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_PRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/primitive3d.hxx>
 #endif
 
 #ifndef _BGFX_COLOR_BCOLOR_HXX
@@ -48,8 +48,8 @@
 #include <basegfx/polygon/b3dpolygon.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_STROKEATTRIBUTE_HXX
-#include <drawinglayer/primitive/strokeattribute.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_STROKEATTRIBUTE_HXX
+#include <drawinglayer/attribute/strokeattribute.hxx>
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
@@ -59,64 +59,66 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class polygonHairlinePrimitive3D : public basePrimitive
+        class polygonHairlinePrimitive3D : public basePrimitive3D
         {
         protected:
-            ::basegfx::B3DPolygon                       maPolygon;
-            ::basegfx::BColor                           maBColor;
+            basegfx::B3DPolygon                     maPolygon;
+            basegfx::BColor                         maBColor;
 
         public:
-            polygonHairlinePrimitive3D(const ::basegfx::B3DPolygon& rPolygon, const ::basegfx::BColor& rBColor);
+            polygonHairlinePrimitive3D(const basegfx::B3DPolygon& rPolygon, const basegfx::BColor& rBColor);
             virtual ~polygonHairlinePrimitive3D();
 
             // get data
-            const ::basegfx::B3DPolygon& getB3DPolygon() const { return maPolygon; }
-            const ::basegfx::BColor& getBColor() const { return maBColor; }
+            const basegfx::B3DPolygon& getB3DPolygon() const { return maPolygon; }
+            const basegfx::BColor& getBColor() const { return maBColor; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3Drange of primitive. Default implementation uses decomposition
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class polygonStrokePrimitive3D : public basePrimitive
+        class polygonStrokePrimitive3D : public basePrimitive3D
         {
         protected:
-            ::basegfx::B3DPolygon                       maPolygon;
-            strokeAttribute                             maStrokeAttribute;
+            basegfx::B3DPolygon                     maPolygon;
+            attribute::strokeAttribute                  maStrokeAttribute;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
-            polygonStrokePrimitive3D(const ::basegfx::B3DPolygon& rPolygon, const strokeAttribute& rStrokeAttribute);
+            polygonStrokePrimitive3D(
+                const basegfx::B3DPolygon& rPolygon,
+                const attribute::strokeAttribute& rStrokeAttribute);
             virtual ~polygonStrokePrimitive3D();
 
             // get data
-            ::basegfx::B3DPolygon getB3DPolygon() const { return maPolygon; }
-            const strokeAttribute& getStrokeAttribute() const { return maStrokeAttribute; }
+            basegfx::B3DPolygon getB3DPolygon() const { return maPolygon; }
+            const attribute::strokeAttribute& getStrokeAttribute() const { return maStrokeAttribute; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx
index 236cf9a7202e..320ee5010749 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/polygontubeprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: polygontubeprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:58 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -52,7 +52,7 @@ namespace basegfx {
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class polygonTubePrimitive3D : public polygonHairlinePrimitive3D
         {
@@ -60,16 +60,16 @@ namespace drawinglayer
             double                                      mfRadius;
             double                                      mfDegreeStepWidth;
             double                                      mfMiterMinimumAngle;
-            ::basegfx::tools::B2DLineJoin               maLineJoin;
+            basegfx::tools::B2DLineJoin             maLineJoin;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
             polygonTubePrimitive3D(
-                const ::basegfx::B3DPolygon& rPolygon,
-                const ::basegfx::BColor& rBColor,
-                double fRadius, ::basegfx::tools::B2DLineJoin aLineJoin,
+                const basegfx::B3DPolygon& rPolygon,
+                const basegfx::BColor& rBColor,
+                double fRadius, basegfx::tools::B2DLineJoin aLineJoin,
                 double fDegreeStepWidth = 10.0 * F_PI180,
                 double fMiterMinimumAngle = 15.0 * F_PI180);
             virtual ~polygonTubePrimitive3D();
@@ -78,15 +78,15 @@ namespace drawinglayer
             double getRadius() const { return mfRadius; }
             double getDegreeStepWidth() const { return mfDegreeStepWidth; }
             double getMiterMinimumAngle() const { return mfMiterMinimumAngle; }
-            ::basegfx::tools::B2DLineJoin getLineJoin() const { return maLineJoin; }
+            basegfx::tools::B2DLineJoin getLineJoin() const { return maLineJoin; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
index 955b3add97b4..c03e78b51630 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: polypolygonprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:58 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,56 +36,59 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_POLYPOLYGONPRIMITIVE_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_POLYPOLYGONPRIMITIVE_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_PRIMITIVE_HXX
-#include <drawinglayer/primitive/primitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_PRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/primitive3d.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE3D_MATERIALATTRIBUTE3D_HXX
-#include <drawinglayer/primitive3d/materialattribute3d.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_MATERIALATTRIBUTE3D_HXX
+#include <drawinglayer/attribute/materialattribute3d.hxx>
 #endif
 
 #ifndef _BGFX_POLYGON_B3DPOLYPOLYGON_HXX
 #include <basegfx/polygon/b3dpolypolygon.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_TEXTURE_HXX
-#include <drawinglayer/primitive/texture.hxx>
+#ifndef _DRAWINGLAYER_TEXTURE_TEXTURE_HXX
+#include <drawinglayer/texture/texture.hxx>
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class polyPolygonMaterialPrimitive3D : public basePrimitive
+        class polyPolygonMaterialPrimitive3D : public basePrimitive3D
         {
         protected:
-            ::basegfx::B3DPolyPolygon                   maPolyPolygon;
-            materialAttribute3D                         maMaterial;
+            basegfx::B3DPolyPolygon                 maPolyPolygon;
+            attribute::materialAttribute3D              maMaterial;
 
             // bitfield
             unsigned                                    mbDoubleSided : 1;
 
         public:
-            polyPolygonMaterialPrimitive3D(const ::basegfx::B3DPolyPolygon& rPolyPolygon, const materialAttribute3D& rMaterial, bool bDoubleSided);
+            polyPolygonMaterialPrimitive3D(
+                const basegfx::B3DPolyPolygon& rPolyPolygon,
+                const attribute::materialAttribute3D& rMaterial,
+                bool bDoubleSided);
             virtual ~polyPolygonMaterialPrimitive3D();
 
             // get data
-            const ::basegfx::B3DPolyPolygon& getB3DPolyPolygon() const { return maPolyPolygon; }
-            const materialAttribute3D& getMaterial() const { return maMaterial; }
+            const basegfx::B3DPolyPolygon& getB3DPolyPolygon() const { return maPolyPolygon; }
+            const attribute::materialAttribute3D& getMaterial() const { return maMaterial; }
             bool getDoubleSided() const { return mbDoubleSided; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3Drange of primitive. Default implementation uses decomposition
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx
index dd3deb4bd011..f74d8267f8d0 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrcubeprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrcubeprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -45,30 +45,30 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class sdrCubePrimitive3D : public sdrPrimitive3D
         {
         protected:
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
             sdrCubePrimitive3D(
-                const ::basegfx::B3DHomMatrix& rTransform,
-                const ::basegfx::B2DVector& rTextureSize,
-                const sdrLineFillShadowAttribute& rSdrLFSAttribute,
-                const sdr3DObjectAttribute& rSdr3DObjectAttribute);
+                const basegfx::B3DHomMatrix& rTransform,
+                const basegfx::B2DVector& rTextureSize,
+                const attribute::sdrLineFillShadowAttribute& rSdrLFSAttribute,
+                const attribute::sdr3DObjectAttribute& rSdr3DObjectAttribute);
             virtual ~sdrCubePrimitive3D();
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3D range of primitive.
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
         };
     } // end of namespace overlay
 } // end of namespace drawinglayer
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx
index 0ae39f660d02..c5aa63c3dac9 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrdecompositiontools3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrdecompositiontools3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,8 +36,8 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_SDRDECOMPOSITIONTOOLS3D_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_SDRDECOMPOSITIONTOOLS3D_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_PRIMITIVE_HXX
-#include <drawinglayer/primitive/primitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_PRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/primitive3d.hxx>
 #endif
 
 #include <vector>
@@ -51,7 +51,7 @@ namespace basegfx {
     class B2DVector;
 }
 
-namespace drawinglayer { namespace primitive {
+namespace drawinglayer { namespace attribute {
     class sdrLineAttribute;
     class sdrFillAttribute;
     class sdr3DObjectAttribute;
@@ -63,26 +63,26 @@ namespace drawinglayer { namespace primitive {
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         void add3DPolyPolygonLinePrimitive(
-            const ::basegfx::B3DPolyPolygon& rUnitPolyPolygon,
-            const ::basegfx::B3DHomMatrix& rObjectTransform,
-            primitiveVector& rTarget,
-            const sdrLineAttribute& rLine);
+            const basegfx::B3DPolyPolygon& rUnitPolyPolygon,
+            const basegfx::B3DHomMatrix& rObjectTransform,
+            primitiveVector3D& rTarget,
+            const attribute::sdrLineAttribute& rLine);
 
         void add3DPolyPolygonFillPrimitive(
-            const ::std::vector< ::basegfx::B3DPolyPolygon >& r3DPolyPolygonVector,
-            const ::basegfx::B3DHomMatrix& rObjectTransform,
-            const ::basegfx::B2DVector& rTextureSize,
-            primitiveVector& rTarget,
-            const sdr3DObjectAttribute& aSdr3DObjectAttribute,
-            const sdrFillAttribute& rFill,
-            const fillGradientAttribute* pFillGradient = 0L);
+            const ::std::vector< basegfx::B3DPolyPolygon >& r3DPolyPolygonVector,
+            const basegfx::B3DHomMatrix& rObjectTransform,
+            const basegfx::B2DVector& rTextureSize,
+            primitiveVector3D& rTarget,
+            const attribute::sdr3DObjectAttribute& aSdr3DObjectAttribute,
+            const attribute::sdrFillAttribute& rFill,
+            const attribute::fillGradientAttribute* pFillGradient = 0L);
 
         void addShadowPrimitive3D(
-            primitiveVector& rTarget,
-            const sdrShadowAttribute& rShadow,
+            primitiveVector3D& rTarget,
+            const attribute::sdrShadowAttribute& rShadow,
             bool bShadow3D);
     } // end of namespace overlay
 } // end of namespace drawinglayer
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx
index 8a92166606fe..c1a6f49027df 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudelathetools3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrextrudelathetools3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-05-19 09:34:49 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:14 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -53,7 +53,7 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         // slice types
         enum sliceType
@@ -67,25 +67,25 @@ namespace drawinglayer
         class slice
         {
         protected:
-            ::basegfx::B3DPolyPolygon                   maPolyPolygon;
+            basegfx::B3DPolyPolygon                 maPolyPolygon;
             sliceType                                   maSliceType;
 
         public:
-            slice(const ::basegfx::B2DPolyPolygon& rPolyPolygon, const ::basegfx::B3DHomMatrix& aTransform, sliceType aSliceType = SLICETYPE_REGULAR)
-            :   maPolyPolygon(::basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPolygon)),
+            slice(const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B3DHomMatrix& aTransform, sliceType aSliceType = SLICETYPE_REGULAR)
+            :   maPolyPolygon(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPolygon)),
                 maSliceType(aSliceType)
             {
                 maPolyPolygon.transform(aTransform);
             }
 
-            slice(const ::basegfx::B3DPolyPolygon& rPolyPolygon, sliceType aSliceType = SLICETYPE_REGULAR)
+            slice(const basegfx::B3DPolyPolygon& rPolyPolygon, sliceType aSliceType = SLICETYPE_REGULAR)
             :   maPolyPolygon(rPolyPolygon),
                 maSliceType(aSliceType)
             {
             }
 
             // data access
-            const ::basegfx::B3DPolyPolygon& getB3DPolyPolygon() const { return maPolyPolygon; }
+            const basegfx::B3DPolyPolygon& getB3DPolyPolygon() const { return maPolyPolygon; }
             sliceType getSliceType() const { return maSliceType; }
         };
 
@@ -93,18 +93,18 @@ namespace drawinglayer
         typedef ::std::vector< slice > sliceVector;
 
         // helpers for creation
-        void createLatheSlices(sliceVector& rSliceVector, const ::basegfx::B2DPolyPolygon& rSource,
+        void createLatheSlices(sliceVector& rSliceVector, const basegfx::B2DPolyPolygon& rSource,
             double fBackScale, double fDiagonal, double fRotation, sal_uInt32 nSteps,
             bool bCharacterMode, bool bCloseFront, bool bCloseBack);
-        void createExtrudeSlices(sliceVector& rSliceVector, const ::basegfx::B2DPolyPolygon& rSource,
+        void createExtrudeSlices(sliceVector& rSliceVector, const basegfx::B2DPolyPolygon& rSource,
             double fBackScale, double fDiagonal, double fDepth,
             bool bCharacterMode, bool bCloseFront, bool bCloseBack);
 
         // helpers for geometry extraction
-        void extractLinesFromSlice(::basegfx::B3DPolyPolygon& rLine, const sliceVector& rSliceVector, bool bClosed);
-        void extractPlanesFromSlice(::std::vector< ::basegfx::B3DPolyPolygon >& rFill, const sliceVector& rSliceVector,
+        void extractLinesFromSlice(basegfx::B3DPolyPolygon& rLine, const sliceVector& rSliceVector, bool bClosed);
+        void extractPlanesFromSlice(::std::vector< basegfx::B3DPolyPolygon >& rFill, const sliceVector& rSliceVector,
             bool bCreateNormals, bool bSmoothHorizontalNormals, bool bSmoothNormals, bool bSmoothLids, bool bClosed,
-            double fSmoothNormalsMix, double fSmoothLidsMix, bool bCreateTextureCoordinates, const ::basegfx::B2DHomMatrix& rTexTransform);
+            double fSmoothNormalsMix, double fSmoothLidsMix, bool bCreateTextureCoordinates, const basegfx::B2DHomMatrix& rTexTransform);
 
     } // end of namespace overlay
 } // end of namespace drawinglayer
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
index 45ed6c0fbf95..7b0a4df0bf6b 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrextrudeprimitive3d.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -51,7 +51,7 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class sdrExtrudePrimitive3D : public sdrPrimitive3D
         {
@@ -60,11 +60,11 @@ namespace drawinglayer
             void impCreateSlices();
 
             // geometry helper for slices
-            ::basegfx::B2DPolyPolygon                   maCorrectedPolyPolygon;
+            basegfx::B2DPolyPolygon                 maCorrectedPolyPolygon;
             sliceVector                                 maSlices;
 
         protected:
-            ::basegfx::B2DPolyPolygon                   maPolyPolygon;
+            basegfx::B2DPolyPolygon                 maPolyPolygon;
             double                                      mfDepth;
             double                                      mfDiagonal;
             double                                      mfBackScale;
@@ -78,18 +78,18 @@ namespace drawinglayer
             unsigned                                    mbCloseBack : 1;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
             // get (evtl. create) slices
             const sliceVector& getSlices() const;
 
         public:
             sdrExtrudePrimitive3D(
-                const ::basegfx::B3DHomMatrix& rTransform,
-                const ::basegfx::B2DVector& rTextureSize,
-                const sdrLineFillShadowAttribute& rSdrLFSAttribute,
-                const sdr3DObjectAttribute& rSdr3DObjectAttribute,
-                const ::basegfx::B2DPolyPolygon& rPolyPolygon,
+                const basegfx::B3DHomMatrix& rTransform,
+                const basegfx::B2DVector& rTextureSize,
+                const attribute::sdrLineFillShadowAttribute& rSdrLFSAttribute,
+                const attribute::sdr3DObjectAttribute& rSdr3DObjectAttribute,
+                const basegfx::B2DPolyPolygon& rPolyPolygon,
                 double fDepth,
                 double fDiagonal,
                 double fBackScale,
@@ -102,16 +102,16 @@ namespace drawinglayer
             virtual ~sdrExtrudePrimitive3D();
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3D range of primitive.
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
 
             // data access
-            const ::basegfx::B2DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
+            const basegfx::B2DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
             double getDepth() const { return mfDepth; }
             double getDiagonal() const { return mfDiagonal; }
             double getBackScale() const { return mfBackScale; }
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
index de2c1fa4dca4..88f2f9cff114 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrlatheprimitive3d.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:12 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -51,7 +51,7 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class sdrLathePrimitive3D : public sdrPrimitive3D
         {
@@ -63,7 +63,7 @@ namespace drawinglayer
             sliceVector                                 maSlices;
 
         protected:
-            ::basegfx::B2DPolyPolygon                   maPolyPolygon;
+            basegfx::B2DPolyPolygon                 maPolyPolygon;
             sal_uInt32                                  mnHorizontalSegments;
             sal_uInt32                                  mnVerticalSegments;
             double                                      mfDiagonal;
@@ -79,18 +79,18 @@ namespace drawinglayer
             unsigned                                    mbCloseBack : 1;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
             // get (evtl. create) slices
             const sliceVector& getSlices() const;
 
         public:
             sdrLathePrimitive3D(
-                const ::basegfx::B3DHomMatrix& rTransform,
-                const ::basegfx::B2DVector& rTextureSize,
-                const sdrLineFillShadowAttribute& rSdrLFSAttribute,
-                const sdr3DObjectAttribute& rSdr3DObjectAttribute,
-                const ::basegfx::B2DPolyPolygon& rPolyPolygon,
+                const basegfx::B3DHomMatrix& rTransform,
+                const basegfx::B2DVector& rTextureSize,
+                const attribute::sdrLineFillShadowAttribute& rSdrLFSAttribute,
+                const attribute::sdr3DObjectAttribute& rSdr3DObjectAttribute,
+                const basegfx::B2DPolyPolygon& rPolyPolygon,
                 sal_uInt32 nHorizontalSegments,
                 sal_uInt32 nVerticalSegments,
                 double fDiagonal,
@@ -105,16 +105,16 @@ namespace drawinglayer
             virtual ~sdrLathePrimitive3D();
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3D range of primitive.
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
 
             // data access
-            const ::basegfx::B2DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
+            const basegfx::B2DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
             sal_uInt32 getHorizontalSegments() const { return mnHorizontalSegments; }
             sal_uInt32 getVerticalSegments() const { return mnVerticalSegments ; }
             double getDiagonal() const { return mfDiagonal; }
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx
index 7556f204ae53..d0d98f373a38 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrprimitive3d.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,26 +36,30 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_SDRPRIMITIVE3D_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_SDRPRIMITIVE3D_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_PRIMITIVE_HXX
-#include <drawinglayer/primitive/primitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_PRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/primitive3d.hxx>
 #endif
 
 #ifndef _BGFX_MATRIX_B3DHOMMATRIX_HXX
 #include <basegfx/matrix/b3dhommatrix.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE3D_SDRALLATTRIBUTE3D_HXX
-#include <drawinglayer/primitive3d/sdrallattribute3d.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRALLATTRIBUTE3D_HXX
+#include <drawinglayer/attribute/sdrallattribute3d.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE3D_SDRATTRIBUTE3D_HXX
-#include <drawinglayer/primitive3d/sdrattribute3d.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrattribute.hxx>
 #endif
 
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_SDREXTRUDELATHETOOLS3D_HXX
 #include <drawinglayer/primitive3d/sdrextrudelathetools3d.hxx>
 #endif
 
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE3D_HXX
+#include <drawinglayer/attribute/sdrattribute3d.hxx>
+#endif
+
 //////////////////////////////////////////////////////////////////////////////
 // predefines
 
@@ -63,40 +67,40 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class sdrPrimitive3D : public basePrimitive
+        class sdrPrimitive3D : public basePrimitive3D
         {
         protected:
-            ::basegfx::B3DHomMatrix                     maTransform;
-            ::basegfx::B2DVector                        maTextureSize;
-            sdrLineFillShadowAttribute                  maSdrLFSAttribute;
-            sdr3DObjectAttribute                        maSdr3DObjectAttribute;
+            basegfx::B3DHomMatrix                       maTransform;
+            basegfx::B2DVector                      maTextureSize;
+            attribute::sdrLineFillShadowAttribute       maSdrLFSAttribute;
+            attribute::sdr3DObjectAttribute             maSdr3DObjectAttribute;
 
             // Standard implementation for primitive3D which
             // will use maTransform as range and expand by evtl. line width / 2
-            ::basegfx::B3DRange getStandard3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            basegfx::B3DRange getStandard3DRange() const;
 
             // implementation for primitive3D which
             // will use given slices and expand by evtl. line width / 2
-            ::basegfx::B3DRange get3DRangeFromSlices(const sliceVector& rSlices, const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            basegfx::B3DRange get3DRangeFromSlices(const sliceVector& rSlices) const;
 
         public:
             sdrPrimitive3D(
-                const ::basegfx::B3DHomMatrix& rTransform,
-                const ::basegfx::B2DVector& rTextureSize,
-                const sdrLineFillShadowAttribute& rSdrLFSAttribute,
-                const sdr3DObjectAttribute& rSdr3DObjectAttribute);
+                const basegfx::B3DHomMatrix& rTransform,
+                const basegfx::B2DVector& rTextureSize,
+                const attribute::sdrLineFillShadowAttribute& rSdrLFSAttribute,
+                const attribute::sdr3DObjectAttribute& rSdr3DObjectAttribute);
             virtual ~sdrPrimitive3D();
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // data access
-            const ::basegfx::B3DHomMatrix& getTransform() const { return maTransform; }
-            const ::basegfx::B2DVector& getTextureSize() const { return maTextureSize; }
-            const sdrLineFillShadowAttribute& getSdrLFSAttribute() const { return maSdrLFSAttribute; }
-            const sdr3DObjectAttribute getSdr3DObjectAttribute() const { return maSdr3DObjectAttribute; }
+            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; }
         };
     } // end of namespace overlay
 } // end of namespace drawinglayer
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx
index 35e61f32747d..5f4302b0b5d2 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/sdrsphereprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrsphereprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -47,7 +47,7 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class sdrSpherePrimitive3D : public sdrPrimitive3D
         {
@@ -56,25 +56,25 @@ namespace drawinglayer
             sal_uInt32                                  mnVerticalSegments;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
             sdrSpherePrimitive3D(
-                const ::basegfx::B3DHomMatrix& rTransform,
-                const ::basegfx::B2DVector& rTextureSize,
-                const sdrLineFillShadowAttribute& rSdrLFSAttribute,
-                const sdr3DObjectAttribute& rSdr3DObjectAttribute,
+                const basegfx::B3DHomMatrix& rTransform,
+                const basegfx::B2DVector& rTextureSize,
+                const attribute::sdrLineFillShadowAttribute& rSdrLFSAttribute,
+                const attribute::sdr3DObjectAttribute& rSdr3DObjectAttribute,
                 sal_uInt32 nHorizontalSegments, sal_uInt32 nVerticalSegments);
             virtual ~sdrSpherePrimitive3D();
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3D range of primitive.
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
 
             // data access
             sal_uInt32 getHorizontalSegments() const { return mnHorizontalSegments; }
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx
index a26f2e43003f..f25e2c1da32e 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/shadowprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: shadowprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:14 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,8 +36,8 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_SHADOWPRIMITIVE3D_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_SHADOWPRIMITIVE3D_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_VECTORPRIMITIVE_HXX
-#include <drawinglayer/primitive/vectorprimitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_VECTORPRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/vectorprimitive3d.hxx>
 #endif
 
 #ifndef _BGFX_MATRIX_B2DHOMMATRIX_HXX
@@ -52,13 +52,13 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class shadowPrimitive3D : public vectorPrimitive
+        class shadowPrimitive3D : public vectorPrimitive3D
         {
         protected:
-            ::basegfx::B2DHomMatrix                     maShadowTransform;
-            ::basegfx::BColor                           maShadowColor;
+            basegfx::B2DHomMatrix                       maShadowTransform;
+            basegfx::BColor                         maShadowColor;
             double                                      mfShadowTransparence;
 
             // bitfield
@@ -66,23 +66,23 @@ namespace drawinglayer
 
         public:
             shadowPrimitive3D(
-                const ::basegfx::B2DHomMatrix& rShadowTransform, const ::basegfx::BColor& rShadowColor,
-                double fShadowTransparence, bool bShadow3D, const primitiveVector& rPrimitiveVector);
+                const basegfx::B2DHomMatrix& rShadowTransform, const basegfx::BColor& rShadowColor,
+                double fShadowTransparence, bool bShadow3D, const primitiveVector3D& rPrimitiveVector);
             virtual ~shadowPrimitive3D();
 
             // get data
-            const ::basegfx::B2DHomMatrix& getShadowTransform() const { return maShadowTransform; }
-            const ::basegfx::BColor& getShadowColor() const { return maShadowColor; }
+            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
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx
index 85dc14523fdf..3d65319f4d7f 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/textureprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: textureprimitive3d.hxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:57:59 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:13 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,16 +36,16 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_TEXTUREPRIMITIVE3D_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_TEXTUREPRIMITIVE3D_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_VECTORPRIMITIVE_HXX
-#include <drawinglayer/primitive/vectorprimitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_VECTORPRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/vectorprimitive3d.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_FILLATTRIBUTE_HXX
-#include <drawinglayer/primitive/fillattribute.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLATTRIBUTE_HXX
+#include <drawinglayer/attribute/fillattribute.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_FILLBITMAPATTRIBUTE_HXX
-#include <drawinglayer/primitive/fillbitmapattribute.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLBITMAPATTRIBUTE_HXX
+#include <drawinglayer/attribute/fillbitmapattribute.hxx>
 #endif
 
 #ifndef _BGFX_MATRIX_B2DHOMMATRIX_HXX
@@ -56,12 +56,12 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class texturePrimitive3D : public vectorPrimitive
+        class texturePrimitive3D : public vectorPrimitive3D
         {
         protected:
-            ::basegfx::B2DVector                        maTextureSize;
+            basegfx::B2DVector                      maTextureSize;
 
             // bitfield
             // flag if texture shall be modulated with white interpolated color
@@ -72,28 +72,28 @@ namespace drawinglayer
 
         public:
             texturePrimitive3D(
-                const primitiveVector& rPrimitiveVector,
-                const ::basegfx::B2DVector& rTextureSize,
+                const primitiveVector3D& rPrimitiveVector,
+                const basegfx::B2DVector& rTextureSize,
                 bool bModulate,
                 bool bFilter);
             virtual ~texturePrimitive3D();
 
             // get data
-            const ::basegfx::B2DVector& getTextureSize() const { return maTextureSize; }
+            const basegfx::B2DVector& getTextureSize() const { return maTextureSize; }
             bool getModulate() const { return mbModulate; }
             bool getFilter() const { return mbFilter; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class simpleTransparenceTexturePrimitive3D : public texturePrimitive3D
         {
@@ -101,118 +101,118 @@ namespace drawinglayer
             double                                      mfTransparence;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
             simpleTransparenceTexturePrimitive3D(
                 double fTransparence,
-                const primitiveVector& rPrimitiveVector);
+                const primitiveVector3D& rPrimitiveVector);
             virtual ~simpleTransparenceTexturePrimitive3D();
 
             // get data
             double getTransparence() const { return mfTransparence; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class gradientTexturePrimitive3D : public texturePrimitive3D
         {
         protected:
-            fillGradientAttribute                       maGradient;
+            attribute::fillGradientAttribute        maGradient;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
             gradientTexturePrimitive3D(
-                const fillGradientAttribute& rGradient,
-                const primitiveVector& rPrimitiveVector,
-                const ::basegfx::B2DVector& rTextureSize,
+                const attribute::fillGradientAttribute& rGradient,
+                const primitiveVector3D& rPrimitiveVector,
+                const basegfx::B2DVector& rTextureSize,
                 bool bModulate,
                 bool bFilter);
             virtual ~gradientTexturePrimitive3D();
 
             // get data
-            const fillGradientAttribute& getGradient() const { return maGradient; }
+            const attribute::fillGradientAttribute& getGradient() const { return maGradient; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class bitmapTexturePrimitive3D : public texturePrimitive3D
         {
         protected:
-            fillBitmapAttribute                         maBitmap;
+            attribute::fillBitmapAttribute      maBitmap;
 
             //  create decomposition
-            virtual void decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation);
+            virtual void decompose(primitiveVector3D& rTarget);
 
         public:
             bitmapTexturePrimitive3D(
-                const fillBitmapAttribute& rBitmap,
-                const primitiveVector& rPrimitiveVector,
-                const ::basegfx::B2DVector& rTextureSize,
+                const attribute::fillBitmapAttribute& rBitmap,
+                const primitiveVector3D& rPrimitiveVector,
+                const basegfx::B2DVector& rTextureSize,
                 bool bModulate,
                 bool bFilter);
             virtual ~bitmapTexturePrimitive3D();
 
             // get data
-            const fillBitmapAttribute& getBitmap() const { return maBitmap; }
+            const attribute::fillBitmapAttribute& getBitmap() const { return maBitmap; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         class transparenceTexturePrimitive3D : public gradientTexturePrimitive3D
         {
         public:
             transparenceTexturePrimitive3D(
-                const fillGradientAttribute& rGradient,
-                const primitiveVector& rPrimitiveVector,
-                const ::basegfx::B2DVector& rTextureSize);
+                const attribute::fillGradientAttribute& rGradient,
+                const primitiveVector3D& rPrimitiveVector,
+                const basegfx::B2DVector& rTextureSize);
             virtual ~transparenceTexturePrimitive3D();
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx b/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx
index 16c83f88e524..ad8ea2b2648b 100644
--- a/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive3d/transformprimitive3d.hxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: transformprimitive3d.hxx,v $
  *
- *  $Revision: 1.1 $
+ *  $Revision: 1.2 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 14:11:41 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:38:14 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -36,8 +36,8 @@
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_TRANSFORMPRIMITIVE3D_HXX
 #define _DRAWINGLAYER_PRIMITIVE3D_TRANSFORMPRIMITIVE3D_HXX
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_VECTORPRIMITIVE_HXX
-#include <drawinglayer/primitive/vectorprimitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_VECTORPRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/vectorprimitive3d.hxx>
 #endif
 
 #ifndef _BGFX_MATRIX_B3DHOMMATRIX_HXX
@@ -48,30 +48,30 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        class transformPrimitive3D : public vectorPrimitive
+        class transformPrimitive3D : public vectorPrimitive3D
         {
         protected:
-            ::basegfx::B3DHomMatrix                 maTransformation;
+            basegfx::B3DHomMatrix                   maTransformation;
 
         public:
-            transformPrimitive3D(const ::basegfx::B3DHomMatrix& rTransformation, const primitiveVector& rPrimitiveVector);
+            transformPrimitive3D(const basegfx::B3DHomMatrix& rTransformation, const primitiveVector3D& rPrimitiveVector);
             virtual ~transformPrimitive3D();
 
             // get data
-            const ::basegfx::B3DHomMatrix& getTransformation() const { return maTransformation; }
+            const basegfx::B3DHomMatrix& getTransformation() const { return maTransformation; }
 
             // compare operator
-            virtual bool operator==(const basePrimitive& rPrimitive) const;
+            virtual bool operator==(const basePrimitive3D& rPrimitive) const;
 
             // id generator
             virtual PrimitiveID getID() const;
 
             // get 3D range of primitive (for 3D geometries). Default implementation uses decomposition, analog to getRange
-            virtual ::basegfx::B3DRange get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const;
+            virtual basegfx::B3DRange get3DRange() const;
         };
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
author	Armin Weiss <aw@openoffice.org>	2006-08-09 15:39:25 +0000
committer	Armin Weiss <aw@openoffice.org>	2006-08-09 15:39:25 +0000
commit	73679d08d7072f98065007b7014df46e45e2862e (patch)
tree	af4d42d577dd245a2fcbe4482770587f5684e4ef /drawinglayer
parent	b04c2937bbc5b3db538e9523e078b469f9899b67 (diff)