#i39532#

30 files changed, 2855 insertions, 625 deletions

diff --git a/drawinglayer/inc/drawinglayer/processor3d/baseprocessor3d.hxx b/drawinglayer/inc/drawinglayer/processor3d/baseprocessor3d.hxx
new file mode 100644
index 000000000000..d34d76cf0f01
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/processor3d/baseprocessor3d.hxx
@@ -0,0 +1,113 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: baseprocessor3d.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:45:32 $
+ *
+ *  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_PROCESSOR3D_BASEPROCESSOR3D_HXX
+#define _DRAWINGLAYER_PROCESSOR3D_BASEPROCESSOR3D_HXX
+
+#ifndef _DRAWINGLAYER_GEOMETRY_VIEWINFORMATION_HXX
+#include <drawinglayer/geometry/viewinformation.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_GEOMETRY_TRANSFORMATION3D_HXX
+#include <drawinglayer/geometry/transformation3d.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_PRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/primitive3d.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace processor3d
+    {
+        class baseProcessor3D
+        {
+        protected:
+            // the view information and the complete 3d stack
+            const geometry::viewInformation         maViewInformation;
+            const geometry::transformation3D        maTransformation3D;
+
+        public:
+            baseProcessor3D(
+                const geometry::viewInformation& rViewInformation,
+                const geometry::transformation3D& rTransformation3D);
+            virtual ~baseProcessor3D();
+
+            // the central processing method
+            virtual void process(const primitive3d::primitiveVector3D& rSource) = 0;
+
+            // data access
+            const geometry::viewInformation& getViewInformation() const { return maViewInformation; }
+            const geometry::transformation3D& getTransformation3D() const { return maTransformation3D; }
+        };
+    } // end of namespace processor3d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace processor3d
+    {
+        class collectingProcessor3D : public baseProcessor3D
+        {
+        protected:
+            primitive3d::primitiveVector3D      maPrimitiveVector;
+
+        public:
+            collectingProcessor3D(
+                const geometry::viewInformation& rViewInformation,
+                const geometry::transformation3D& rTransformation3D);
+            virtual ~collectingProcessor3D();
+
+            // the central processing method
+            virtual void process(const primitive3d::primitiveVector3D& rSource);
+
+            // data access
+            const primitive3d::primitiveVector3D& getPrimitives() const { return maPrimitiveVector; }
+        };
+    } // end of namespace processor3d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_PROCESSOR3D_BASEPROCESSOR3D_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/processor3d/defaultprocessor3d.hxx b/drawinglayer/inc/drawinglayer/processor3d/defaultprocessor3d.hxx
new file mode 100644
index 000000000000..3bc59564aea6
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/processor3d/defaultprocessor3d.hxx
@@ -0,0 +1,182 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: defaultprocessor3d.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:45:32 $
+ *
+ *  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_PROCESSOR3D_DEFAULTPROCESSOR3D_HXX
+#define _DRAWINGLAYER_PROCESSOR3D_DEFAULTPROCESSOR3D_HXX
+
+#ifndef _DRAWINGLAYER_PROCESSOR3D_BASEPROCESSOR3D_HXX
+#include <drawinglayer/processor3d/baseprocessor3d.hxx>
+#endif
+
+#ifndef _BGFX_MATRIX_B3DHOMMATRIX_HXX
+#include <basegfx/matrix/b3dhommatrix.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_GEOMETRY_TRANSFORMATION3D_HXX
+#include <drawinglayer/geometry/transformation3d.hxx>
+#endif
+
+#ifndef _SV_BITMAPEX_HXX
+#include <vcl/bitmapex.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_MODIFIEDCOLORPRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
+#endif
+
+#ifndef _BGFX_RANGE_B2DRANGE_HXX
+#include <basegfx/range/b2drange.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+namespace basegfx {
+    class BZPixelRaster;
+}
+
+namespace drawinglayer { namespace attribute {
+    class sdrSceneAttribute;
+    class sdrLightingAttribute;
+    class materialAttribute3D;
+}}
+
+namespace drawinglayer { namespace primitive3d {
+    class polygonHairlinePrimitive3D;
+    class polyPolygonMaterialPrimitive3D;
+    class gradientTexturePrimitive3D;
+    class hatchTexturePrimitive3D;
+    class bitmapTexturePrimitive3D;
+    class transparenceTexturePrimitive3D;
+    class transformPrimitive3D;
+}}
+
+namespace drawinglayer { namespace texture {
+    class geoTexSvx;
+}}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace processor3d
+    {
+        class defaultProcessor3D : public baseProcessor3D
+        {
+        protected:
+            // render information
+            const attribute::sdrSceneAttribute&                 mrSdrSceneAttribute;    // read-only scene infos (normal handling, etc...)
+            const attribute::sdrLightingAttribute&              mrSdrLightingAttribute; // read-only light infos (lights, etc...)
+            basegfx::B3DHomMatrix                               maDeviceToView;         // scale and translate to map to target view size
+            basegfx::B3DHomMatrix                               maWorldToEye;           // world to eye coordinates
+            basegfx::B3DHomMatrix                               maWorldToView;          // mul maWorldToEye with maProjection and maDeviceToView
+            basegfx::B3DHomMatrix                               maInvEyeToView;         // back from view to eye coordinates
+            basegfx::B3DHomMatrix                               maInvWorldToView;       // back from view to world coordinates
+            basegfx::B2DRange                                   maRasterRange;          // the (0, 0, W, H) range from mpBZPixelRaster
+
+            // the target
+            basegfx::BZPixelRaster*                             mpBZPixelRaster;
+
+            // the modifiedColorPrimitive stack
+            basegfx::BColorModifierStack                        maBColorModifierStack;
+
+            // the current active texture
+            texture::geoTexSvx*                             mpGeoTexSvx;
+
+            // the current active transparence texture
+            texture::geoTexSvx*                             mpTransparenceGeoTexSvx;
+
+            // bitfield
+            unsigned                                            mbModulate : 1;
+            unsigned                                            mbFilter : 1;
+            unsigned                                            mbProcessTransparent : 1;
+            unsigned                                            mbContainsTransparent : 1;
+
+            //////////////////////////////////////////////////////////////////////////////
+            // rendering support
+            void impRender_GRX3(const primitive3d::gradientTexturePrimitive3D& rPrimitive, bool bTransparence);
+            void impRender_HAX3(const primitive3d::hatchTexturePrimitive3D& rPrimitive);
+            void impRender_BMX3(const primitive3d::bitmapTexturePrimitive3D& rPrimitive);
+            void impRender_MCOL(const primitive3d::modifiedColorPrimitive3D& rModifiedCandidate);
+            void impRender_POH3(const primitive3d::polygonHairlinePrimitive3D& rPrimitive);
+            void impRender_POM3(const primitive3d::polyPolygonMaterialPrimitive3D& rPrimitive);
+            void impRender_TRN3(const primitive3d::transformPrimitive3D& rTransformCandidate);
+
+            //////////////////////////////////////////////////////////////////////////////
+            // lighting support
+            basegfx::BColor impSolveColorModel(
+                basegfx::B3DVector aNormal,
+                const attribute::materialAttribute3D& rMaterial);
+
+        public:
+            defaultProcessor3D(
+                const geometry::viewInformation& rViewInformation,
+                const geometry::transformation3D& rTransformation3D,
+                const attribute::sdrSceneAttribute& rSdrSceneAttribute,
+                const attribute::sdrLightingAttribute& rSdrLightingAttribute,
+                double fSizeX,
+                double fSizeY,
+                const basegfx::B2DRange& rVisiblePart);
+            virtual ~defaultProcessor3D();
+
+            // the central processing method
+            virtual void process(const primitive3d::primitiveVector3D& rSource);
+
+            // helpers for drawing transparent parts in 2nd run
+            void processNonTransparent(const primitive3d::primitiveVector3D& rSource);
+            void processTransparent(const primitive3d::primitiveVector3D& rSource);
+
+            // data read access
+            const attribute::sdrLightingAttribute& getSdrLightingAttribute() const { return mrSdrLightingAttribute; }
+            const basegfx::BColorModifierStack& getBColorModifierStack() const { return maBColorModifierStack; }
+            const texture::geoTexSvx* getGeoTexSvx() const { return mpGeoTexSvx; }
+            const texture::geoTexSvx* getTransparenceGeoTexSvx() const { return mpTransparenceGeoTexSvx; }
+            bool getModulate() const { return mbModulate; }
+            bool getFilter() const { return mbFilter; }
+
+            // get the result as bitmapEx
+            BitmapEx getBitmapEx() const;
+        };
+    } // end of namespace processor3d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_PROCESSOR3D_DEFAULTPROCESSOR3D_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/processor3d/shadow3dextractor.hxx b/drawinglayer/inc/drawinglayer/processor3d/shadow3dextractor.hxx
new file mode 100644
index 000000000000..f4126416d043
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/processor3d/shadow3dextractor.hxx
@@ -0,0 +1,146 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: shadow3dextractor.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:45:32 $
+ *
+ *  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_PROCESSOR3D_SHADOW3DEXTRACTOR_HXX
+#define _DRAWINGLAYER_PROCESSOR3D_SHADOW3DEXTRACTOR_HXX
+
+#ifndef _DRAWINGLAYER_PROCESSOR3D_BASEPROCESSOR3D_HXX
+#include <drawinglayer/processor3d/baseprocessor3d.hxx>
+#endif
+
+#ifndef _BGFX_MATRIX_B2DHOMMATRIX_HXX
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#endif
+
+#ifndef _BGFX_MATRIX_B3DHOMMATRIX_HXX
+#include <basegfx/matrix/b3dhommatrix.hxx>
+#endif
+
+#ifndef _BGFX_POLYGON_B2DPOLYGON_HXX
+#include <basegfx/polygon/b2dpolygon.hxx>
+#endif
+
+#ifndef _BGFX_POLYGON_B3DPOLYGON_HXX
+#include <basegfx/polygon/b3dpolygon.hxx>
+#endif
+
+#ifndef _BGFX_POLYGON_B2DPOLYPOLYGON_HXX
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#endif
+
+#ifndef _BGFX_POLYGON_B3DPOLYPOLYGON_HXX
+#include <basegfx/polygon/b3dpolypolygon.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_PRIMITIVE_PRIMITIVE_HXX
+#include <drawinglayer/primitive/primitive.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// predefines
+
+namespace drawinglayer { namespace geometry {
+    class viewInformation;
+}}
+
+namespace drawinglayer { namespace attribute {
+    class sdrLightingAttribute;
+}}
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace processor3d
+    {
+        class shadow3DExtractingProcessor : public baseProcessor3D
+        {
+        protected:
+            // result holding vector (2D) and target vector for stacking (inited to &maPrimitiveVector)
+            primitive::primitiveVector                      maPrimitiveVector;
+            primitive::primitiveVector*                     mpTargetVector;
+
+            // prepared data (transformations) for 2D/3D shadow calculations
+            basegfx::B3DHomMatrix                           maWorldToEye;
+            basegfx::B3DHomMatrix                           maEyeToView;
+            basegfx::B3DHomMatrix                           maWorldToView;
+            basegfx::B3DVector                          maLightNormal;
+            basegfx::B3DVector                          maShadowPlaneNormal;
+            basegfx::B3DPoint                               maPlanePoint;
+            double                                          mfLightPlaneScalar;
+
+            // the shadow color used for sub-primitives. Can stay at black since
+            // the encapsulating 2d shadow primitive will contain the color
+            basegfx::BColor                             maPrimitiveColor;
+
+            // bitfield
+            // flag if shadow plane projection preparation leaded to valid results
+            unsigned                                        mbShadowProjectionIsValid : 1;
+
+            // flag if conversion is switched on
+            unsigned                                        mbConvert : 1;
+
+            // flag if conversion shall use projection
+            unsigned                                        mbUseProjection : 1;
+
+            // protected helpers
+            basegfx::B2DPolygon impDoShadowProjection(const basegfx::B3DPolygon& rSource);
+            basegfx::B2DPolyPolygon impDoShadowProjection(const basegfx::B3DPolyPolygon& rSource);
+
+        public:
+            shadow3DExtractingProcessor(
+                const geometry::viewInformation& rViewInformation,
+                const geometry::transformation3D& rTransformation3D,
+                const attribute::sdrLightingAttribute& rSdrLightingAttribute,
+                const primitive3d::primitiveVector3D& rPrimitiveVector,
+                double fShadowSlant);
+            virtual ~shadow3DExtractingProcessor();
+
+            // the central processing method
+            virtual void process(const primitive3d::primitiveVector3D& rSource);
+
+            // data access
+            const primitive::primitiveVector& getPrimitives() const { return maPrimitiveVector; }
+        };
+    } // end of namespace processor3d
+} // end of namespace drawinglayer
+
+#endif //_DRAWINGLAYER_PROCESSOR3D_SHADOW3DEXTRACTOR_HXX
+
+// eof
diff --git a/drawinglayer/inc/drawinglayer/texture/texture.hxx b/drawinglayer/inc/drawinglayer/texture/texture.hxx
new file mode 100644
index 000000000000..946297f92fad
--- /dev/null
+++ b/drawinglayer/inc/drawinglayer/texture/texture.hxx
@@ -0,0 +1,288 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: texture.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:46:03 $
+ *
+ *  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_TEXTURE_TEXTURE_HXX
+#define _DRAWINGLAYER_TEXTURE_TEXTURE_HXX
+
+#ifndef _BGFX_MATRIX_B2DHOMMATRIX_HXX
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#endif
+
+#ifndef _BGFX_RANGE_B2DRANGE_HXX
+#include <basegfx/range/b2drange.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+#include <vector>
+
+//////////////////////////////////////////////////////////////////////////////
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvx
+        {
+        public:
+            geoTexSvx();
+            virtual ~geoTexSvx();
+
+            // compare operator
+            virtual bool operator==(const geoTexSvx& rGeoTexSvx) const;
+            bool operator!=(const geoTexSvx& rGeoTexSvx) const { return !operator==(rGeoTexSvx); }
+
+            // virtual base methods
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+            virtual void modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradient : public geoTexSvx
+        {
+        protected:
+            basegfx::B2DHomMatrix               maTextureTransform;
+            basegfx::B2DHomMatrix               maBackTextureTransform;
+            basegfx::B2DRange                   maTargetRange;
+            basegfx::BColor                 maStart;
+            basegfx::BColor                 maEnd;
+            sal_uInt32                          mnSteps;
+            double                              mfAspect;
+            double                              mfBorder;
+
+            // helpers
+            void impAppendMatrix(::std::vector< basegfx::B2DHomMatrix >& rMatrices, const basegfx::B2DRange& rRange);
+            void impAppendColorsRadial(::std::vector< basegfx::BColor >& rColors);
+
+        public:
+            geoTexSvxGradient(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder);
+            virtual ~geoTexSvxGradient();
+
+            // compare operator
+            virtual bool operator==(const geoTexSvx& rGeoTexSvx) const;
+
+            // virtual base methods
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors) = 0;
+
+            // data access
+            const basegfx::BColor& getStart() const { return maStart; }
+            const basegfx::BColor& getEnd() const { return maEnd; }
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradientLinear : public geoTexSvxGradient
+        {
+        public:
+            geoTexSvxGradientLinear(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fAngle);
+            virtual ~geoTexSvxGradientLinear();
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradientAxial : public geoTexSvxGradient
+        {
+        protected:
+            double                              mfInternalSteps;
+
+        public:
+            geoTexSvxGradientAxial(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fAngle);
+            virtual ~geoTexSvxGradientAxial();
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradientRadial : public geoTexSvxGradient
+        {
+        public:
+            geoTexSvxGradientRadial(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY);
+            virtual ~geoTexSvxGradientRadial();
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradientElliptical : public geoTexSvxGradient
+        {
+        public:
+            geoTexSvxGradientElliptical(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY, double fAngle);
+            virtual ~geoTexSvxGradientElliptical();
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradientSquare : public geoTexSvxGradient
+        {
+        public:
+            geoTexSvxGradientSquare(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY, double fAngle);
+            virtual ~geoTexSvxGradientSquare();
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxGradientRect : public geoTexSvxGradient
+        {
+        public:
+            geoTexSvxGradientRect(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY, double fAngle);
+            virtual ~geoTexSvxGradientRect();
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            virtual void appendColors(::std::vector< basegfx::BColor >& rColors);
+            virtual void modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxHatch : public geoTexSvx
+        {
+        protected:
+            basegfx::B2DHomMatrix               maTextureTransform;
+            basegfx::B2DHomMatrix               maBackTextureTransform;
+            double                              mfDistance;
+            double                              mfAngle;
+            sal_uInt32                          mnSteps;
+
+        public:
+            geoTexSvxHatch(const basegfx::B2DRange& rTargetRange, double fDistance, double fAngle);
+            virtual ~geoTexSvxHatch();
+
+            // compare operator
+            virtual bool operator==(const geoTexSvx& rGeoTexSvx) const;
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+            double getDistanceToHatch(const basegfx::B2DPoint& rUV) const;
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace texture
+    {
+        class geoTexSvxTiled : public geoTexSvx
+        {
+        protected:
+            basegfx::B2DPoint                           maTopLeft;
+            basegfx::B2DVector                      maSize;
+
+        public:
+            geoTexSvxTiled(const basegfx::B2DPoint& rTopLeft, const basegfx::B2DVector& rSize);
+            virtual ~geoTexSvxTiled();
+
+            // compare operator
+            virtual bool operator==(const geoTexSvx& rGeoTexSvx) const;
+
+            virtual void appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices);
+        };
+    } // end of namespace texture
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+#endif //_DRAWINGLAYER_TEXTURE_TEXTURE_HXX
+
+// eof
diff --git a/drawinglayer/source/animation/animationtiming.cxx b/drawinglayer/source/animation/animationtiming.cxx
index d3a4654a6e57..5ffe14f6d4f4 100644
--- a/drawinglayer/source/animation/animationtiming.cxx
+++ b/drawinglayer/source/animation/animationtiming.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: animationtiming.cxx,v $
  *
- *  $Revision: 1.1 $
+ *  $Revision: 1.2 $
  *
- *  last change: $Author: aw $ $Date: 2006-05-12 11:50:12 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:02 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -37,6 +37,10 @@
 #include <drawinglayer/animation/animationtiming.hxx>
 #endif
 
+#ifndef _BGFX_NUMERIC_FTOOLS_HXX
+#include <basegfx/numeric/ftools.hxx>
+#endif
+
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
@@ -75,8 +79,8 @@ namespace drawinglayer
             const animationEntryFixed* pCompare = dynamic_cast< const animationEntryFixed* >(&rCandidate);
 
             return (pCompare
-                && mfDuration == pCompare->mfDuration
-                && mfState == pCompare->mfState);
+                && basegfx::fTools::equal(mfDuration, pCompare->mfDuration)
+                && basegfx::fTools::equal(mfState, pCompare->mfState));
         }
 
         double animationEntryFixed::getDuration() const
@@ -91,12 +95,14 @@ namespace drawinglayer
 
         double animationEntryFixed::getNextEventTime(double fTime) const
         {
-            if(fTime < mfDuration)
+            if(basegfx::fTools::less(fTime, mfDuration))
             {
-                fTime = mfDuration;
+                return mfDuration;
+            }
+            else
+            {
+                return 0.0;
             }
-
-            return fTime;
         }
 
         //////////////////////////////////////////////////////////////////////////////
@@ -123,9 +129,9 @@ namespace drawinglayer
             const animationEntryLinear* pCompare = dynamic_cast< const animationEntryLinear* >(&rCandidate);
 
             return (pCompare
-                && mfDuration == pCompare->mfDuration
-                && mfStart == pCompare->mfStart
-                && mfStop == pCompare->mfStop);
+                && basegfx::fTools::equal(mfDuration, pCompare->mfDuration)
+                && basegfx::fTools::equal(mfStart, pCompare->mfStart)
+                && basegfx::fTools::equal(mfStop, pCompare->mfStop));
         }
 
         double animationEntryLinear::getDuration() const
@@ -135,10 +141,18 @@ namespace drawinglayer
 
         double animationEntryLinear::getStateAtTime(double fTime) const
         {
-            if(0.0 != mfDuration)
+            if(basegfx::fTools::more(mfDuration, 0.0))
             {
                 const double fFactor(fTime / mfDuration);
-                return mfStart + ((mfStop - mfStart) * fFactor);
+
+                if(fFactor > 1.0)
+                {
+                    return mfStop;
+                }
+                else
+                {
+                    return mfStart + ((mfStop - mfStart) * fFactor);
+                }
             }
             else
             {
@@ -148,20 +162,24 @@ namespace drawinglayer
 
         double animationEntryLinear::getNextEventTime(double fTime) const
         {
-            if(fTime < mfDuration)
+            if(basegfx::fTools::less(fTime, mfDuration))
             {
                 // use the simple solution: just add the frequency. More correct (but also more
                 // complicated) would be to calculate the slice of time we are in and when this
                 // slice will end. For the animations, this makes no quality difference.
                 fTime += mfFrequency;
 
-                if(fTime > mfDuration)
+                if(basegfx::fTools::more(fTime, mfDuration))
                 {
                     fTime = mfDuration;
                 }
-            }
 
-            return fTime;
+                return fTime;
+            }
+            else
+            {
+                return 0.0;
+            }
         }
 
         //////////////////////////////////////////////////////////////////////////////
@@ -170,7 +188,7 @@ namespace drawinglayer
         {
             sal_uInt32 nIndex(0L);
 
-            while(nIndex < maEntries.size() && rfAddedTime + maEntries[nIndex]->getDuration() <= fTime)
+            while(nIndex < maEntries.size() && basegfx::fTools::lessOrEqual(rfAddedTime + maEntries[nIndex]->getDuration(), fTime))
             {
                 rfAddedTime += maEntries[nIndex++]->getDuration();
             }
@@ -183,15 +201,6 @@ namespace drawinglayer
         {
         }
 
-        animationEntryList::animationEntryList(const animationEntryList& rCandidate)
-        :   mfDuration(0.0)
-        {
-            for(sal_uInt32 a(0L); a < rCandidate.maEntries.size(); a++)
-            {
-                append(*rCandidate.maEntries[a]);
-            }
-        }
-
         animationEntryList::~animationEntryList()
         {
             for(sal_uInt32 a(0L); a < maEntries.size(); a++)
@@ -236,7 +245,7 @@ namespace drawinglayer
         {
             const double fDuration(rCandidate.getDuration());
 
-            if(0.0 != fDuration)
+            if(!basegfx::fTools::equalZero(fDuration))
             {
                 maEntries.push_back(rCandidate.clone());
                 mfDuration += fDuration;
@@ -250,7 +259,7 @@ namespace drawinglayer
 
         double animationEntryList::getStateAtTime(double fTime) const
         {
-            if(0.0 != mfDuration)
+            if(!basegfx::fTools::equalZero(mfDuration))
             {
                 double fAddedTime(0.0);
                 const sal_uInt32 nIndex(impGetIndexAtTime(fTime, fAddedTime));
@@ -266,18 +275,20 @@ namespace drawinglayer
 
         double animationEntryList::getNextEventTime(double fTime) const
         {
-            if(0.0 != mfDuration)
+            double fNewTime(0.0);
+
+            if(!basegfx::fTools::equalZero(mfDuration))
             {
                 double fAddedTime(0.0);
                 const sal_uInt32 nIndex(impGetIndexAtTime(fTime, fAddedTime));
 
                 if(nIndex < maEntries.size())
                 {
-                    return maEntries[nIndex]->getNextEventTime(fTime - fAddedTime);
+                    fNewTime = maEntries[nIndex]->getNextEventTime(fTime - fAddedTime) + fAddedTime;
                 }
             }
 
-            return fTime;
+            return fNewTime;
         }
 
         //////////////////////////////////////////////////////////////////////////////
@@ -309,8 +320,8 @@ namespace drawinglayer
             const animationEntryLoop* pCompare = dynamic_cast< const animationEntryLoop* >(&rCandidate);
 
             return (pCompare
-                && animationEntryList::operator==(rCandidate)
-                && mnRepeat == pCompare->mnRepeat);
+                && mnRepeat == pCompare->mnRepeat
+                && animationEntryList::operator==(rCandidate));
         }
 
         double animationEntryLoop::getDuration() const
@@ -320,7 +331,7 @@ namespace drawinglayer
 
         double animationEntryLoop::getStateAtTime(double fTime) const
         {
-            if(mnRepeat && 0.0 != mfDuration)
+            if(mnRepeat && !basegfx::fTools::equalZero(mfDuration))
             {
                 const sal_uInt32 nCurrentLoop((sal_uInt32)(fTime / mfDuration));
 
@@ -341,7 +352,9 @@ namespace drawinglayer
 
         double animationEntryLoop::getNextEventTime(double fTime) const
         {
-            if(mnRepeat && 0.0 != mfDuration)
+            double fNewTime(0.0);
+
+            if(mnRepeat && !basegfx::fTools::equalZero(mfDuration))
             {
                 const sal_uInt32 nCurrentLoop((sal_uInt32)(fTime / mfDuration));
 
@@ -351,14 +364,14 @@ namespace drawinglayer
                     const double fRelativeTime(fTime - fTimeAtLoopStart);
                     const double fNextEventAtLoop(animationEntryList::getNextEventTime(fRelativeTime));
 
-                    if(fNextEventAtLoop != fRelativeTime)
+                    if(!basegfx::fTools::equalZero(fNextEventAtLoop))
                     {
-                        return fNextEventAtLoop + fTimeAtLoopStart;
+                        fNewTime = fNextEventAtLoop + fTimeAtLoopStart;
                     }
                 }
             }
 
-            return fTime;
+            return fNewTime;
         }
     } // end of namespace animation
 } // end of namespace drawinglayer
diff --git a/drawinglayer/source/animation/makefile.mk b/drawinglayer/source/animation/makefile.mk
index 2d1d39b4c387..ef533c8a8614 100644
--- a/drawinglayer/source/animation/makefile.mk
+++ b/drawinglayer/source/animation/makefile.mk
@@ -4,9 +4,9 @@
 #
 #   $RCSfile: makefile.mk,v $
 #
-#   $Revision: 1.1 $
+#   $Revision: 1.2 $
 #
-#   last change: $Author: aw $ $Date: 2006-05-12 11:50:12 $
+#   last change: $Author: aw $ $Date: 2006-08-09 16:47:02 $
 #
 #   The Contents of this file are made available subject to
 #   the terms of GNU Lesser General Public License Version 2.1.
@@ -45,7 +45,7 @@ TARGET=animation
 
 SLOFILES= \
         $(SLO)$/animationtiming.obj
-
+        
 # --- Targets ----------------------------------
 
 .INCLUDE : target.mk
diff --git a/drawinglayer/source/attribute/fillattribute.cxx b/drawinglayer/source/attribute/fillattribute.cxx
new file mode 100644
index 000000000000..197f65071a0f
--- /dev/null
+++ b/drawinglayer/source/attribute/fillattribute.cxx
@@ -0,0 +1,104 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: fillattribute.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:33 $
+ *
+ *  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
+#include <drawinglayer/attribute/fillattribute.hxx>
+#endif
+
+#ifndef _BGFX_NUMERIC_FTOOLS_HXX
+#include <basegfx/numeric/ftools.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        fillGradientAttribute::fillGradientAttribute(GradientStyle eStyle, double fBorder, double fOffsetX, double fOffsetY, double fAngle,
+            const basegfx::BColor& rStartColor, const basegfx::BColor& rEndColor, sal_uInt16 nSteps)
+        :   maStartColor(rStartColor),
+            maEndColor(rEndColor),
+            mfBorder(fBorder),
+            mfOffsetX(fOffsetX),
+            mfOffsetY(fOffsetY),
+            mfAngle(fAngle),
+            meStyle(eStyle),
+            mnSteps(nSteps)
+        {
+        }
+
+        bool fillGradientAttribute::operator==(const fillGradientAttribute& rCandidate) const
+        {
+            return (meStyle == rCandidate.meStyle
+                && maStartColor == rCandidate.maStartColor
+                && maEndColor == rCandidate.maEndColor
+                && mfBorder == rCandidate.mfBorder
+                && mfOffsetX == rCandidate.mfOffsetX
+                && mfOffsetY == rCandidate.mfOffsetY
+                && mfAngle == rCandidate.mfAngle
+                && mnSteps == rCandidate.mnSteps);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        fillHatchAttribute::fillHatchAttribute(HatchStyle eStyle, double fDistance, double fAngle, const basegfx::BColor& rColor, bool bFillBackground)
+        :   mfDistance(fDistance),
+            mfAngle(fAngle),
+            maColor(rColor),
+            meStyle(eStyle),
+            mbFillBackground(bFillBackground)
+        {
+        }
+
+        bool fillHatchAttribute::operator==(const fillHatchAttribute& rCandidate) const
+        {
+            return (meStyle == rCandidate.meStyle
+                && mfDistance == rCandidate.mfDistance
+                && mfAngle == rCandidate.mfAngle
+                && maColor == rCandidate.maColor
+                && mbFillBackground  == rCandidate.mbFillBackground);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/attribute/fillbitmapattribute.cxx b/drawinglayer/source/attribute/fillbitmapattribute.cxx
new file mode 100644
index 000000000000..625657412eaa
--- /dev/null
+++ b/drawinglayer/source/attribute/fillbitmapattribute.cxx
@@ -0,0 +1,65 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: fillbitmapattribute.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:33 $
+ *
+ *  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
+#include <drawinglayer/attribute/fillbitmapattribute.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        fillBitmapAttribute::fillBitmapAttribute(const Bitmap& rBitmap, const basegfx::B2DPoint& rTopLeft, const basegfx::B2DVector& rSize, bool bTiling)
+        :   maBitmap(rBitmap),
+            maTopLeft(rTopLeft),
+            maSize(rSize),
+            mbTiling(bTiling)
+        {
+        }
+
+        bool fillBitmapAttribute::operator==(const fillBitmapAttribute& rCandidate) const
+        {
+            return (maBitmap == rCandidate.maBitmap
+                && maTopLeft == rCandidate.maTopLeft
+                && maSize == rCandidate.maSize
+                && mbTiling == rCandidate.mbTiling);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/attribute/makefile.mk b/drawinglayer/source/attribute/makefile.mk
new file mode 100644
index 000000000000..7e4bccd0b959
--- /dev/null
+++ b/drawinglayer/source/attribute/makefile.mk
@@ -0,0 +1,57 @@
+#*************************************************************************
+#
+#   OpenOffice.org - a multi-platform office productivity suite
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: aw $ $Date: 2006-08-09 16:47:33 $
+#
+#   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
+#
+#*************************************************************************
+
+PRJ=..$/..
+PRJNAME=drawinglayer
+TARGET=attribute
+
+# --- Settings ----------------------------------
+
+.INCLUDE :  	settings.mk
+
+# --- Files -------------------------------------
+
+SLOFILES= \
+        $(SLO)$/fillattribute.obj			\
+        $(SLO)$/fillbitmapattribute.obj		\
+        $(SLO)$/materialattribute3d.obj		\
+        $(SLO)$/sdrallattribute3d.obj		\
+        $(SLO)$/sdrattribute.obj			\
+        $(SLO)$/sdrattribute3d.obj			\
+        $(SLO)$/sdrfillbitmapattribute.obj
+
+# --- Targets ----------------------------------
+
+.INCLUDE : target.mk
diff --git a/drawinglayer/source/attribute/materialattribute3d.cxx b/drawinglayer/source/attribute/materialattribute3d.cxx
new file mode 100644
index 000000000000..4a2c0b30cdbc
--- /dev/null
+++ b/drawinglayer/source/attribute/materialattribute3d.cxx
@@ -0,0 +1,194 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: materialattribute3d.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:33 $
+ *
+ *  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
+#include <drawinglayer/attribute/materialattribute3d.hxx>
+#endif
+
+#ifndef _BGFX_COLOR_BCOLOR_HXX
+#include <basegfx/color/bcolor.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace
+    {
+        class impMaterialAttribute3D
+        {
+        public:
+            // materialAttribute3D definitions
+            basegfx::BColor                         maColor;                // object color
+            basegfx::BColor                         maSpecular;             // material specular color
+            basegfx::BColor                         maEmission;             // material emissive color
+            sal_uInt16                                  mnSpecularIntensity;    // material specular intensity [0..128]
+
+            // refcounter
+            sal_uInt32                                  mnRefCount;
+
+            impMaterialAttribute3D(const basegfx::BColor& rColor, const basegfx::BColor& rSpecular, const basegfx::BColor& rEmission, sal_uInt16 nSpecularIntensity)
+            :   maColor(rColor),
+                maSpecular(rSpecular),
+                maEmission(rEmission),
+                mnSpecularIntensity(nSpecularIntensity),
+                mnRefCount(0L)
+            {
+            }
+
+            impMaterialAttribute3D(const basegfx::BColor& rColor)
+            :   maColor(rColor),
+                maSpecular(1.0, 1.0, 1.0),
+                maEmission(),
+                mnSpecularIntensity(15),
+                mnRefCount(0L)
+            {
+            }
+
+            impMaterialAttribute3D()
+            :   mnSpecularIntensity(0),
+                mnRefCount(0L)
+            {
+            }
+
+            bool operator==(const impMaterialAttribute3D& rCandidate) const
+            {
+                return (maColor == rCandidate.maColor
+                    && maSpecular == rCandidate.maSpecular
+                    && maEmission == rCandidate.maEmission
+                    && mnSpecularIntensity == rCandidate.mnSpecularIntensity);
+            }
+
+            const basegfx::BColor& getColor() const { return maColor; }
+            const basegfx::BColor& getSpecular() const { return maSpecular; }
+            const basegfx::BColor& getEmission() const { return maEmission; }
+            sal_uInt16 getSpecularIntensity() const { return mnSpecularIntensity; }
+        };
+    } // end of anonymous namespace
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        materialAttribute3D::materialAttribute3D(const basegfx::BColor& rColor, const basegfx::BColor& rSpecular, const basegfx::BColor& rEmission, sal_uInt16 nSpecularIntensity)
+        :   mpMaterialAttribute3D(new impMaterialAttribute3D(rColor, rSpecular, rEmission, nSpecularIntensity))
+        {
+        }
+
+        materialAttribute3D::materialAttribute3D(const basegfx::BColor& rColor)
+        :   mpMaterialAttribute3D(new impMaterialAttribute3D(rColor))
+        {
+        }
+
+        materialAttribute3D::materialAttribute3D()
+        :   mpMaterialAttribute3D(new impMaterialAttribute3D())
+        {
+        }
+
+        materialAttribute3D::materialAttribute3D(const materialAttribute3D& rCandidate)
+        :   mpMaterialAttribute3D(rCandidate.mpMaterialAttribute3D)
+        {
+            mpMaterialAttribute3D->mnRefCount++;
+        }
+
+        materialAttribute3D::~materialAttribute3D()
+        {
+            if(mpMaterialAttribute3D->mnRefCount)
+            {
+                mpMaterialAttribute3D->mnRefCount--;
+            }
+            else
+            {
+                delete mpMaterialAttribute3D;
+            }
+        }
+
+        materialAttribute3D& materialAttribute3D::operator=(const materialAttribute3D& rCandidate)
+        {
+            if(rCandidate.mpMaterialAttribute3D != mpMaterialAttribute3D)
+            {
+                if(mpMaterialAttribute3D->mnRefCount)
+                {
+                    mpMaterialAttribute3D->mnRefCount--;
+                }
+                else
+                {
+                    delete mpMaterialAttribute3D;
+                }
+
+                mpMaterialAttribute3D = rCandidate.mpMaterialAttribute3D;
+                mpMaterialAttribute3D->mnRefCount++;
+            }
+
+            return *this;
+        }
+
+        bool materialAttribute3D::operator==(const materialAttribute3D& rCandidate) const
+        {
+            if(rCandidate.mpMaterialAttribute3D == mpMaterialAttribute3D)
+            {
+                return true;
+            }
+
+            return (*rCandidate.mpMaterialAttribute3D == *mpMaterialAttribute3D);
+        }
+
+        const basegfx::BColor& materialAttribute3D::getColor() const
+        {
+            return mpMaterialAttribute3D->getColor();
+        }
+
+        const basegfx::BColor& materialAttribute3D::getSpecular() const
+        {
+            return mpMaterialAttribute3D->getSpecular();
+        }
+
+        const basegfx::BColor& materialAttribute3D::getEmission() const
+        {
+            return mpMaterialAttribute3D->getEmission();
+        }
+
+        sal_uInt16 materialAttribute3D::getSpecularIntensity() const
+        {
+            return mpMaterialAttribute3D->getSpecularIntensity();
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/attribute/sdrallattribute3d.cxx b/drawinglayer/source/attribute/sdrallattribute3d.cxx
new file mode 100644
index 000000000000..1ac32323c7ef
--- /dev/null
+++ b/drawinglayer/source/attribute/sdrallattribute3d.cxx
@@ -0,0 +1,207 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrallattribute3d.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:33 $
+ *
+ *  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
+#include <drawinglayer/attribute/sdrallattribute3d.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrattribute.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLATTRIBUTE_HXX
+#include <drawinglayer/attribute/fillattribute.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// pointer compare define
+#define pointerOrContentEqual(p, q) ((p == q) || (p && q && *p == *q))
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrLineFillShadowAttribute::sdrLineFillShadowAttribute(
+            sdrLineAttribute* pLine,
+            sdrFillAttribute* pFill,
+            sdrLineStartEndAttribute* pLineStartEnd,
+            sdrShadowAttribute* pShadow,
+            fillGradientAttribute* pFillFloatTransGradient)
+        :   mpShadow(pShadow),
+            mpLine(pLine),
+            mpLineStartEnd(pLineStartEnd),
+            mpFill(pFill),
+            mpFillFloatTransGradient(pFillFloatTransGradient)
+        {
+        }
+
+        sdrLineFillShadowAttribute::sdrLineFillShadowAttribute(const sdrLineFillShadowAttribute& rCandidate)
+        :   mpShadow(0L),
+            mpLine(0L),
+            mpLineStartEnd(0L),
+            mpFill(0L),
+            mpFillFloatTransGradient(0L)
+        {
+            if(!(*this == rCandidate))
+            {
+                *this = rCandidate;
+            }
+        }
+
+        sdrLineFillShadowAttribute::~sdrLineFillShadowAttribute()
+        {
+            delete mpShadow;
+            delete mpLine;
+            delete mpLineStartEnd;
+            delete mpFill;
+            delete mpFillFloatTransGradient;
+        }
+
+        sdrLineFillShadowAttribute& sdrLineFillShadowAttribute::operator=(const sdrLineFillShadowAttribute& rCandidate)
+        {
+            // handle mpShadow
+            {
+                // delete local mpShadow if necessary
+                if(mpShadow && ((!rCandidate.mpShadow) || (!(*mpShadow == *rCandidate.mpShadow))))
+                {
+                    delete mpShadow;
+                    mpShadow = 0L;
+                }
+
+                // copy mpShadow if necessary
+                if(!mpShadow && rCandidate.mpShadow)
+                {
+                    mpShadow = new sdrShadowAttribute(*rCandidate.mpShadow);
+                }
+            }
+
+            // handle mpLine
+            {
+                // delete local mpLine if necessary
+                if(mpLine && ((!rCandidate.mpLine) || (!(*mpLine == *rCandidate.mpLine))))
+                {
+                    delete mpLine;
+                    mpLine = 0L;
+                }
+
+                // copy mpLine if necessary
+                if(!mpLine && rCandidate.mpLine)
+                {
+                    mpLine = new sdrLineAttribute(*rCandidate.mpLine);
+                }
+            }
+
+            // handle mpLineStartEnd
+            {
+                // delete local mpLineStartEnd if necessary
+                if(mpLineStartEnd && ((!rCandidate.mpLineStartEnd) || (!(*mpLineStartEnd == *rCandidate.mpLineStartEnd))))
+                {
+                    delete mpLineStartEnd;
+                    mpLineStartEnd = 0L;
+                }
+
+                // copy mpLineStartEnd if necessary
+                if(!mpLineStartEnd && rCandidate.mpLineStartEnd)
+                {
+                    mpLineStartEnd = new sdrLineStartEndAttribute(*rCandidate.mpLineStartEnd);
+                }
+            }
+
+            // handle mpFill
+            {
+                // delete local mpFill if necessary
+                if(mpFill && ((!rCandidate.mpFill) || (!(*mpFill == *rCandidate.mpFill))))
+                {
+                    delete mpFill;
+                    mpFill = 0L;
+                }
+
+                // copy mpFill if necessary
+                if(!mpFill && rCandidate.mpFill)
+                {
+                    mpFill = new sdrFillAttribute(*rCandidate.mpFill);
+                }
+            }
+
+            // handle mpFillFloatTransGradient
+            {
+                // delete local mpFillFloatTransGradient if necessary
+                if(mpFillFloatTransGradient && ((!rCandidate.mpFillFloatTransGradient) || (!(*mpFillFloatTransGradient == *rCandidate.mpFillFloatTransGradient))))
+                {
+                    delete mpFillFloatTransGradient;
+                    mpFillFloatTransGradient = 0L;
+                }
+
+                // copy mpFillFloatTransGradient if necessary
+                if(!mpFillFloatTransGradient && rCandidate.mpFillFloatTransGradient)
+                {
+                    mpFillFloatTransGradient = new fillGradientAttribute(*rCandidate.mpFillFloatTransGradient);
+                }
+            }
+
+            return *this;
+        }
+
+        bool sdrLineFillShadowAttribute::operator==(const sdrLineFillShadowAttribute& rCandidate) const
+        {
+            // handle mpShadow
+            if(!pointerOrContentEqual(mpShadow, rCandidate.mpShadow))
+                return false;
+
+            // handle mpLine
+            if(!pointerOrContentEqual(mpLine, rCandidate.mpLine))
+                return false;
+
+            // handle mpLineStartEnd
+            if(!pointerOrContentEqual(mpLineStartEnd, rCandidate.mpLineStartEnd))
+                return false;
+
+            // handle mpFill
+            if(!pointerOrContentEqual(mpFill, rCandidate.mpFill))
+                return false;
+
+            // handle mpFillFloatTransGradient
+            if(!pointerOrContentEqual(mpFillFloatTransGradient, rCandidate.mpFillFloatTransGradient))
+                return false;
+
+            return true;
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/attribute/sdrattribute.cxx b/drawinglayer/source/attribute/sdrattribute.cxx
new file mode 100644
index 000000000000..6c4a8ff84501
--- /dev/null
+++ b/drawinglayer/source/attribute/sdrattribute.cxx
@@ -0,0 +1,285 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrattribute.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:34 $
+ *
+ *  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
+#include <drawinglayer/attribute/sdrattribute.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLATTRIBUTE_HXX
+#include <drawinglayer/attribute/fillattribute.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRFILLBITMAPATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrLineAttribute::sdrLineAttribute(
+            basegfx::tools::B2DLineJoin eJoin, double fWidth, double fTransparence, const basegfx::BColor& rColor,
+            const ::std::vector< double >& rDotDashArray, double fFullDotDashLen)
+        :   meJoin(eJoin),
+            mfWidth(fWidth),
+            mfTransparence(fTransparence),
+            maColor(rColor),
+            maDotDashArray(rDotDashArray),
+            mfFullDotDashLen(fFullDotDashLen)
+        {
+        }
+
+        sdrLineAttribute::~sdrLineAttribute()
+        {
+        }
+
+        bool sdrLineAttribute::operator==(const sdrLineAttribute& rCandidate) const
+        {
+            return (meJoin == rCandidate.meJoin
+                && mfWidth == rCandidate.mfWidth
+                && mfTransparence == rCandidate.mfTransparence
+                && maColor == rCandidate.maColor
+                && maDotDashArray == rCandidate.maDotDashArray);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrLineStartEndAttribute::sdrLineStartEndAttribute(
+            const basegfx::B2DPolyPolygon& rStartPolyPolygon, const basegfx::B2DPolyPolygon& rEndPolyPolygon,
+            double fStartWidth, double fEndWidth, bool bStartActive, bool bEndActive, bool bStartCentered, bool bEndCentered)
+        :   maStartPolyPolygon(rStartPolyPolygon),
+            maEndPolyPolygon(rEndPolyPolygon),
+            mfStartWidth(fStartWidth),
+            mfEndWidth(fEndWidth),
+            mbStartActive(bStartActive),
+            mbEndActive(bEndActive),
+            mbStartCentered(bStartCentered),
+            mbEndCentered(bEndCentered)
+        {
+        }
+
+        sdrLineStartEndAttribute::~sdrLineStartEndAttribute()
+        {
+        }
+
+        bool sdrLineStartEndAttribute::operator==(const sdrLineStartEndAttribute& rCandidate) const
+        {
+            return (mbStartActive == rCandidate.mbStartActive
+                && mbEndActive == rCandidate.mbEndActive
+                && mbStartCentered == rCandidate.mbStartCentered
+                && mbEndCentered == rCandidate.mbEndCentered
+                && mfStartWidth == rCandidate.mfStartWidth
+                && mfEndWidth == rCandidate.mfEndWidth
+                && maStartPolyPolygon == rCandidate.maStartPolyPolygon
+                && maEndPolyPolygon == rCandidate.maEndPolyPolygon);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrShadowAttribute::sdrShadowAttribute(const basegfx::B2DVector& rOffset, double fTransparence, const basegfx::BColor& rColor)
+        :   maOffset(rOffset),
+            mfTransparence(fTransparence),
+            maColor(rColor)
+        {
+        }
+
+        sdrShadowAttribute::~sdrShadowAttribute()
+        {
+        }
+
+        bool sdrShadowAttribute::operator==(const sdrShadowAttribute& rCandidate) const
+        {
+            return (mfTransparence == rCandidate.mfTransparence
+                && maColor == rCandidate.maColor
+                && maOffset == rCandidate.maOffset);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrFillAttribute::sdrFillAttribute(
+            double fTransparence, const basegfx::BColor& rColor, fillGradientAttribute* pGradient,
+            fillHatchAttribute* pHatch, sdrFillBitmapAttribute* pBitmap)
+        :   mfTransparence(fTransparence),
+            maColor(rColor),
+            mpGradient(pGradient),
+            mpHatch(pHatch),
+            mpBitmap(pBitmap)
+        {
+        }
+
+        sdrFillAttribute::sdrFillAttribute(const sdrFillAttribute& rCandidate)
+        :   mfTransparence(1.0),
+            mpGradient(0L),
+            mpHatch(0L),
+            mpBitmap(0L)
+        {
+            if(!(*this == rCandidate))
+            {
+                *this = rCandidate;
+            }
+        }
+
+        sdrFillAttribute::~sdrFillAttribute()
+        {
+            delete mpGradient;
+            delete mpHatch;
+            delete mpBitmap;
+        }
+
+        sdrFillAttribute& sdrFillAttribute::operator=(const sdrFillAttribute& rCandidate)
+        {
+            // copy data
+            mfTransparence = rCandidate.mfTransparence;
+            maColor = rCandidate.maColor;
+
+            // handle mpGradient
+            {
+                // delete local mpGradient if necessary
+                if(mpGradient && ((!rCandidate.mpGradient) || (!(*mpGradient == *rCandidate.mpGradient))))
+                {
+                    delete mpGradient;
+                    mpGradient = 0L;
+                }
+
+                // copy mpGradient if necessary
+                if(!mpGradient && rCandidate.mpGradient)
+                {
+                    mpGradient = new fillGradientAttribute(*rCandidate.mpGradient);
+                }
+            }
+
+            // handle mpHatch
+            {
+                // delete local mpHatch if necessary
+                if(mpHatch && ((!rCandidate.mpHatch) || (!(*mpHatch == *rCandidate.mpHatch))))
+                {
+                    delete mpHatch;
+                    mpHatch = 0L;
+                }
+
+                // copy mpHatch if necessary
+                if(!mpHatch && rCandidate.mpHatch)
+                {
+                    mpHatch = new fillHatchAttribute(*rCandidate.mpHatch);
+                }
+            }
+
+            // handle mpBitmap
+            {
+                // delete local mpBitmap if necessary
+                if(mpBitmap && ((!rCandidate.mpBitmap) || (!(*mpBitmap == *rCandidate.mpBitmap))))
+                {
+                    delete mpBitmap;
+                    mpBitmap = 0L;
+                }
+
+                // copy mpBitmap if necessary
+                if(!mpBitmap && rCandidate.mpBitmap)
+                {
+                    mpBitmap = new sdrFillBitmapAttribute(*rCandidate.mpBitmap);
+                }
+            }
+
+            return *this;
+        }
+
+        bool sdrFillAttribute::operator==(const sdrFillAttribute& rCandidate) const
+        {
+            if(mfTransparence != rCandidate.mfTransparence)
+                return false;
+
+            if(mpGradient)
+            {
+                if(!rCandidate.mpGradient)
+                    return false;
+
+                if(!(*mpGradient == *rCandidate.mpGradient))
+                    return false;
+            }
+            else if(mpHatch)
+            {
+                if(!rCandidate.mpHatch)
+                    return false;
+
+                if(!(*mpHatch == *rCandidate.mpHatch))
+                    return false;
+
+                if(mpHatch->isFillBackground() && !(maColor == rCandidate.maColor))
+                    return false;
+            }
+            else if(mpBitmap)
+            {
+                if(!rCandidate.mpBitmap)
+                    return false;
+
+                if(!(*mpBitmap == *rCandidate.mpBitmap))
+                    return false;
+            }
+            else
+            {
+                if(!rCandidate.isColor())
+                    return false;
+
+                if(!(maColor == rCandidate.maColor))
+                    return false;
+            }
+
+            return true;
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/attribute/sdrattribute3d.cxx b/drawinglayer/source/attribute/sdrattribute3d.cxx
new file mode 100644
index 000000000000..ccbe27181256
--- /dev/null
+++ b/drawinglayer/source/attribute/sdrattribute3d.cxx
@@ -0,0 +1,231 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrattribute3d.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:34 $
+ *
+ *  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
+#include <drawinglayer/attribute/sdrattribute3d.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdr3DObjectAttribute::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)
+        :   maNormalsKind(aNormalsKind),
+            maTextureProjectionX(aTextureProjectionX),
+            maTextureProjectionY(aTextureProjectionY),
+            maTextureKind(aTextureKind),
+            maTextureMode(aTextureMode),
+            maMaterial(rMaterial),
+            mbNormalsInvert(bNormalsInvert),
+            mbDoubleSided(bDoubleSided),
+            mbShadow3D(bShadow3D),
+            mbTextureFilter(bTextureFilter)
+        {
+        }
+
+        sdr3DObjectAttribute::~sdr3DObjectAttribute()
+        {
+        }
+
+        bool sdr3DObjectAttribute::operator==(const sdr3DObjectAttribute& rCandidate) const
+        {
+            return (maNormalsKind == rCandidate.maNormalsKind
+            && maTextureProjectionX == rCandidate.maTextureProjectionX
+            && maTextureProjectionY == rCandidate.maTextureProjectionY
+            && maTextureKind == rCandidate.maTextureKind
+            && maTextureMode == rCandidate.maTextureMode
+            && maMaterial == rCandidate.maMaterial
+            && mbNormalsInvert == rCandidate.mbNormalsInvert
+            && mbDoubleSided == rCandidate.mbDoubleSided
+            && mbShadow3D == rCandidate.mbShadow3D
+            && mbTextureFilter == rCandidate.mbTextureFilter);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdr3DLightAttribute::sdr3DLightAttribute(const basegfx::BColor& rColor, const basegfx::B3DVector& rDirection, bool bSpecular)
+        :   maColor(rColor),
+            maDirection(rDirection),
+            mbSpecular(bSpecular)
+        {
+        }
+
+        sdr3DLightAttribute::~sdr3DLightAttribute()
+        {
+        }
+
+        bool sdr3DLightAttribute::operator==(const sdr3DLightAttribute& rCandidate) const
+        {
+            return (maColor == rCandidate.maColor
+                && maDirection == rCandidate.maDirection
+                && mbSpecular == rCandidate.mbSpecular);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrLightingAttribute::sdrLightingAttribute(
+            const basegfx::BColor& rAmbientLight,
+            const ::std::vector< sdr3DLightAttribute >& rLightVector)
+        :   maAmbientLight(rAmbientLight),
+            maLightVector(rLightVector)
+        {
+        }
+
+        sdrLightingAttribute::~sdrLightingAttribute()
+        {
+        }
+
+        bool sdrLightingAttribute::operator==(const sdrLightingAttribute& rCandidate) const
+        {
+            return (maAmbientLight == rCandidate.maAmbientLight
+                && maLightVector == rCandidate.maLightVector);
+        }
+
+        // color model solver
+        basegfx::BColor sdrLightingAttribute::solveColorModel(
+            const basegfx::B3DVector& rNormalInEyeCoordinates,
+            const basegfx::BColor& rColor, const basegfx::BColor& rSpecular,
+            const basegfx::BColor& rEmission, sal_uInt16 nSpecularIntensity) const
+        {
+            // initialize with emissive color
+            basegfx::BColor aRetval(rEmission);
+
+            // take care of global ambient light
+            aRetval += getAmbientLight() * rColor;
+
+            // prepare light access. Is there a light?
+            const sal_uInt32 nLightCount(maLightVector.size());
+
+            if(nLightCount && !rNormalInEyeCoordinates.equalZero())
+            {
+                // prepare normal
+                basegfx::B3DVector aEyeNormal(rNormalInEyeCoordinates);
+                aEyeNormal.normalize();
+
+                for(sal_uInt32 a(0L); a < nLightCount; a++)
+                {
+                    const sdr3DLightAttribute& rLight(maLightVector[a]);
+                    const double fCosFac(rLight.getDirection().scalar(aEyeNormal));
+
+                    if(basegfx::fTools::more(fCosFac, 0.0))
+                    {
+                        aRetval += ((rLight.getColor() * rColor) * fCosFac);
+
+                        if(rLight.getSpecular())
+                        {
+                            // expand by (0.0, 0.0, 1.0) in Z
+                            basegfx::B3DVector aSpecularNormal(rLight.getDirection().getX(), rLight.getDirection().getY(), rLight.getDirection().getZ() + 1.0);
+                            aSpecularNormal.normalize();
+                            double fCosFac2(aSpecularNormal.scalar(aEyeNormal));
+
+                            if(basegfx::fTools::more(fCosFac2, 0.0))
+                            {
+                                fCosFac2 = pow(fCosFac2, (double)nSpecularIntensity);
+                                aRetval += (rSpecular * fCosFac2);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // clamp to color space before usage
+            aRetval.clamp();
+
+            return aRetval;
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrSceneAttribute::sdrSceneAttribute(
+            double fDistance,
+            double fShadowSlant,
+            ::com::sun::star::drawing::ProjectionMode aProjectionMode,
+            ::com::sun::star::drawing::ShadeMode aShadeMode,
+            bool bTwoSidedLighting)
+        :   mfDistance(fDistance),
+            mfShadowSlant(fShadowSlant),
+            maProjectionMode(aProjectionMode),
+            maShadeMode(aShadeMode),
+            mbTwoSidedLighting(bTwoSidedLighting)
+        {
+        }
+
+        sdrSceneAttribute::~sdrSceneAttribute()
+        {
+        }
+
+        bool sdrSceneAttribute::operator==(const sdrSceneAttribute& rCandidate) const
+        {
+            return (mfDistance == rCandidate.mfDistance
+                && mfShadowSlant == rCandidate.mfShadowSlant
+                && maProjectionMode == rCandidate.maProjectionMode
+                && maShadeMode == rCandidate.maShadeMode
+                && mbTwoSidedLighting == rCandidate.mbTwoSidedLighting);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/attribute/sdrfillbitmapattribute.cxx b/drawinglayer/source/attribute/sdrfillbitmapattribute.cxx
new file mode 100644
index 000000000000..4f7e8b5947a2
--- /dev/null
+++ b/drawinglayer/source/attribute/sdrfillbitmapattribute.cxx
@@ -0,0 +1,245 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: sdrfillbitmapattribute.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:47:34 $
+ *
+ *  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
+#include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
+#endif
+
+#ifndef _DRAWINGLAYER_ATTRIBUTE_FILLBITMAPATTRIBUTE_HXX
+#include <drawinglayer/attribute/fillbitmapattribute.hxx>
+#endif
+
+#ifndef _BGFX_NUMERIC_FTOOLS_HXX
+#include <basegfx/numeric/ftools.hxx>
+#endif
+
+#ifndef _BGFX_RANGE_B2DRANGE_HXX
+#include <basegfx/range/b2drange.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace attribute
+    {
+        sdrFillBitmapAttribute::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)
+        :   maBitmap(rBitmap),
+            maSize(rSize),
+            maOffset(rOffset),
+            maOffsetPosition(rOffsetPosition),
+            maRectPoint(rRectPoint),
+            mbTiling(bTiling),
+            mbStretch(bStretch),
+            mbLogSize(bLogSize)
+        {
+        }
+
+        bool sdrFillBitmapAttribute::operator==(const sdrFillBitmapAttribute& rCandidate) const
+        {
+            return (maBitmap == rCandidate.maBitmap
+                && maSize == rCandidate.maSize
+                && maOffset == rCandidate.maOffset
+                && maOffsetPosition == rCandidate.maOffsetPosition
+                && maRectPoint == rCandidate.maRectPoint
+                && mbTiling == rCandidate.mbTiling
+                && mbStretch == rCandidate.mbStretch
+                && mbLogSize == rCandidate.mbLogSize);
+        }
+
+        fillBitmapAttribute sdrFillBitmapAttribute::getFillBitmapAttribute(const basegfx::B2DRange& rRange) const
+        {
+            // get logical size of bitmap (before expanding eventually)
+            Bitmap aBitmap(maBitmap);
+            const basegfx::B2DVector aLogicalSize(aBitmap.GetPrefSize().getWidth(), aBitmap.GetPrefSize().getHeight());
+
+            // get hor/ver shiftings and apply them eventually to the bitmap, but only
+            // when tiling is on
+            bool bExpandWidth(false);
+            bool bExpandHeight(false);
+
+            if(mbTiling)
+            {
+                if(0.0 != maOffset.getX() || 0.0 != maOffset.getY())
+                {
+                    const sal_uInt32 nWidth(aBitmap.GetSizePixel().getWidth());
+                    const sal_uInt32 nHeight(aBitmap.GetSizePixel().getHeight());
+
+                    if(0.0 != maOffset.getX())
+                    {
+                        bExpandHeight = true;
+                        const sal_uInt32 nOffset(basegfx::fround(((double)nWidth * maOffset.getX()) / 100.0));
+                        aBitmap.Expand(0L, nHeight);
+
+                        const Size aSizeA(nOffset, nHeight);
+                        const Rectangle aDstA(Point(0L, nHeight), aSizeA);
+                        const Rectangle aSrcA(Point(nWidth - nOffset, 0L), aSizeA);
+                        aBitmap.CopyPixel(aDstA, aSrcA);
+
+                        const Size aSizeB(nWidth - nOffset, nHeight);
+                        const Rectangle aDstB(Point(nOffset, nHeight), aSizeB);
+                        const Rectangle aSrcB(Point(0L, 0L), aSizeB);
+                        aBitmap.CopyPixel(aDstB, aSrcB);
+                    }
+                    else
+                    {
+                        bExpandWidth = true;
+                        const sal_uInt32 nOffset(basegfx::fround(((double)nHeight * maOffset.getY()) / 100.0));
+                        aBitmap.Expand(nWidth, 0L);
+
+                        const Size aSize(nWidth, nHeight);
+                        const Rectangle aDst(Point(nWidth, 0L), aSize);
+                        const Rectangle aSrc(Point(0L, 0L), aSize);
+                        aBitmap.CopyPixel(aDst, aSrc);
+
+                        const Size aSizeA(nWidth, nOffset);
+                        const Rectangle aDstA(Point(0L, 0L), aSizeA);
+                        const Rectangle aSrcA(Point(nWidth, nHeight - nOffset), aSizeA);
+                        aBitmap.CopyPixel(aDstA, aSrcA);
+
+                        const Size aSizeB(nWidth, nHeight - nOffset);
+                        const Rectangle aDstB(Point(0L, nOffset), aSizeB);
+                        const Rectangle aSrcB(Point(nWidth, 0L), aSizeB);
+                        aBitmap.CopyPixel(aDstB, aSrcB);
+                    }
+                }
+            }
+
+            // init values with defaults
+            basegfx::B2DPoint aBitmapSize(1.0, 1.0);
+            basegfx::B2DVector aBitmapTopLeft(0.0, 0.0);
+
+            // are canges needed?
+            if(mbTiling || !mbStretch)
+            {
+                // init values with range sizes
+                const double fRangeWidth(0.0 != rRange.getWidth() ? rRange.getWidth() : 1.0);
+                const double fRangeHeight(0.0 != rRange.getHeight() ? rRange.getHeight() : 1.0);
+                aBitmapSize = basegfx::B2DPoint(fRangeWidth, fRangeHeight);
+
+                // size changes
+                if(0.0 != maSize.getX())
+                {
+                    if(maSize.getX() < 0.0)
+                    {
+                        aBitmapSize.setX(aBitmapSize.getX() * (maSize.getX() * -0.01));
+                    }
+                    else
+                    {
+                        aBitmapSize.setX(maSize.getX());
+                    }
+                }
+                else
+                {
+                    aBitmapSize.setX(aLogicalSize.getX());
+                }
+
+                if(0.0 != maSize.getY())
+                {
+                    if(maSize.getY() < 0.0)
+                    {
+                        aBitmapSize.setY(aBitmapSize.getY() * (maSize.getY() * -0.01));
+                    }
+                    else
+                    {
+                        aBitmapSize.setY(maSize.getY());
+                    }
+                }
+                else
+                {
+                    aBitmapSize.setY(aLogicalSize.getY());
+                }
+
+                // get values, force to centered if necessary
+                const basegfx::B2DVector aRectPoint(mbTiling ? maRectPoint : basegfx::B2DVector(0.0, 0.0));
+
+                // position changes X
+                if(0.0 == aRectPoint.getX())
+                {
+                    aBitmapTopLeft.setX((fRangeWidth - aBitmapSize.getX()) * 0.5);
+                }
+                else if(1.0 == aRectPoint.getX())
+                {
+                    aBitmapTopLeft.setX(fRangeWidth - aBitmapSize.getX());
+                }
+
+                if(mbTiling && 0.0 != maOffsetPosition.getX())
+                {
+                    aBitmapTopLeft.setX(aBitmapTopLeft.getX() + (aBitmapSize.getX() * (maOffsetPosition.getX() * 0.01)));
+                }
+
+                // position changes Y
+                if(0.0 == aRectPoint.getY())
+                {
+                    aBitmapTopLeft.setY((fRangeHeight - aBitmapSize.getY()) * 0.5);
+                }
+                else if(1.0 == aRectPoint.getY())
+                {
+                    aBitmapTopLeft.setY(fRangeHeight - aBitmapSize.getY());
+                }
+
+                if(mbTiling && 0.0 != maOffsetPosition.getY())
+                {
+                    aBitmapTopLeft.setY(aBitmapTopLeft.getY() + (aBitmapSize.getY() * (maOffsetPosition.getY() * 0.01)));
+                }
+
+                // apply expand
+                if(bExpandWidth)
+                {
+                    aBitmapSize.setX(aBitmapSize.getX() * 2.0);
+                }
+
+                if(bExpandHeight)
+                {
+                    aBitmapSize.setY(aBitmapSize.getY() * 2.0);
+                }
+
+                // apply bitmap size scaling to unit rectangle
+                aBitmapTopLeft.setX(aBitmapTopLeft.getX() / fRangeWidth);
+                aBitmapTopLeft.setY(aBitmapTopLeft.getY() / fRangeHeight);
+                aBitmapSize.setX(aBitmapSize.getX() / fRangeWidth);
+                aBitmapSize.setY(aBitmapSize.getY() / fRangeHeight);
+            }
+
+            return fillBitmapAttribute(aBitmap, aBitmapTopLeft, aBitmapSize, mbTiling);
+        }
+    } // end of namespace attribute
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx b/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx
index 14e1f53cc5bc..1ab1baa2827d 100644
--- a/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: hatchtextureprimitive3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:14 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -73,14 +73,14 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void hatchTexturePrimitive3D::impCreateDecomposition(const primitiveVector& rSource, primitiveVector& rDest)
+        void hatchTexturePrimitive3D::impCreateDecomposition(const primitiveVector3D& rSource, primitiveVector3D& rDest)
         {
             for(sal_uInt32 a(0L); a < rSource.size(); a++)
             {
                 // get reference
-                const referencedPrimitive& rCandidate = rSource[a];
+                const referencedPrimitive3D& rCandidate = rSource[a];
 
                 // not all content is needed, remove transparencies and ModifiedColorPrimitives
                 switch(rCandidate.getID())
@@ -89,28 +89,28 @@ namespace drawinglayer
                     {
                         // polyPolygonMaterialPrimitive3D, check texturing and hatching
                         const polyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const polyPolygonMaterialPrimitive3D& >(rCandidate.getBasePrimitive());
-                        const ::basegfx::B3DPolyPolygon aFillPolyPolygon(rPrimitive.getB3DPolyPolygon());
+                        const basegfx::B3DPolyPolygon aFillPolyPolygon(rPrimitive.getB3DPolyPolygon());
 
                         if(aFillPolyPolygon.areTextureCoordinatesUsed())
                         {
                             const sal_uInt32 nPolyCount(aFillPolyPolygon.count());
-                            ::basegfx::B2DPolyPolygon aTexPolyPolygon;
-                            ::basegfx::B2DPoint a2N;
-                            ::basegfx::B2DVector a2X, a2Y;
-                            ::basegfx::B3DPoint a3N;
-                            ::basegfx::B3DVector a3X, a3Y;
+                            basegfx::B2DPolyPolygon aTexPolyPolygon;
+                            basegfx::B2DPoint a2N;
+                            basegfx::B2DVector a2X, a2Y;
+                            basegfx::B3DPoint a3N;
+                            basegfx::B3DVector a3X, a3Y;
                             bool b2N(false), b2X(false), b2Y(false);
                             sal_uInt32 a, b;
 
                             for(a = 0L; a < nPolyCount; a++)
                             {
-                                const ::basegfx::B3DPolygon aPartPoly(aFillPolyPolygon.getB3DPolygon(a));
+                                const basegfx::B3DPolygon aPartPoly(aFillPolyPolygon.getB3DPolygon(a));
                                 const sal_uInt32 nPointCount(aPartPoly.count());
-                                ::basegfx::B2DPolygon aTexPolygon;
+                                basegfx::B2DPolygon aTexPolygon;
 
                                 for(b = 0L; b < nPointCount; b++)
                                 {
-                                    const ::basegfx::B2DPoint a2Candidate(aPartPoly.getTextureCoordinate(b));
+                                    const basegfx::B2DPoint a2Candidate(aPartPoly.getTextureCoordinate(b));
 
                                     if(!b2N)
                                     {
@@ -130,7 +130,7 @@ namespace drawinglayer
 
                                         const double fCross(a2X.cross(a2Y));
 
-                                        if(!::basegfx::fTools::equalZero(fCross))
+                                        if(!basegfx::fTools::equalZero(fCross))
                                         {
                                             a3Y = aPartPoly.getB3DPoint(b) - a3N;
                                             b2Y = true;
@@ -148,44 +148,44 @@ namespace drawinglayer
                             {
                                 // found two linearly independent 2D vectors
                                 // get 2d range of texture coordinates
-                                const ::basegfx::B2DRange aOutlineRange(::basegfx::tools::getRange(aTexPolyPolygon));
-                                const ::basegfx::BColor aHatchColor(maHatch.getColor());
+                                const basegfx::B2DRange aOutlineRange(basegfx::tools::getRange(aTexPolyPolygon));
+                                const basegfx::BColor aHatchColor(maHatch.getColor());
                                 const double fAngle(-maHatch.getAngle());
-                                ::std::vector< ::basegfx::B2DHomMatrix > aMatrices;
+                                ::std::vector< basegfx::B2DHomMatrix > aMatrices;
 
                                 // get hatch transformations
                                 switch(maHatch.getStyle())
                                 {
-                                    case HATCHSTYLE_TRIPLE:
+                                    case attribute::HATCHSTYLE_TRIPLE:
                                     {
                                         // rotated 45 degrees
-                                        geoTexSvxHatch aHatch(aOutlineRange, maHatch.getDistance(), fAngle + F_PI4);
+                                        texture::geoTexSvxHatch aHatch(aOutlineRange, maHatch.getDistance(), fAngle + F_PI4);
                                         aHatch.appendTransformations(aMatrices);
                                     }
-                                    case HATCHSTYLE_DOUBLE:
+                                    case attribute::HATCHSTYLE_DOUBLE:
                                     {
                                         // rotated 90 degrees
-                                        geoTexSvxHatch aHatch(aOutlineRange, maHatch.getDistance(), fAngle + F_PI2);
+                                        texture::geoTexSvxHatch aHatch(aOutlineRange, maHatch.getDistance(), fAngle + F_PI2);
                                         aHatch.appendTransformations(aMatrices);
                                     }
-                                    case HATCHSTYLE_SINGLE:
+                                    case attribute::HATCHSTYLE_SINGLE:
                                     {
                                         // angle as given
-                                        geoTexSvxHatch aHatch(aOutlineRange, maHatch.getDistance(), fAngle);
+                                        texture::geoTexSvxHatch aHatch(aOutlineRange, maHatch.getDistance(), fAngle);
                                         aHatch.appendTransformations(aMatrices);
                                     }
                                 }
 
                                 // create geometry from unit line
-                                ::basegfx::B2DPolyPolygon a2DHatchLines;
-                                ::basegfx::B2DPolygon a2DUnitLine;
-                                a2DUnitLine.append(::basegfx::B2DPoint(0.0, 0.0));
-                                a2DUnitLine.append(::basegfx::B2DPoint(1.0, 0.0));
+                                basegfx::B2DPolyPolygon a2DHatchLines;
+                                basegfx::B2DPolygon a2DUnitLine;
+                                a2DUnitLine.append(basegfx::B2DPoint(0.0, 0.0));
+                                a2DUnitLine.append(basegfx::B2DPoint(1.0, 0.0));
 
                                 for(a = 0L; a < aMatrices.size(); a++)
                                 {
-                                    const ::basegfx::B2DHomMatrix& rMatrix = aMatrices[a];
-                                    ::basegfx::B2DPolygon aNewLine(a2DUnitLine);
+                                    const basegfx::B2DHomMatrix& rMatrix = aMatrices[a];
+                                    basegfx::B2DPolygon aNewLine(a2DUnitLine);
                                     aNewLine.transform(rMatrix);
                                     a2DHatchLines.append(aNewLine);
                                 }
@@ -193,14 +193,14 @@ namespace drawinglayer
                                 if(a2DHatchLines.count())
                                 {
                                     // clip against texture polygon
-                                    a2DHatchLines = ::basegfx::tools::clipPolyPolygonOnPolyPolygon(a2DHatchLines, aTexPolyPolygon, true, false);
+                                    a2DHatchLines = basegfx::tools::clipPolyPolygonOnPolyPolygon(a2DHatchLines, aTexPolyPolygon, true, false);
                                 }
 
                                 if(a2DHatchLines.count())
                                 {
                                     // create 2d matrix with 2d vectors as column vectors and 2d point as offset, this represents
                                     // a coordinate system transformation from unit coordinates to the new coordinate system
-                                    ::basegfx::B2DHomMatrix a2D;
+                                    basegfx::B2DHomMatrix a2D;
                                     a2D.set(0, 0, a2X.getX());
                                     a2D.set(1, 0, a2X.getY());
                                     a2D.set(0, 1, a2Y.getX());
@@ -214,11 +214,11 @@ namespace drawinglayer
                                     a2DHatchLines.transform(a2D);
 
                                     // expand back-transformated geometry tpo 3D
-                                    ::basegfx::B3DPolyPolygon a3DHatchLines(::basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(a2DHatchLines, 0.0));
+                                    basegfx::B3DPolyPolygon a3DHatchLines(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(a2DHatchLines, 0.0));
 
                                     // create 3d matrix with 3d vectors as column vectors (0,0,1 as Z) and 3d point as offset, this represents
                                     // a coordinate system transformation from unit coordinates to the object's 3d coordinate system
-                                    ::basegfx::B3DHomMatrix a3D;
+                                    basegfx::B3DHomMatrix a3D;
                                     a3D.set(0, 0, a3X.getX());
                                     a3D.set(1, 0, a3X.getY());
                                     a3D.set(2, 0, a3X.getZ());
@@ -237,8 +237,8 @@ namespace drawinglayer
 
                                     for(a = 0L; a < nHatchLines; a++)
                                     {
-                                        basePrimitive* pNew = new polygonHairlinePrimitive3D(a3DHatchLines.getB3DPolygon(a), aHatchColor);
-                                        rDest.push_back(referencedPrimitive(*pNew));
+                                        basePrimitive3D* pNew = new polygonHairlinePrimitive3D(a3DHatchLines.getB3DPolygon(a), aHatchColor);
+                                        rDest.push_back(referencedPrimitive3D(*pNew));
                                     }
                                 }
                             }
@@ -263,21 +263,21 @@ namespace drawinglayer
             }
         }
 
-        void hatchTexturePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void hatchTexturePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             if(maPrimitiveVector.size())
             {
                 // create decomposition
-                primitiveVector aNewPrimitiveVector;
+                primitiveVector3D aNewPrimitiveVector;
                 impCreateDecomposition(maPrimitiveVector, aNewPrimitiveVector);
                 rTarget.insert(rTarget.end(), aNewPrimitiveVector.begin(), aNewPrimitiveVector.end());
             }
         }
 
         hatchTexturePrimitive3D::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)
         :   texturePrimitive3D(rPrimitiveVector, rTextureSize, bModulate, bFilter),
@@ -289,7 +289,7 @@ namespace drawinglayer
         {
         }
 
-        bool hatchTexturePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool hatchTexturePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(texturePrimitive3D::operator==(rPrimitive))
             {
@@ -304,7 +304,7 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('H', 'A', 'X', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/makefile.mk b/drawinglayer/source/primitive3d/makefile.mk
index 0be6d6307dcd..dcb84b36d464 100644
--- a/drawinglayer/source/primitive3d/makefile.mk
+++ b/drawinglayer/source/primitive3d/makefile.mk
@@ -4,9 +4,9 @@
 #
 #   $RCSfile: makefile.mk,v $
 #
-#   $Revision: 1.2 $
+#   $Revision: 1.3 $
 #
-#   last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+#   last change: $Author: aw $ $Date: 2006-08-09 16:51:14 $
 #
 #   The Contents of this file are made available subject to
 #   the terms of GNU Lesser General Public License Version 2.1.
@@ -44,24 +44,25 @@ TARGET=primitive3d
 # --- Files -------------------------------------
 
 SLOFILES= \
-        $(SLO)$/materialattribute3d.obj		\
-        $(SLO)$/sdrallattribute3d.obj		\
-        $(SLO)$/sdrattribute3d.obj			\
-        $(SLO)$/shadowprimitive3d.obj		\
-        $(SLO)$/textureprimitive3d.obj		\
-        $(SLO)$/hatchtextureprimitive3d.obj	\
-        $(SLO)$/polygontubeprimitive3d.obj	\
-        $(SLO)$/polygonprimitive3d.obj		\
-        $(SLO)$/polypolygonprimitive3d.obj	\
-        $(SLO)$/transformprimitive3d.obj	\
-        $(SLO)$/sdrdecompositiontools3d.obj	\
-        $(SLO)$/sdrextrudelathetools3d.obj	\
-        $(SLO)$/sdrprimitive3d.obj			\
-        $(SLO)$/sdrcubeprimitive3d.obj		\
-        $(SLO)$/sdrextrudeprimitive3d.obj	\
-        $(SLO)$/sdrsphereprimitive3d.obj	\
-        $(SLO)$/sdrlatheprimitive3d.obj		\
-        $(SLO)$/sdrpolygonprimitive3d.obj
+        $(SLO)$/primitive3d.obj					\
+        $(SLO)$/vectorprimitive3d.obj			\
+        $(SLO)$/shadowprimitive3d.obj			\
+        $(SLO)$/textureprimitive3d.obj			\
+        $(SLO)$/hatchtextureprimitive3d.obj		\
+        $(SLO)$/polygontubeprimitive3d.obj		\
+        $(SLO)$/polygonprimitive3d.obj			\
+        $(SLO)$/polypolygonprimitive3d.obj		\
+        $(SLO)$/transformprimitive3d.obj		\
+        $(SLO)$/sdrdecompositiontools3d.obj		\
+        $(SLO)$/sdrextrudelathetools3d.obj		\
+        $(SLO)$/sdrprimitive3d.obj				\
+        $(SLO)$/sdrlabelprimitive3d.obj			\
+        $(SLO)$/sdrcubeprimitive3d.obj			\
+        $(SLO)$/sdrextrudeprimitive3d.obj		\
+        $(SLO)$/sdrsphereprimitive3d.obj		\
+        $(SLO)$/sdrlatheprimitive3d.obj			\
+        $(SLO)$/sdrpolygonprimitive3d.obj		\
+        $(SLO)$/modifiedcolorprimitive3d.obj
 
 # --- Targets ----------------------------------
 
diff --git a/drawinglayer/source/primitive3d/modifiedcolorprimitive3d.cxx b/drawinglayer/source/primitive3d/modifiedcolorprimitive3d.cxx
new file mode 100644
index 000000000000..0d5d911919d3
--- /dev/null
+++ b/drawinglayer/source/primitive3d/modifiedcolorprimitive3d.cxx
@@ -0,0 +1,77 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: modifiedcolorprimitive3d.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
+ *
+ *  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
+#include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace primitive3d
+    {
+        modifiedColorPrimitive3D::modifiedColorPrimitive3D(
+            const primitiveVector3D& rPrimitiveVector,
+            const basegfx::BColorModifier& rColorModifier)
+        :   vectorPrimitive3D(rPrimitiveVector),
+            maColorModifier(rColorModifier)
+        {
+        }
+
+        modifiedColorPrimitive3D::~modifiedColorPrimitive3D()
+        {
+        }
+
+        bool modifiedColorPrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
+        {
+            if(vectorPrimitive3D::operator==(rPrimitive))
+            {
+                const modifiedColorPrimitive3D& rCompare = (modifiedColorPrimitive3D&)rPrimitive;
+                return (maColorModifier == rCompare.maColorModifier);
+            }
+
+            return false;
+        }
+
+        PrimitiveID modifiedColorPrimitive3D::getID() const
+        {
+            return CreatePrimitiveID('M', 'C', 'L', '3');
+        }
+    } // end of namespace primitive3d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/primitive3d/polygonprimitive3d.cxx b/drawinglayer/source/primitive3d/polygonprimitive3d.cxx
index cf5db747ad27..435ccca60716 100644
--- a/drawinglayer/source/primitive3d/polygonprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/polygonprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: polygonprimitive3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -53,10 +53,11 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        polygonHairlinePrimitive3D::polygonHairlinePrimitive3D(const ::basegfx::B3DPolygon& rPolygon, const ::basegfx::BColor& rBColor)
-        :   maPolygon(rPolygon),
+        polygonHairlinePrimitive3D::polygonHairlinePrimitive3D(const basegfx::B3DPolygon& rPolygon, const basegfx::BColor& rBColor)
+        :   basePrimitive3D(),
+            maPolygon(rPolygon),
             maBColor(rBColor)
         {
         }
@@ -65,7 +66,7 @@ namespace drawinglayer
         {
         }
 
-        bool polygonHairlinePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool polygonHairlinePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(getID() == rPrimitive.getID())
             {
@@ -83,39 +84,39 @@ namespace drawinglayer
             return CreatePrimitiveID('P', 'O', 'H', '3');
         }
 
-        ::basegfx::B3DRange polygonHairlinePrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange polygonHairlinePrimitive3D::get3DRange() const
         {
-            return ::basegfx::tools::getRange(maPolygon);
+            return basegfx::tools::getRange(maPolygon);
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void polygonStrokePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void polygonStrokePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             if(maPolygon.count())
             {
-                ::basegfx::B3DPolyPolygon aHairLinePolyPolygon(maPolygon);
+                basegfx::B3DPolyPolygon aHairLinePolyPolygon(maPolygon);
 
                 if(0.0 != maStrokeAttribute.getFullDotDashLen())
                 {
                     // apply LineStyle
-                    aHairLinePolyPolygon = ::basegfx::tools::applyLineDashing(aHairLinePolyPolygon, maStrokeAttribute.getDotDashArray(), maStrokeAttribute.getFullDotDashLen());
+                    aHairLinePolyPolygon = basegfx::tools::applyLineDashing(aHairLinePolyPolygon, maStrokeAttribute.getDotDashArray(), maStrokeAttribute.getFullDotDashLen());
 
                     // merge LineStyle polygons to bigger parts
-                    aHairLinePolyPolygon = ::basegfx::tools::mergeDashedLines(aHairLinePolyPolygon);
+                    aHairLinePolyPolygon = basegfx::tools::mergeDashedLines(aHairLinePolyPolygon);
                 }
 
                 if(maStrokeAttribute.getWidth())
                 {
                     // create fat line data
                     const double fRadius(maStrokeAttribute.getWidth() / 2.0);
-                    const ::basegfx::tools::B2DLineJoin aLineJoin(maStrokeAttribute.getLineJoin());
+                    const basegfx::tools::B2DLineJoin aLineJoin(maStrokeAttribute.getLineJoin());
 
                     for(sal_uInt32 a(0L); a < aHairLinePolyPolygon.count(); a++)
                     {
@@ -123,7 +124,7 @@ namespace drawinglayer
                         polygonTubePrimitive3D* pNew = new polygonTubePrimitive3D(aHairLinePolyPolygon.getB3DPolygon(a),
                             maStrokeAttribute.getColor(),
                             fRadius, aLineJoin);
-                        rTarget.push_back(referencedPrimitive(*pNew));
+                        rTarget.push_back(referencedPrimitive3D(*pNew));
                     }
                 }
                 else
@@ -131,16 +132,19 @@ namespace drawinglayer
                     // create hair line data for all sub polygons
                     for(sal_uInt32 a(0L); a < aHairLinePolyPolygon.count(); a++)
                     {
-                        const ::basegfx::B3DPolygon aCandidate = aHairLinePolyPolygon.getB3DPolygon(a);
-                        basePrimitive* pNew = new polygonHairlinePrimitive3D(aCandidate, maStrokeAttribute.getColor());
-                        rTarget.push_back(referencedPrimitive(*pNew));
+                        const basegfx::B3DPolygon aCandidate = aHairLinePolyPolygon.getB3DPolygon(a);
+                        basePrimitive3D* pNew = new polygonHairlinePrimitive3D(aCandidate, maStrokeAttribute.getColor());
+                        rTarget.push_back(referencedPrimitive3D(*pNew));
                     }
                 }
             }
         }
 
-        polygonStrokePrimitive3D::polygonStrokePrimitive3D(const ::basegfx::B3DPolygon& rPolygon, const strokeAttribute& rStrokeAttribute)
-        :   maPolygon(rPolygon),
+        polygonStrokePrimitive3D::polygonStrokePrimitive3D(
+            const basegfx::B3DPolygon& rPolygon,
+            const attribute::strokeAttribute& rStrokeAttribute)
+        :   basePrimitive3D(),
+            maPolygon(rPolygon),
             maStrokeAttribute(rStrokeAttribute)
         {
         }
@@ -149,7 +153,7 @@ namespace drawinglayer
         {
         }
 
-        bool polygonStrokePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool polygonStrokePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(getID() == rPrimitive.getID())
             {
@@ -166,7 +170,7 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('P', 'L', 'S', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx b/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx
index ffb059cde583..6f470c5870b2 100644
--- a/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: polygontubeprimitive3d.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -45,8 +45,8 @@
 #include <basegfx/matrix/b3dhommatrix.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE3D_MATERIALATTRIBUTE3D_HXX
-#include <drawinglayer/primitive3d/materialattribute3d.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_MATERIALATTRIBUTE3D_HXX
+#include <drawinglayer/attribute/materialattribute3d.hxx>
 #endif
 
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_POLYPOLYGONPRIMITIVE_HXX
@@ -69,16 +69,18 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         namespace // anonymous namespace
         {
-            const primitiveVector& getLineTubeSegments(sal_uInt32 nSegments, const materialAttribute3D& rMaterial)
+            const primitiveVector3D& getLineTubeSegments(
+                sal_uInt32 nSegments,
+                const attribute::materialAttribute3D& rMaterial)
             {
                 // static data for buffered tube primitives
-                static primitiveVector aLineTubeList;
+                static primitiveVector3D aLineTubeList;
                 static sal_uInt32 nLineTubeSegments(0L);
-                static materialAttribute3D aLineMaterial;
+                static attribute::materialAttribute3D aLineMaterial;
 
                 // may exclusively change static data, use mutex
                 ::osl::Mutex m_mutex;
@@ -92,36 +94,36 @@ namespace drawinglayer
 
                 if(0L == aLineTubeList.size() && 0L != nLineTubeSegments)
                 {
-                    const ::basegfx::B3DPoint aLeft(0.0, 0.0, 0.0);
-                    const ::basegfx::B3DPoint aRight(1.0, 0.0, 0.0);
-                    ::basegfx::B3DPoint aLastLeft(0.0, 1.0, 0.0);
-                    ::basegfx::B3DPoint aLastRight(1.0, 1.0, 0.0);
-                    ::basegfx::B3DHomMatrix aRot;
+                    const basegfx::B3DPoint aLeft(0.0, 0.0, 0.0);
+                    const basegfx::B3DPoint aRight(1.0, 0.0, 0.0);
+                    basegfx::B3DPoint aLastLeft(0.0, 1.0, 0.0);
+                    basegfx::B3DPoint aLastRight(1.0, 1.0, 0.0);
+                    basegfx::B3DHomMatrix aRot;
                     aRot.rotate(F_2PI / (double)nLineTubeSegments, 0.0, 0.0);
 
                     for(sal_uInt32 a(0L); a < nLineTubeSegments; a++)
                     {
-                        const ::basegfx::B3DPoint aNextLeft(aRot * aLastLeft);
-                        const ::basegfx::B3DPoint aNextRight(aRot * aLastRight);
-                        ::basegfx::B3DPolygon aNewPolygon;
+                        const basegfx::B3DPoint aNextLeft(aRot * aLastLeft);
+                        const basegfx::B3DPoint aNextRight(aRot * aLastRight);
+                        basegfx::B3DPolygon aNewPolygon;
 
                         aNewPolygon.append(aNextLeft);
-                        aNewPolygon.setNormal(0L, ::basegfx::B3DVector(aNextLeft - aLeft));
+                        aNewPolygon.setNormal(0L, basegfx::B3DVector(aNextLeft - aLeft));
 
                         aNewPolygon.append(aLastLeft);
-                        aNewPolygon.setNormal(1L, ::basegfx::B3DVector(aLastLeft - aLeft));
+                        aNewPolygon.setNormal(1L, basegfx::B3DVector(aLastLeft - aLeft));
 
                         aNewPolygon.append(aLastRight);
-                        aNewPolygon.setNormal(2L, ::basegfx::B3DVector(aLastRight - aRight));
+                        aNewPolygon.setNormal(2L, basegfx::B3DVector(aLastRight - aRight));
 
                         aNewPolygon.append(aNextRight);
-                        aNewPolygon.setNormal(3L, ::basegfx::B3DVector(aNextRight - aRight));
+                        aNewPolygon.setNormal(3L, basegfx::B3DVector(aNextRight - aRight));
 
                         aNewPolygon.setClosed(true);
 
-                        const ::basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
-                        basePrimitive* pNew = new polyPolygonMaterialPrimitive3D(aNewPolyPolygon, aLineMaterial, false);
-                        aLineTubeList.push_back(referencedPrimitive(*pNew));
+                        const basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
+                        basePrimitive3D* pNew = new polyPolygonMaterialPrimitive3D(aNewPolyPolygon, aLineMaterial, false);
+                        aLineTubeList.push_back(referencedPrimitive3D(*pNew));
 
                         aLastLeft = aNextLeft;
                         aLastRight = aNextRight;
@@ -131,12 +133,14 @@ namespace drawinglayer
                 return aLineTubeList;
             }
 
-            const primitiveVector& getLineCapSegments(sal_uInt32 nSegments, const materialAttribute3D& rMaterial)
+            const primitiveVector3D& getLineCapSegments(
+                sal_uInt32 nSegments,
+                const attribute::materialAttribute3D& rMaterial)
             {
                 // static data for buffered tube primitives
-                static primitiveVector aLineCapList;
+                static primitiveVector3D aLineCapList;
                 static sal_uInt32 nLineCapSegments(0L);
-                static materialAttribute3D aLineMaterial;
+                static attribute::materialAttribute3D aLineMaterial;
 
                 // may exclusively change static data, use mutex
                 ::osl::Mutex m_mutex;
@@ -150,30 +154,30 @@ namespace drawinglayer
 
                 if(0L == aLineCapList.size() && 0L != nLineCapSegments)
                 {
-                    const ::basegfx::B3DPoint aNull(0.0, 0.0, 0.0);
-                    ::basegfx::B3DPoint aLast(0.0, 1.0, 0.0);
-                    ::basegfx::B3DHomMatrix aRot;
+                    const basegfx::B3DPoint aNull(0.0, 0.0, 0.0);
+                    basegfx::B3DPoint aLast(0.0, 1.0, 0.0);
+                    basegfx::B3DHomMatrix aRot;
                     aRot.rotate(F_2PI / (double)nLineCapSegments, 0.0, 0.0);
 
                     for(sal_uInt32 a(0L); a < nLineCapSegments; a++)
                     {
-                        const ::basegfx::B3DPoint aNext(aRot * aLast);
-                        ::basegfx::B3DPolygon aNewPolygon;
+                        const basegfx::B3DPoint aNext(aRot * aLast);
+                        basegfx::B3DPolygon aNewPolygon;
 
                         aNewPolygon.append(aLast);
-                        aNewPolygon.setNormal(0L, ::basegfx::B3DVector(aLast - aNull));
+                        aNewPolygon.setNormal(0L, basegfx::B3DVector(aLast - aNull));
 
                         aNewPolygon.append(aNext);
-                        aNewPolygon.setNormal(1L, ::basegfx::B3DVector(aNext - aNull));
+                        aNewPolygon.setNormal(1L, basegfx::B3DVector(aNext - aNull));
 
                         aNewPolygon.append(aNull);
-                        aNewPolygon.setNormal(2L, ::basegfx::B3DVector(-1.0, 0.0, 0.0));
+                        aNewPolygon.setNormal(2L, basegfx::B3DVector(-1.0, 0.0, 0.0));
 
                         aNewPolygon.setClosed(true);
 
-                        const ::basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
-                        basePrimitive* pNew = new polyPolygonMaterialPrimitive3D(aNewPolyPolygon, aLineMaterial, false);
-                        aLineCapList.push_back(referencedPrimitive(*pNew));
+                        const basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
+                        basePrimitive3D* pNew = new polyPolygonMaterialPrimitive3D(aNewPolyPolygon, aLineMaterial, false);
+                        aLineCapList.push_back(referencedPrimitive3D(*pNew));
 
                         aLast = aNext;
                     }
@@ -182,15 +186,21 @@ namespace drawinglayer
                 return aLineCapList;
             }
 
-            void getLineJoinSegments(primitiveVector& rDest, sal_uInt32 nSegments, const materialAttribute3D& rMaterial, double fAngle,
-                double fDegreeStepWidth, double fMiterMinimumAngle, ::basegfx::tools::B2DLineJoin aLineJoin)
+            void getLineJoinSegments(
+                primitiveVector3D& rDest,
+                sal_uInt32 nSegments,
+                const attribute::materialAttribute3D& rMaterial,
+                double fAngle,
+                double fDegreeStepWidth,
+                double fMiterMinimumAngle,
+                basegfx::tools::B2DLineJoin aLineJoin)
             {
                 // nSegments is for whole circle, adapt to half circle
                 const sal_uInt32 nVerSeg(nSegments >> 1L);
 
                 if(nVerSeg)
                 {
-                    if(::basegfx::tools::B2DLINEJOIN_ROUND == aLineJoin)
+                    if(basegfx::tools::B2DLINEJOIN_ROUND == aLineJoin)
                     {
                         // calculate new horizontal segments
                         const sal_uInt32 nHorSeg((sal_uInt32)((fAngle / F_2PI) * (double)nSegments));
@@ -198,48 +208,48 @@ namespace drawinglayer
                         if(nHorSeg)
                         {
                             // create half-sphere
-                            const ::basegfx::B3DPolyPolygon aSphere(::basegfx::tools::createUnitSphereFillPolyPolygon(nHorSeg, nVerSeg, true, F_PI2, -F_PI2, 0.0, fAngle));
+                            const basegfx::B3DPolyPolygon aSphere(basegfx::tools::createUnitSphereFillPolyPolygon(nHorSeg, nVerSeg, true, F_PI2, -F_PI2, 0.0, fAngle));
 
                             for(sal_uInt32 a(0L); a < aSphere.count(); a++)
                             {
-                                const ::basegfx::B3DPolygon aPartPolygon(aSphere.getB3DPolygon(a));
-                                const ::basegfx::B3DPolyPolygon aPartPolyPolygon(aPartPolygon);
-                                basePrimitive* pNew = new polyPolygonMaterialPrimitive3D(aPartPolyPolygon, rMaterial, false);
-                                rDest.push_back(referencedPrimitive(*pNew));
+                                const basegfx::B3DPolygon aPartPolygon(aSphere.getB3DPolygon(a));
+                                const basegfx::B3DPolyPolygon aPartPolyPolygon(aPartPolygon);
+                                basePrimitive3D* pNew = new polyPolygonMaterialPrimitive3D(aPartPolyPolygon, rMaterial, false);
+                                rDest.push_back(referencedPrimitive3D(*pNew));
                             }
                         }
                         else
                         {
                             // fallback to bevel when there is not at least one segment hor and ver
-                            aLineJoin = ::basegfx::tools::B2DLINEJOIN_BEVEL;
+                            aLineJoin = basegfx::tools::B2DLINEJOIN_BEVEL;
                         }
                     }
 
-                    if(::basegfx::tools::B2DLINEJOIN_MIDDLE == aLineJoin
-                        || ::basegfx::tools::B2DLINEJOIN_BEVEL == aLineJoin
-                        || ::basegfx::tools::B2DLINEJOIN_MITER == aLineJoin)
+                    if(basegfx::tools::B2DLINEJOIN_MIDDLE == aLineJoin
+                        || basegfx::tools::B2DLINEJOIN_BEVEL == aLineJoin
+                        || basegfx::tools::B2DLINEJOIN_MITER == aLineJoin)
                     {
-                        if(::basegfx::tools::B2DLINEJOIN_MITER == aLineJoin)
+                        if(basegfx::tools::B2DLINEJOIN_MITER == aLineJoin)
                         {
                             const double fMiterAngle(fAngle/2.0);
 
                             if(fMiterAngle < fMiterMinimumAngle)
                             {
                                 // fallback to bevel when miter's angle is too small
-                                aLineJoin = ::basegfx::tools::B2DLINEJOIN_BEVEL;
+                                aLineJoin = basegfx::tools::B2DLINEJOIN_BEVEL;
                             }
                         }
 
                         const double fInc(F_PI / (double)nVerSeg);
                         const double fSin(sin(-fAngle));
                         const double fCos(cos(-fAngle));
-                        const bool bMiter(::basegfx::tools::B2DLINEJOIN_MITER == aLineJoin);
+                        const bool bMiter(basegfx::tools::B2DLINEJOIN_MITER == aLineJoin);
                         const double fMiterSin(bMiter ? sin(-(fAngle/2.0)) : 0.0);
                         const double fMiterCos(bMiter ? cos(-(fAngle/2.0)) : 0.0);
                         double fPos(-F_PI2);
-                        ::basegfx::B3DPoint aPointOnXY, aPointRotY, aNextPointOnXY, aNextPointRotY;
-                        ::basegfx::B3DPoint aCurrMiter, aNextMiter;
-                        ::basegfx::B3DPolygon aNewPolygon, aMiterPolygon;
+                        basegfx::B3DPoint aPointOnXY, aPointRotY, aNextPointOnXY, aNextPointRotY;
+                        basegfx::B3DPoint aCurrMiter, aNextMiter;
+                        basegfx::B3DPolygon aNewPolygon, aMiterPolygon;
 
                         // close polygon
                         aNewPolygon.setClosed(true);
@@ -254,19 +264,19 @@ namespace drawinglayer
                             {
                                 fPos += fInc;
 
-                                aNextPointOnXY = ::basegfx::B3DPoint(
+                                aNextPointOnXY = basegfx::B3DPoint(
                                     cos(fPos),
                                     sin(fPos),
                                     0.0);
 
-                                aNextPointRotY = ::basegfx::B3DPoint(
+                                aNextPointRotY = basegfx::B3DPoint(
                                     aNextPointOnXY.getX() * fCos,
                                     aNextPointOnXY.getY(),
                                     aNextPointOnXY.getX() * fSin);
 
                                 if(bMiter)
                                 {
-                                    aNextMiter = ::basegfx::B3DPoint(
+                                    aNextMiter = basegfx::B3DPoint(
                                         aNextPointOnXY.getX(),
                                         aNextPointOnXY.getY(),
                                         fMiterSin * (aNextPointOnXY.getX() / fMiterCos));
@@ -279,18 +289,18 @@ namespace drawinglayer
 
                                 if(bMiter)
                                 {
-                                    aNewPolygon.append(::basegfx::B3DPoint(0.0, -1.0, 0.0));
+                                    aNewPolygon.append(basegfx::B3DPoint(0.0, -1.0, 0.0));
                                     aNewPolygon.append(aNextPointOnXY);
                                     aNewPolygon.append(aNextMiter);
 
                                     aMiterPolygon.clear();
-                                    aMiterPolygon.append(::basegfx::B3DPoint(0.0, -1.0, 0.0));
+                                    aMiterPolygon.append(basegfx::B3DPoint(0.0, -1.0, 0.0));
                                     aMiterPolygon.append(aNextMiter);
                                     aMiterPolygon.append(aNextPointRotY);
                                 }
                                 else
                                 {
-                                    aNewPolygon.append(::basegfx::B3DPoint(0.0, -1.0, 0.0));
+                                    aNewPolygon.append(basegfx::B3DPoint(0.0, -1.0, 0.0));
                                     aNewPolygon.append(aNextPointOnXY);
                                     aNewPolygon.append(aNextPointRotY);
                                 }
@@ -301,18 +311,18 @@ namespace drawinglayer
 
                                 if(bMiter)
                                 {
-                                    aNewPolygon.append(::basegfx::B3DPoint(0.0, 1.0, 0.0));
+                                    aNewPolygon.append(basegfx::B3DPoint(0.0, 1.0, 0.0));
                                     aNewPolygon.append(aCurrMiter);
                                     aNewPolygon.append(aPointOnXY);
 
                                     aMiterPolygon.clear();
-                                    aMiterPolygon.append(::basegfx::B3DPoint(0.0, 1.0, 0.0));
+                                    aMiterPolygon.append(basegfx::B3DPoint(0.0, 1.0, 0.0));
                                     aMiterPolygon.append(aPointRotY);
                                     aMiterPolygon.append(aCurrMiter);
                                 }
                                 else
                                 {
-                                    aNewPolygon.append(::basegfx::B3DPoint(0.0, 1.0, 0.0));
+                                    aNewPolygon.append(basegfx::B3DPoint(0.0, 1.0, 0.0));
                                     aNewPolygon.append(aPointRotY);
                                     aNewPolygon.append(aPointOnXY);
                                 }
@@ -346,15 +356,15 @@ namespace drawinglayer
                             // set normals
                             for(sal_uInt32 b(0L); b < aNewPolygon.count(); b++)
                             {
-                                aNewPolygon.setNormal(b, ::basegfx::B3DVector(aNewPolygon.getB3DPoint(b)));
+                                aNewPolygon.setNormal(b, basegfx::B3DVector(aNewPolygon.getB3DPoint(b)));
                             }
 
                             // create primitive
                             if(aNewPolygon.count())
                             {
-                                const ::basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
-                                basePrimitive* pNew = new polyPolygonMaterialPrimitive3D(aNewPolyPolygon, rMaterial, false);
-                                rDest.push_back(referencedPrimitive(*pNew));
+                                const basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
+                                basePrimitive3D* pNew = new polyPolygonMaterialPrimitive3D(aNewPolyPolygon, rMaterial, false);
+                                rDest.push_back(referencedPrimitive3D(*pNew));
                             }
 
                             if(bMiter && aMiterPolygon.count())
@@ -362,13 +372,13 @@ namespace drawinglayer
                                 // set normals
                                 for(sal_uInt32 c(0L); c < aMiterPolygon.count(); c++)
                                 {
-                                    aMiterPolygon.setNormal(c, ::basegfx::B3DVector(aMiterPolygon.getB3DPoint(c)));
+                                    aMiterPolygon.setNormal(c, basegfx::B3DVector(aMiterPolygon.getB3DPoint(c)));
                                 }
 
                                 // create primitive
-                                const ::basegfx::B3DPolyPolygon aMiterPolyPolygon(aMiterPolygon);
-                                basePrimitive* pNew = new polyPolygonMaterialPrimitive3D(aMiterPolyPolygon, rMaterial, false);
-                                rDest.push_back(referencedPrimitive(*pNew));
+                                const basegfx::B3DPolyPolygon aMiterPolyPolygon(aMiterPolygon);
+                                basePrimitive3D* pNew = new polyPolygonMaterialPrimitive3D(aMiterPolyPolygon, rMaterial, false);
+                                rDest.push_back(referencedPrimitive3D(*pNew));
                             }
 
                             // prepare next step
@@ -387,10 +397,10 @@ namespace drawinglayer
                 }
             }
 
-            ::basegfx::B3DHomMatrix getRotationFromVector(const ::basegfx::B3DVector& rVector)
+            basegfx::B3DHomMatrix getRotationFromVector(const basegfx::B3DVector& rVector)
             {
                 // build transformation from unit vector to vector
-                ::basegfx::B3DHomMatrix aRetval;
+                basegfx::B3DHomMatrix aRetval;
 
                 // get applied rotations from angles in XY and in XZ (cartesian)
                 const double fRotInXY(atan2(rVector.getY(), rVector.getXZLength()));
@@ -403,105 +413,105 @@ namespace drawinglayer
                 return aRetval;
             }
         } // end of anonymous namespace
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void polygonTubePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void polygonTubePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             const sal_uInt32 nPointCount(maPolygon.count());
 
             if(0L != nPointCount)
             {
-                if(::basegfx::fTools::more(mfRadius, 0.0))
+                if(basegfx::fTools::more(mfRadius, 0.0))
                 {
-                    const materialAttribute3D aMaterial(maBColor);
+                    const attribute::materialAttribute3D aMaterial(maBColor);
                     static sal_uInt32 nSegments(8L); // default for 3d line segments, for more quality just raise this value (in even steps)
                     const bool bClosed(maPolygon.isClosed());
-                    const bool bNoLineJoin(::basegfx::tools::B2DLINEJOIN_NONE == maLineJoin);
+                    const bool bNoLineJoin(basegfx::tools::B2DLINEJOIN_NONE == maLineJoin);
                     const sal_uInt32 nLoopCount(bClosed ? nPointCount : nPointCount - 1L);
-                    ::basegfx::B3DPoint aLast(maPolygon.getB3DPoint(nPointCount - 1L));
-                    ::basegfx::B3DPoint aCurr(maPolygon.getB3DPoint(0L));
+                    basegfx::B3DPoint aLast(maPolygon.getB3DPoint(nPointCount - 1L));
+                    basegfx::B3DPoint aCurr(maPolygon.getB3DPoint(0L));
 
                     for(sal_uInt32 a(0L); a < nLoopCount; a++)
                     {
                         // get next data
-                        const ::basegfx::B3DPoint aNext(maPolygon.getB3DPoint((a + 1L) % nPointCount));
-                        const ::basegfx::B3DVector aForw(aNext - aCurr);
+                        const basegfx::B3DPoint aNext(maPolygon.getB3DPoint((a + 1L) % nPointCount));
+                        const basegfx::B3DVector aForw(aNext - aCurr);
                         const double fForwLen(aForw.getLength());
 
-                        if(::basegfx::fTools::more(fForwLen, 0.0))
+                        if(basegfx::fTools::more(fForwLen, 0.0))
                         {
                             // get rotation from vector, this describes rotation from (1, 0, 0) to aForw
-                            ::basegfx::B3DHomMatrix aRotVector(getRotationFromVector(aForw));
+                            basegfx::B3DHomMatrix aRotVector(getRotationFromVector(aForw));
 
                             // create default transformation with scale and rotate
-                            ::basegfx::B3DHomMatrix aVectorTrans;
+                            basegfx::B3DHomMatrix aVectorTrans;
                             aVectorTrans.scale(fForwLen, mfRadius, mfRadius);
                             aVectorTrans *= aRotVector;
                             aVectorTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
 
                             if(bNoLineJoin || (!bClosed && !a))
                             {
-                                // line start edge, build transformed primitiveVector
+                                // line start edge, build transformed primitiveVector3D
                                 transformPrimitive3D* pNewTransformedA = new transformPrimitive3D(aVectorTrans, getLineCapSegments(nSegments, aMaterial));
-                                rTarget.push_back(referencedPrimitive(*pNewTransformedA));
+                                rTarget.push_back(referencedPrimitive3D(*pNewTransformedA));
                             }
                             else
                             {
-                                const ::basegfx::B3DVector aBack(aCurr - aLast);
-                                const double fCross(::basegfx::cross(aBack, aForw).getLength());
+                                const basegfx::B3DVector aBack(aCurr - aLast);
+                                const double fCross(basegfx::cross(aBack, aForw).getLength());
 
-                                if(!::basegfx::fTools::equalZero(fCross))
+                                if(!basegfx::fTools::equalZero(fCross))
                                 {
                                     // line connect non-parallel, aBack, aForw, use maLineJoin
-                                    primitiveVector aNewList;
+                                    primitiveVector3D aNewList;
                                     const double fAngle(acos(aBack.scalar(aForw) / (fForwLen * aBack.getLength()))); // 0.0 .. F_PI2
                                     getLineJoinSegments(aNewList, nSegments, aMaterial, fAngle, mfDegreeStepWidth, mfMiterMinimumAngle, maLineJoin);
 
                                     // calculate transformation. First, get angle in YZ between nForw projected on (1, 0, 0) and nBack
-                                    ::basegfx::B3DHomMatrix aInvRotVector(aRotVector);
+                                    basegfx::B3DHomMatrix aInvRotVector(aRotVector);
                                     aInvRotVector.invert();
-                                    ::basegfx::B3DVector aTransBack(aInvRotVector * aBack);
+                                    basegfx::B3DVector aTransBack(aInvRotVector * aBack);
                                     const double fRotInYZ(atan2(aTransBack.getY(), aTransBack.getZ()));
 
                                     // create trans by rotating unit sphere with angle 90 degrees around Y, then 180-fRot in X.
                                     // Also apply usual scaling and translation
-                                    ::basegfx::B3DHomMatrix aSphereTrans;
+                                    basegfx::B3DHomMatrix aSphereTrans;
                                     aSphereTrans.rotate(0.0, F_PI2, 0.0);
                                     aSphereTrans.rotate(F_PI - fRotInYZ, 0.0, 0.0);
                                     aSphereTrans *= aRotVector;
                                     aSphereTrans.scale(mfRadius, mfRadius, mfRadius);
                                     aSphereTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
 
-                                    // line start edge, build transformed primitiveVector
+                                    // line start edge, build transformed primitiveVector3D
                                     transformPrimitive3D* pNewTransformedB = new transformPrimitive3D(aSphereTrans, aNewList);
-                                    rTarget.push_back(referencedPrimitive(*pNewTransformedB));
+                                    rTarget.push_back(referencedPrimitive3D(*pNewTransformedB));
                                 }
                             }
 
-                            // create line segments, build transformed primitiveVector
+                            // create line segments, build transformed primitiveVector3D
                             transformPrimitive3D* pNewTransformedC = new transformPrimitive3D(aVectorTrans, getLineTubeSegments(nSegments, aMaterial));
-                            rTarget.push_back(referencedPrimitive(*pNewTransformedC));
+                            rTarget.push_back(referencedPrimitive3D(*pNewTransformedC));
 
                             if(bNoLineJoin || (!bClosed && ((a + 1L) == nLoopCount)))
                             {
                                 // line end edge, first rotate (mirror) and translate, then use use aRotVector
-                                ::basegfx::B3DHomMatrix aBackTrans;
+                                basegfx::B3DHomMatrix aBackTrans;
                                 aBackTrans.rotate(0.0, F_PI, 0.0);
                                 aBackTrans.translate(1.0, 0.0, 0.0);
                                 aBackTrans.scale(fForwLen, mfRadius, mfRadius);
                                 aBackTrans *= aRotVector;
                                 aBackTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
 
-                                // line end edge, build transformed primitiveVector
+                                // line end edge, build transformed primitiveVector3D
                                 transformPrimitive3D* pNewTransformedD = new transformPrimitive3D(aBackTrans, getLineCapSegments(nSegments, aMaterial));
-                                rTarget.push_back(referencedPrimitive(*pNewTransformedD));
+                                rTarget.push_back(referencedPrimitive3D(*pNewTransformedD));
                             }
                         }
 
@@ -514,15 +524,15 @@ namespace drawinglayer
                 {
                     // create hairline
                     polygonHairlinePrimitive3D* pNew = new polygonHairlinePrimitive3D(maPolygon, maBColor);
-                    rTarget.push_back(referencedPrimitive(*pNew));
+                    rTarget.push_back(referencedPrimitive3D(*pNew));
                 }
             }
         }
 
         polygonTubePrimitive3D::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,
             double fMiterMinimumAngle)
         :   polygonHairlinePrimitive3D(rPolygon, rBColor),
@@ -537,7 +547,7 @@ namespace drawinglayer
         {
         }
 
-        bool polygonTubePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool polygonTubePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(polygonHairlinePrimitive3D::operator==(rPrimitive))
             {
@@ -556,7 +566,7 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('T', 'U', 'B', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx b/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx
index 0ba67d332f83..6e838043762b 100644
--- a/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: polypolygonprimitive3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -45,10 +45,14 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        polyPolygonMaterialPrimitive3D::polyPolygonMaterialPrimitive3D(const ::basegfx::B3DPolyPolygon& rPolyPolygon, const materialAttribute3D& rMaterial, bool bDoubleSided)
-        :   maPolyPolygon(rPolyPolygon),
+        polyPolygonMaterialPrimitive3D::polyPolygonMaterialPrimitive3D(
+            const basegfx::B3DPolyPolygon& rPolyPolygon,
+            const attribute::materialAttribute3D& rMaterial,
+            bool bDoubleSided)
+        :   basePrimitive3D(),
+            maPolyPolygon(rPolyPolygon),
             maMaterial(rMaterial),
             mbDoubleSided(bDoubleSided)
         {
@@ -58,7 +62,7 @@ namespace drawinglayer
         {
         }
 
-        bool polyPolygonMaterialPrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool polyPolygonMaterialPrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(getID() == rPrimitive.getID())
             {
@@ -77,11 +81,11 @@ namespace drawinglayer
             return CreatePrimitiveID('P', 'O', 'M', '3');
         }
 
-        ::basegfx::B3DRange polyPolygonMaterialPrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange polyPolygonMaterialPrimitive3D::get3DRange() const
         {
-            return ::basegfx::tools::getRange(maPolyPolygon);
+            return basegfx::tools::getRange(maPolyPolygon);
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx
index b34fd61f3449..aa2a43198df4 100644
--- a/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrcubeprimitive3d.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -69,16 +69,16 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void sdrCubePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void sdrCubePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
-            const ::basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
+            const basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
 
             // add fill
             if(getSdrLFSAttribute().getFill())
             {
-                ::basegfx::B3DPolyPolygon aFill(::basegfx::tools::createCubeFillPolyPolygonFromB3DRange(aUnitRange));
+                basegfx::B3DPolyPolygon aFill(basegfx::tools::createCubeFillPolyPolygonFromB3DRange(aUnitRange));
 
                 // normal creation
                 {
@@ -86,14 +86,14 @@ namespace drawinglayer
                         || ::com::sun::star::drawing::NormalsKind_SPHERE == getSdr3DObjectAttribute().getNormalsKind())
                     {
                         // create sphere normals
-                        const ::basegfx::B3DPoint aCenter(::basegfx::tools::getRange(aFill).getCenter());
-                        aFill = ::basegfx::tools::applyDefaultNormalsSphere(aFill, aCenter);
+                        const basegfx::B3DPoint aCenter(basegfx::tools::getRange(aFill).getCenter());
+                        aFill = basegfx::tools::applyDefaultNormalsSphere(aFill, aCenter);
                     }
 
                     if(getSdr3DObjectAttribute().getNormalsInvert())
                     {
                         // invert normals
-                        aFill = ::basegfx::tools::invertNormals(aFill);
+                        aFill = basegfx::tools::invertNormals(aFill);
                     }
                 }
 
@@ -112,16 +112,16 @@ namespace drawinglayer
                     if(bParallelX || bParallelY)
                     {
                         // apply parallel texture coordinates in X and/or Y
-                        const ::basegfx::B3DRange aRange(::basegfx::tools::getRange(aFill));
-                        aFill = ::basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
+                        const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
+                        aFill = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
                     }
 
                     if(bSphereX || bSphereY)
                     {
                         // apply spherical texture coordinates in X and/or Y
-                        const ::basegfx::B3DRange aRange(::basegfx::tools::getRange(aFill));
-                        const ::basegfx::B3DPoint aCenter(aRange.getCenter());
-                        aFill = ::basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill, aCenter, bSphereX, bSphereY);
+                        const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
+                        const basegfx::B3DPoint aCenter(aRange.getCenter());
+                        aFill = basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill, aCenter, bSphereX, bSphereY);
                     }
 
                     if(bObjectSpecificX || bObjectSpecificY)
@@ -129,13 +129,13 @@ namespace drawinglayer
                         // object-specific
                         for(sal_uInt32 a(0L); a < aFill.count(); a++)
                         {
-                            ::basegfx::B3DPolygon aTmpPoly(aFill.getB3DPolygon(a));
+                            basegfx::B3DPolygon aTmpPoly(aFill.getB3DPolygon(a));
 
                             if(aTmpPoly.count() >= 4L)
                             {
                                 for(sal_uInt32 b(0L); b < 4L; b++)
                                 {
-                                    ::basegfx::B2DPoint aPoint(aTmpPoly.getTextureCoordinate(b));
+                                    basegfx::B2DPoint aPoint(aTmpPoly.getTextureCoordinate(b));
 
                                     if(bObjectSpecificX)
                                     {
@@ -156,17 +156,17 @@ namespace drawinglayer
                     }
 
                     // transform texture coordinates to texture size
-                    ::basegfx::B2DHomMatrix aTexMatrix;
+                    basegfx::B2DHomMatrix aTexMatrix;
                     aTexMatrix.scale(maTextureSize.getX(), maTextureSize.getY());
                     aFill.transformTextureCoordiantes(aTexMatrix);
                 }
 
                 // build vector of PolyPolygons
-                ::std::vector< ::basegfx::B3DPolyPolygon > a3DPolyPolygonVector;
+                ::std::vector< basegfx::B3DPolyPolygon > a3DPolyPolygonVector;
 
                 for(sal_uInt32 a(0L); a < aFill.count(); a++)
                 {
-                    a3DPolyPolygonVector.push_back(::basegfx::B3DPolyPolygon(aFill.getB3DPolygon(a)));
+                    a3DPolyPolygonVector.push_back(basegfx::B3DPolyPolygon(aFill.getB3DPolygon(a)));
                 }
 
                 // create single PolyPolygonFill primitives
@@ -179,7 +179,7 @@ namespace drawinglayer
             // add line
             if(getSdrLFSAttribute().getLine())
             {
-                ::basegfx::B3DPolyPolygon aLine(::basegfx::tools::createCubePolyPolygonFromB3DRange(aUnitRange));
+                basegfx::B3DPolyPolygon aLine(basegfx::tools::createCubePolyPolygonFromB3DRange(aUnitRange));
                 add3DPolyPolygonLinePrimitive(aLine, maTransform, rTarget, *getSdrLFSAttribute().getLine());
             }
 
@@ -191,10 +191,10 @@ namespace drawinglayer
         }
 
         sdrCubePrimitive3D::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)
         :   sdrPrimitive3D(rTransform, rTextureSize, rSdrLFSAttribute, rSdr3DObjectAttribute)
         {
         }
@@ -203,7 +203,7 @@ namespace drawinglayer
         {
         }
 
-        bool sdrCubePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool sdrCubePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             return sdrPrimitive3D::operator==(rPrimitive);
         }
@@ -213,7 +213,7 @@ namespace drawinglayer
             return CreatePrimitiveID('S', 'C', 'U', '3');
         }
 
-        ::basegfx::B3DRange sdrCubePrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange sdrCubePrimitive3D::get3DRange() const
         {
             // use defaut from sdrPrimitive3D which uses transformation expanded by line width/2.
             // The parent implementation which uses the ranges of the decomposition would be more
@@ -221,9 +221,9 @@ namespace drawinglayer
             // the range of the non-transformed geometry and transform it then. This leads to different
             // ranges where the new method is more correct, but the need to keep the old behaviour
             // has priority here.
-            return getStandard3DRange(rViewInformation);
+            return getStandard3DRange();
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx b/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx
index 82816748a7c3..0e9c053b15cf 100644
--- a/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrdecompositiontools3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -41,16 +41,16 @@
 #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
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_SDRATTRIBUTE_HXX
-#include <drawinglayer/primitive/sdrattribute.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrattribute.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_PRIMITIVE_HXX
-#include <drawinglayer/primitive/primitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_PRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/primitive3d.hxx>
 #endif
 
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_POLYGONPRIMITIVE3D_HXX
@@ -69,24 +69,24 @@
 #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE3D_SDRATTRIBUTE3D_HXX
-#include <drawinglayer/primitive3d/sdrattribute3d.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrattribute.hxx>
 #endif
 
 #ifndef _VCL_VCLENUM_HXX
 #include <vcl/vclenum.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 _DRAWINGLAYER_PRIMITIVE_SDRFILLBITMAPATTRIBUTE_HXX
-#include <drawinglayer/primitive/sdrfillbitmapattribute.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRFILLBITMAPATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
 #endif
 
 #ifndef _SV_BMPACC_HXX
@@ -101,8 +101,8 @@
 #include <drawinglayer/primitive3d/textureprimitive3d.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_MODIFIEDCOLORPRIMITIVE_HXX
-#include <drawinglayer/primitive/modifiedcolorprimitive.hxx>
+#ifndef _DRAWINGLAYER_PRIMITIVE3D_MODIFIEDCOLORPRIMITIVE3D_HXX
+#include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
 #endif
 
 #ifndef _DRAWINGLAYER_PRIMITIVE3D_HATCHTEXTUREPRIMITIVE3D_HXX
@@ -113,39 +113,43 @@
 #include <drawinglayer/primitive3d/shadowprimitive3d.hxx>
 #endif
 
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE3D_HXX
+#include <drawinglayer/attribute/sdrattribute3d.hxx>
+#endif
+
 //////////////////////////////////////////////////////////////////////////////
 
 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)
         {
             // prepare fully scaled polyPolygon
-            ::basegfx::B3DPolyPolygon aScaledPolyPolygon(rUnitPolyPolygon);
+            basegfx::B3DPolyPolygon aScaledPolyPolygon(rUnitPolyPolygon);
             aScaledPolyPolygon.transform(rObjectTransform);
 
             // create stroke attribute
-            const strokeAttribute aStrokeAttribute(rLine.getColor(), rLine.getWidth(), rLine.getJoin(), rLine.getDotDashArray(), rLine.getFullDotDashLen());
+            const attribute::strokeAttribute aStrokeAttribute(rLine.getColor(), rLine.getWidth(), rLine.getJoin(), rLine.getDotDashArray(), rLine.getFullDotDashLen());
 
             // create primitives
-            primitiveVector aNewPrimitiveVector;
+            primitiveVector3D aNewPrimitiveVector;
 
             for(sal_uInt32 a(0L); a < aScaledPolyPolygon.count(); a++)
             {
-                basePrimitive* pNewLinePrimitive = new polygonStrokePrimitive3D(aScaledPolyPolygon.getB3DPolygon(a), aStrokeAttribute);
-                aNewPrimitiveVector.push_back(referencedPrimitive(*pNewLinePrimitive));
+                basePrimitive3D* pNewLinePrimitive = new polygonStrokePrimitive3D(aScaledPolyPolygon.getB3DPolygon(a), aStrokeAttribute);
+                aNewPrimitiveVector.push_back(referencedPrimitive3D(*pNewLinePrimitive));
             }
 
             if(0.0 != rLine.getTransparence())
             {
                 // create simpleTransparencePrimitive, add created fill primitives
-                basePrimitive* pNewSimpleTransparenceTexturePrimitive3D = new simpleTransparenceTexturePrimitive3D(rLine.getTransparence(), aNewPrimitiveVector);
-                rTarget.push_back(referencedPrimitive(*pNewSimpleTransparenceTexturePrimitive3D));
+                basePrimitive3D* pNewSimpleTransparenceTexturePrimitive3D = new simpleTransparenceTexturePrimitive3D(rLine.getTransparence(), aNewPrimitiveVector);
+                rTarget.push_back(referencedPrimitive3D(*pNewSimpleTransparenceTexturePrimitive3D));
             }
             else
             {
@@ -155,23 +159,23 @@ namespace drawinglayer
         }
 
         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)
+            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)
         {
             if(r3DPolyPolygonVector.size())
             {
                 // create list of simple fill primitives
-                primitiveVector aNewPrimitiveVector;
+                primitiveVector3D aNewPrimitiveVector;
 
                 for(sal_uInt32 a(0L); a < r3DPolyPolygonVector.size(); a++)
                 {
                     // get scaled PolyPolygon
-                    ::basegfx::B3DPolyPolygon aScaledPolyPolygon(r3DPolyPolygonVector[a]);
+                    basegfx::B3DPolyPolygon aScaledPolyPolygon(r3DPolyPolygonVector[a]);
                     aScaledPolyPolygon.transform(rObjectTransform);
 
                     if(aScaledPolyPolygon.areNormalsUsed())
@@ -179,11 +183,11 @@ namespace drawinglayer
                         aScaledPolyPolygon.transformNormals(rObjectTransform);
                     }
 
-                    basePrimitive* pNewFillPrimitive = new polyPolygonMaterialPrimitive3D(
+                    basePrimitive3D* pNewFillPrimitive = new polyPolygonMaterialPrimitive3D(
                         aScaledPolyPolygon,
                         aSdr3DObjectAttribute.getMaterial(),
                         aSdr3DObjectAttribute.getDoubleSided());
-                    aNewPrimitiveVector.push_back(referencedPrimitive(*pNewFillPrimitive));
+                    aNewPrimitiveVector.push_back(referencedPrimitive3D(*pNewFillPrimitive));
                 }
 
                 // look for and evtl. build texture sub-group primitive
@@ -191,7 +195,7 @@ namespace drawinglayer
                 {
                     bool bModulate(::com::sun::star::drawing::TextureMode_MODULATE == aSdr3DObjectAttribute.getTextureMode());
                     bool bFilter(aSdr3DObjectAttribute.getTextureFilter());
-                    basePrimitive* pNewTexturePrimitive3D = 0L;
+                    basePrimitive3D* pNewTexturePrimitive3D = 0L;
 
                     if(rFill.isGradient())
                     {
@@ -206,35 +210,35 @@ namespace drawinglayer
                     else // if(rFill.isBitmap())
                     {
                         // create bitmapTexture3D with sublist, add to local aNewPrimitiveVector
-                        ::basegfx::B2DRange aTexRange(0.0, 0.0, rTextureSize.getX(), rTextureSize.getY());
+                        basegfx::B2DRange aTexRange(0.0, 0.0, rTextureSize.getX(), rTextureSize.getY());
                         pNewTexturePrimitive3D = new bitmapTexturePrimitive3D(rFill.getBitmap()->getFillBitmapAttribute(aTexRange), aNewPrimitiveVector, rTextureSize, bModulate, bFilter);
                     }
 
                     // exchange aNewPrimitiveVector content with texture group
                     aNewPrimitiveVector.clear();
-                    aNewPrimitiveVector.push_back(referencedPrimitive(*pNewTexturePrimitive3D));
+                    aNewPrimitiveVector.push_back(referencedPrimitive3D(*pNewTexturePrimitive3D));
 
                     if(::com::sun::star::drawing::TextureKind2_LUMINANCE == aSdr3DObjectAttribute.getTextureKind())
                     {
                         // use modified color primitive to force textures to gray
-                        const ::basegfx::BColorModifier aBColorModifier(::basegfx::BColor(), 0.0, ::basegfx::BCOLORMODIFYMODE_GRAY);
-                        basePrimitive* pModifiedColor = new modifiedColorPrimitive(aNewPrimitiveVector, aBColorModifier);
+                        const basegfx::BColorModifier aBColorModifier(basegfx::BColor(), 0.0, basegfx::BCOLORMODIFYMODE_GRAY);
+                        basePrimitive3D* pModifiedColor = new modifiedColorPrimitive3D(aNewPrimitiveVector, aBColorModifier);
                         aNewPrimitiveVector.clear();
-                        aNewPrimitiveVector.push_back(referencedPrimitive(*pModifiedColor));
+                        aNewPrimitiveVector.push_back(referencedPrimitive3D(*pModifiedColor));
                     }
                 }
 
                 if(0.0 != rFill.getTransparence())
                 {
                     // create simpleTransparenceTexturePrimitive3D with sublist and append
-                    basePrimitive* pNewSimpleTransparenceTexturePrimitive3D = new simpleTransparenceTexturePrimitive3D(rFill.getTransparence(), aNewPrimitiveVector);
-                    rTarget.push_back(referencedPrimitive(*pNewSimpleTransparenceTexturePrimitive3D));
+                    basePrimitive3D* pNewSimpleTransparenceTexturePrimitive3D = new simpleTransparenceTexturePrimitive3D(rFill.getTransparence(), aNewPrimitiveVector);
+                    rTarget.push_back(referencedPrimitive3D(*pNewSimpleTransparenceTexturePrimitive3D));
                 }
                 else if(pFillGradient)
                 {
                     // create transparenceTexture3D with sublist and append
-                    basePrimitive* pNewTransparenceTexturePrimitive3D = new transparenceTexturePrimitive3D(*pFillGradient, aNewPrimitiveVector, rTextureSize);
-                    rTarget.push_back(referencedPrimitive(*pNewTransparenceTexturePrimitive3D));
+                    basePrimitive3D* pNewTransparenceTexturePrimitive3D = new transparenceTexturePrimitive3D(*pFillGradient, aNewPrimitiveVector, rTextureSize);
+                    rTarget.push_back(referencedPrimitive3D(*pNewTransparenceTexturePrimitive3D));
                 }
                 else
                 {
@@ -245,29 +249,28 @@ namespace drawinglayer
         }
 
         void addShadowPrimitive3D(
-            primitiveVector& rTarget,
-            const sdrShadowAttribute& rShadow,
+            primitiveVector3D& rTarget,
+            const attribute::sdrShadowAttribute& rShadow,
             bool bShadow3D)
         {
             // create Shadow primitives. Need to be added in front, should use already created primitives
-            if(rTarget.size() && !::basegfx::fTools::moreOrEqual(rShadow.getTransparence(), 1.0))
+            if(rTarget.size() && !basegfx::fTools::moreOrEqual(rShadow.getTransparence(), 1.0))
             {
                 // prepare new list for shadow geometry
-                primitiveVector aNewList;
+                primitiveVector3D aNewList;
 
                 // prepare shadow offset
-                ::basegfx::B2DHomMatrix aShadowOffset;
+                basegfx::B2DHomMatrix   aShadowOffset;
                 aShadowOffset.set(0, 2, rShadow.getOffset().getX());
                 aShadowOffset.set(1, 2, rShadow.getOffset().getY());
 
                 // create shadow primitive and add primitives
-                primitiveVector aShadowPrimitiveVector(rTarget);
-                shadowPrimitive3D* pNewShadow3D = new shadowPrimitive3D(aShadowOffset, rShadow.getColor(), rShadow.getTransparence(), bShadow3D, aShadowPrimitiveVector);
+                shadowPrimitive3D* pNewShadow3D = new shadowPrimitive3D(aShadowOffset, rShadow.getColor(), rShadow.getTransparence(), bShadow3D, rTarget);
                 rTarget.clear();
-                rTarget.push_back(referencedPrimitive(*pNewShadow3D));
+                rTarget.push_back(referencedPrimitive3D(*pNewShadow3D));
             }
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx b/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx
index 4cfb233c2b18..574e2c5ea982 100644
--- a/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrextrudelathetools3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-05-19 09:34:54 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -91,15 +91,15 @@ namespace
     //////////////////////////////////////////////////////////////////////////////
     // common helpers
 
-    ::basegfx::B2DPolyPolygon impScalePolyPolygonOnCenter(const ::basegfx::B2DPolyPolygon& rSource, double fScale)
+    basegfx::B2DPolyPolygon impScalePolyPolygonOnCenter(const basegfx::B2DPolyPolygon& rSource, double fScale)
     {
-        ::basegfx::B2DPolyPolygon aRetval(rSource);
+        basegfx::B2DPolyPolygon aRetval(rSource);
 
-        if(!::basegfx::fTools::equalZero(fScale))
+        if(!basegfx::fTools::equalZero(fScale))
         {
-            const ::basegfx::B2DRange aRange(::basegfx::tools::getRange(rSource));
-            const ::basegfx::B2DPoint aCenter(aRange.getCenter());
-            ::basegfx::B2DHomMatrix aTrans;
+            const basegfx::B2DRange aRange(basegfx::tools::getRange(rSource));
+            const basegfx::B2DPoint aCenter(aRange.getCenter());
+            basegfx::B2DHomMatrix aTrans;
 
             aTrans.translate(-aCenter.getX(), -aCenter.getY());
             aTrans.scale(fScale, fScale);
@@ -110,23 +110,23 @@ namespace
         return aRetval;
     }
 
-    void impGetOuterPolyPolygon(::basegfx::B2DPolyPolygon& rPolygon, ::basegfx::B2DPolyPolygon& rOuterPolyPolygon, double fOffset, bool bCharacterMode)
+    void impGetOuterPolyPolygon(basegfx::B2DPolyPolygon& rPolygon, basegfx::B2DPolyPolygon& rOuterPolyPolygon, double fOffset, bool bCharacterMode)
     {
         rOuterPolyPolygon = rPolygon;
 
-        if(::basegfx::fTools::more(fOffset, 0.0))
+        if(basegfx::fTools::more(fOffset, 0.0))
         {
             if(bCharacterMode)
             {
                 // grow the outside polygon and scale all polygons to original size. This is done
                 // to avoid a shrink which potentially would lead to self-intersections, but changes
                 // the original polygon -> not a precision step, so e.g. not usable for charts
-                const ::basegfx::B2DRange aRange(::basegfx::tools::getRange(rPolygon));
-                rPolygon = ::basegfx::tools::growInNormalDirection(rPolygon, fOffset);
-                const ::basegfx::B2DRange aGrownRange(::basegfx::tools::getRange(rPolygon));
-                const double fScaleX(::basegfx::fTools::equalZero(aGrownRange.getWidth()) ? 1.0 : aRange.getWidth() / aGrownRange.getWidth());
-                const double fScaleY(::basegfx::fTools::equalZero(aGrownRange.getHeight())? 1.0 : aRange.getHeight() / aGrownRange.getHeight());
-                ::basegfx::B2DHomMatrix aScaleTrans;
+                const basegfx::B2DRange aRange(basegfx::tools::getRange(rPolygon));
+                rPolygon = basegfx::tools::growInNormalDirection(rPolygon, fOffset);
+                const basegfx::B2DRange aGrownRange(basegfx::tools::getRange(rPolygon));
+                const double fScaleX(basegfx::fTools::equalZero(aGrownRange.getWidth()) ? 1.0 : aRange.getWidth() / aGrownRange.getWidth());
+                const double fScaleY(basegfx::fTools::equalZero(aGrownRange.getHeight())? 1.0 : aRange.getHeight() / aGrownRange.getHeight());
+                basegfx::B2DHomMatrix aScaleTrans;
 
                 aScaleTrans.translate(-aGrownRange.getMinX(), -aGrownRange.getMinY());
                 aScaleTrans.scale(fScaleX, fScaleY);
@@ -138,13 +138,13 @@ namespace
             {
                 // use more precision, shrink the outer polygons. Since this may lead to self-intersections,
                 // some kind of correction should be applied here after that step
-                rOuterPolyPolygon = ::basegfx::tools::growInNormalDirection(rPolygon, -fOffset);
-                ::basegfx::tools::correctGrowShrinkPolygonPair(rPolygon, rOuterPolyPolygon);
+                rOuterPolyPolygon = basegfx::tools::growInNormalDirection(rPolygon, -fOffset);
+                basegfx::tools::correctGrowShrinkPolygonPair(rPolygon, rOuterPolyPolygon);
             }
         }
     }
 
-    void impAddInBetweenFill(::basegfx::B3DPolyPolygon& rTarget, const ::basegfx::B3DPolyPolygon& rPolA, const ::basegfx::B3DPolyPolygon& rPolB,
+    void impAddInBetweenFill(basegfx::B3DPolyPolygon& rTarget, const basegfx::B3DPolyPolygon& rPolA, const basegfx::B3DPolyPolygon& rPolB,
         double fTexVerStart, double fTexVerStop, bool bCreateNormals, bool bCreateTextureCoordinates)
     {
         OSL_ENSURE(rPolA.count() == rPolB.count(), "impAddInBetweenFill: unequally sized polygons (!)");
@@ -152,8 +152,8 @@ namespace
 
         for(sal_uInt32 a(0L); a < nPolygonCount; a++)
         {
-            const ::basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
-            const ::basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
+            const basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
+            const basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
             OSL_ENSURE(aSubA.count() == aSubB.count(), "impAddInBetweenFill: unequally sized polygons (!)");
             const sal_uInt32 nPointCount(aSubA.count());
 
@@ -165,11 +165,11 @@ namespace
 
                 if(bCreateTextureCoordinates)
                 {
-                    const double fPolygonLengthA(::basegfx::tools::getLength(aSubA));
-                    fTexHorMultiplicatorA = ::basegfx::fTools::equalZero(fPolygonLengthA) ? 1.0 : 1.0 / fPolygonLengthA;
+                    const double fPolygonLengthA(basegfx::tools::getLength(aSubA));
+                    fTexHorMultiplicatorA = basegfx::fTools::equalZero(fPolygonLengthA) ? 1.0 : 1.0 / fPolygonLengthA;
 
-                    const double fPolygonLengthB(::basegfx::tools::getLength(aSubB));
-                    fTexHorMultiplicatorB = ::basegfx::fTools::equalZero(fPolygonLengthB) ? 1.0 : 1.0 / fPolygonLengthB;
+                    const double fPolygonLengthB(basegfx::tools::getLength(aSubB));
+                    fTexHorMultiplicatorB = basegfx::fTools::equalZero(fPolygonLengthB) ? 1.0 : 1.0 / fPolygonLengthB;
 
                     fPolygonPosA = fPolygonPosB = 0.0;
                 }
@@ -179,12 +179,12 @@ namespace
                     const sal_uInt32 nIndexA(b);
                     const sal_uInt32 nIndexB((b + 1L) % nPointCount);
 
-                    const ::basegfx::B3DPoint aStartA(aSubA.getB3DPoint(nIndexA));
-                    const ::basegfx::B3DPoint aEndA(aSubA.getB3DPoint(nIndexB));
-                    const ::basegfx::B3DPoint aStartB(aSubB.getB3DPoint(nIndexA));
-                    const ::basegfx::B3DPoint aEndB(aSubB.getB3DPoint(nIndexB));
+                    const basegfx::B3DPoint aStartA(aSubA.getB3DPoint(nIndexA));
+                    const basegfx::B3DPoint aEndA(aSubA.getB3DPoint(nIndexB));
+                    const basegfx::B3DPoint aStartB(aSubB.getB3DPoint(nIndexA));
+                    const basegfx::B3DPoint aEndB(aSubB.getB3DPoint(nIndexB));
 
-                    ::basegfx::B3DPolygon aNew;
+                    basegfx::B3DPolygon aNew;
                     aNew.setClosed(true);
 
                     aNew.append(aStartA);
@@ -203,19 +203,19 @@ namespace
                     if(bCreateTextureCoordinates)
                     {
                         const double fRelTexAL(fPolygonPosA * fTexHorMultiplicatorA);
-                        const double fEdgeLengthA(::basegfx::B3DVector(aEndA - aStartA).getLength());
+                        const double fEdgeLengthA(basegfx::B3DVector(aEndA - aStartA).getLength());
                         fPolygonPosA += fEdgeLengthA;
                         const double fRelTexAR(fPolygonPosA * fTexHorMultiplicatorA);
 
                         const double fRelTexBL(fPolygonPosB * fTexHorMultiplicatorB);
-                        const double fEdgeLengthB(::basegfx::B3DVector(aEndB - aStartB).getLength());
+                        const double fEdgeLengthB(basegfx::B3DVector(aEndB - aStartB).getLength());
                         fPolygonPosB += fEdgeLengthB;
                         const double fRelTexBR(fPolygonPosB * fTexHorMultiplicatorB);
 
-                        aNew.setTextureCoordinate(0L, ::basegfx::B2DPoint(fRelTexAL, fTexVerStart));
-                        aNew.setTextureCoordinate(1L, ::basegfx::B2DPoint(fRelTexBL, fTexVerStop));
-                        aNew.setTextureCoordinate(2L, ::basegfx::B2DPoint(fRelTexBR, fTexVerStop));
-                        aNew.setTextureCoordinate(3L, ::basegfx::B2DPoint(fRelTexAR, fTexVerStart));
+                        aNew.setTextureCoordinate(0L, basegfx::B2DPoint(fRelTexAL, fTexVerStart));
+                        aNew.setTextureCoordinate(1L, basegfx::B2DPoint(fRelTexBL, fTexVerStop));
+                        aNew.setTextureCoordinate(2L, basegfx::B2DPoint(fRelTexBR, fTexVerStop));
+                        aNew.setTextureCoordinate(3L, basegfx::B2DPoint(fRelTexAR, fTexVerStart));
                     }
 
                     rTarget.append(aNew);
@@ -224,11 +224,11 @@ namespace
         }
     }
 
-    void impSetNormal(::basegfx::B3DPolyPolygon& rCandidate, const ::basegfx::B3DVector& rNormal)
+    void impSetNormal(basegfx::B3DPolyPolygon& rCandidate, const basegfx::B3DVector& rNormal)
     {
         for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
         {
-            ::basegfx::B3DPolygon aSub(rCandidate.getB3DPolygon(a));
+            basegfx::B3DPolygon aSub(rCandidate.getB3DPolygon(a));
 
             for(sal_uInt32 b(0L); b < aSub.count(); b++)
             {
@@ -239,61 +239,61 @@ namespace
         }
     }
 
-    void impCreateInBetweenNormals(::basegfx::B3DPolyPolygon& rPolA, ::basegfx::B3DPolyPolygon& rPolB, bool bSmoothHorizontalNormals)
+    void impCreateInBetweenNormals(basegfx::B3DPolyPolygon& rPolA, basegfx::B3DPolyPolygon& rPolB, bool bSmoothHorizontalNormals)
     {
         OSL_ENSURE(rPolA.count() == rPolB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
 
         for(sal_uInt32 a(0L); a < rPolA.count(); a++)
         {
-            ::basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
-            ::basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
+            basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
+            basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
             OSL_ENSURE(aSubA.count() == aSubB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
             const sal_uInt32 nPointCount(aSubA.count());
 
             if(nPointCount)
             {
-                ::basegfx::B3DPoint aPrevA(aSubA.getB3DPoint(nPointCount - 1L));
-                ::basegfx::B3DPoint aCurrA(aSubA.getB3DPoint(0L));
+                basegfx::B3DPoint aPrevA(aSubA.getB3DPoint(nPointCount - 1L));
+                basegfx::B3DPoint aCurrA(aSubA.getB3DPoint(0L));
                 const bool bClosed(aSubA.isClosed());
 
                 for(sal_uInt32 b(0L); b < nPointCount; b++)
                 {
                     const sal_uInt32 nIndNext((b + 1L) % nPointCount);
-                    const ::basegfx::B3DPoint aNextA(aSubA.getB3DPoint(nIndNext));
-                    const ::basegfx::B3DPoint aCurrB(aSubB.getB3DPoint(b));
+                    const basegfx::B3DPoint aNextA(aSubA.getB3DPoint(nIndNext));
+                    const basegfx::B3DPoint aCurrB(aSubB.getB3DPoint(b));
 
                     // vector to back
-                    ::basegfx::B3DVector aDepth(aCurrB - aCurrA);
+                    basegfx::B3DVector aDepth(aCurrB - aCurrA);
                     aDepth.normalize();
 
                     if(aDepth.equalZero())
                     {
                         // no difference, try to get depth from next point
-                        const ::basegfx::B3DPoint aNextB(aSubB.getB3DPoint(nIndNext));
+                        const basegfx::B3DPoint aNextB(aSubB.getB3DPoint(nIndNext));
                         aDepth = aNextB - aNextA;
                         aDepth.normalize();
                     }
 
                     // vector to left (correct for non-closed lines)
                     const bool bFirstAndNotClosed(!bClosed && 0L == b);
-                    ::basegfx::B3DVector aLeft(bFirstAndNotClosed ? aCurrA - aNextA : aPrevA - aCurrA);
+                    basegfx::B3DVector aLeft(bFirstAndNotClosed ? aCurrA - aNextA : aPrevA - aCurrA);
                     aLeft.normalize();
 
                     // create left normal
-                    const ::basegfx::B3DVector aNormalLeft(aDepth.getPerpendicular(aLeft));
+                    const basegfx::B3DVector aNormalLeft(aDepth.getPerpendicular(aLeft));
 
                     if(bSmoothHorizontalNormals)
                     {
                         // vector to right (correct for non-closed lines)
                         const bool bLastAndNotClosed(!bClosed && b + 1L == nPointCount);
-                        ::basegfx::B3DVector aRight(bLastAndNotClosed ? aCurrA - aPrevA : aNextA - aCurrA);
+                        basegfx::B3DVector aRight(bLastAndNotClosed ? aCurrA - aPrevA : aNextA - aCurrA);
                         aRight.normalize();
 
                         // create right normal
-                        const ::basegfx::B3DVector aNormalRight(aRight.getPerpendicular(aDepth));
+                        const basegfx::B3DVector aNormalRight(aRight.getPerpendicular(aDepth));
 
                         // create smoothed in-between normal
-                        ::basegfx::B3DVector aNewNormal(aNormalLeft + aNormalRight);
+                        basegfx::B3DVector aNewNormal(aNormalLeft + aNormalRight);
                         aNewNormal.normalize();
 
                         // set as new normal at polygons
@@ -318,23 +318,23 @@ namespace
         }
     }
 
-    void impMixNormals(::basegfx::B3DPolyPolygon& rPolA, const ::basegfx::B3DPolyPolygon& rPolB, double fWeightA)
+    void impMixNormals(basegfx::B3DPolyPolygon& rPolA, const basegfx::B3DPolyPolygon& rPolB, double fWeightA)
     {
         const double fWeightB(1.0 - fWeightA);
         OSL_ENSURE(rPolA.count() == rPolB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
 
         for(sal_uInt32 a(0L); a < rPolA.count(); a++)
         {
-            ::basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
-            const ::basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
+            basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
+            const basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
             OSL_ENSURE(aSubA.count() == aSubB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
             const sal_uInt32 nPointCount(aSubA.count());
 
             for(sal_uInt32 b(0L); b < nPointCount; b++)
             {
-                const ::basegfx::B3DVector aVA(aSubA.getNormal(b) * fWeightA);
-                const ::basegfx::B3DVector aVB(aSubB.getNormal(b) * fWeightB);
-                ::basegfx::B3DVector aVNew(aVA + aVB);
+                const basegfx::B3DVector aVA(aSubA.getNormal(b) * fWeightA);
+                const basegfx::B3DVector aVB(aSubB.getNormal(b) * fWeightB);
+                basegfx::B3DVector aVNew(aVA + aVB);
                 aVNew.normalize();
                 aSubA.setNormal(b, aVNew);
             }
@@ -349,25 +349,25 @@ namespace
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        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)
         {
-            if(::basegfx::fTools::equalZero(fRotation) || 0L == nSteps)
+            if(basegfx::fTools::equalZero(fRotation) || 0L == nSteps)
             {
                 // no rotation or no steps, just one plane
-                rSliceVector.push_back(slice(rSource, ::basegfx::B3DHomMatrix()));
+                rSliceVector.push_back(slice(rSource, basegfx::B3DHomMatrix()));
             }
             else
             {
-                const bool bBackScale(!::basegfx::fTools::equal(fBackScale, 1.0));
-                const bool bClosedRotation(!bBackScale && ::basegfx::fTools::equal(fRotation, F_2PI));
-                ::basegfx::B2DPolyPolygon aFront(rSource);
-                ::basegfx::B2DPolyPolygon aBack(rSource);
-                ::basegfx::B3DHomMatrix aTransformBack;
-                ::basegfx::B2DPolyPolygon aOuterBack;
+                const bool bBackScale(!basegfx::fTools::equal(fBackScale, 1.0));
+                const bool bClosedRotation(!bBackScale && basegfx::fTools::equal(fRotation, F_2PI));
+                basegfx::B2DPolyPolygon aFront(rSource);
+                basegfx::B2DPolyPolygon aBack(rSource);
+                basegfx::B3DHomMatrix aTransformBack;
+                basegfx::B2DPolyPolygon aOuterBack;
 
                 if(bClosedRotation)
                 {
@@ -377,7 +377,7 @@ namespace drawinglayer
                 if(bBackScale)
                 {
                     // avoid null zoom
-                    if(::basegfx::fTools::equalZero(fBackScale))
+                    if(basegfx::fTools::equalZero(fBackScale))
                     {
                         fBackScale = 0.000001;
                     }
@@ -388,7 +388,7 @@ namespace drawinglayer
 
                 if(bCloseFront || bCloseBack)
                 {
-                    const ::basegfx::B2DRange aBaseRange(::basegfx::tools::getRange(aFront));
+                    const basegfx::B2DRange aBaseRange(basegfx::tools::getRange(aFront));
                     const double fOuterLength(aBaseRange.getMaxX() * fRotation);
                     const double fInnerLength(aBaseRange.getMinX() * fRotation);
                     const double fAverageLength((fOuterLength + fInnerLength) * 0.5);
@@ -396,9 +396,9 @@ namespace drawinglayer
                     if(bCloseFront)
                     {
                         const double fOffsetLen((fAverageLength / 12.0) * fDiagonal);
-                        ::basegfx::B2DPolyPolygon aOuterFront;
+                        basegfx::B2DPolyPolygon aOuterFront;
                         impGetOuterPolyPolygon(aFront, aOuterFront, fOffsetLen, bCharacterMode);
-                        ::basegfx::B3DHomMatrix aTransform;
+                        basegfx::B3DHomMatrix aTransform;
                         aTransform.translate(0.0, 0.0, fOffsetLen);
                         rSliceVector.push_back(slice(aOuterFront, aTransform, SLICETYPE_FRONTCAP));
                     }
@@ -415,7 +415,7 @@ namespace drawinglayer
                 // add start polygon (a = 0L)
                 if(!bClosedRotation)
                 {
-                    rSliceVector.push_back(slice(aFront, ::basegfx::B3DHomMatrix()));
+                    rSliceVector.push_back(slice(aFront, basegfx::B3DHomMatrix()));
                 }
 
                 // create segments (a + 1 .. nSteps)
@@ -424,8 +424,8 @@ namespace drawinglayer
                 for(sal_uInt32 a(0L); a < nSteps; a++)
                 {
                     const double fStep((double)(a + 1L) * fStepSize);
-                    ::basegfx::B2DPolyPolygon aNewPoly(bBackScale ? ::basegfx::tools::interpolate(aFront, aBack, fStep) : aFront);
-                    ::basegfx::B3DHomMatrix aNewMat;
+                    basegfx::B2DPolyPolygon aNewPoly(bBackScale ? basegfx::tools::interpolate(aFront, aBack, fStep) : aFront);
+                    basegfx::B3DHomMatrix aNewMat;
                     aNewMat.rotate(0.0, fRotation * fStep, 0.0);
                     rSliceVector.push_back(slice(aNewPoly, aNewMat));
                 }
@@ -437,29 +437,29 @@ namespace drawinglayer
             }
         }
 
-        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)
         {
-            if(::basegfx::fTools::equalZero(fDepth))
+            if(basegfx::fTools::equalZero(fDepth))
             {
                 // no depth, just one plane
-                rSliceVector.push_back(slice(rSource, ::basegfx::B3DHomMatrix()));
+                rSliceVector.push_back(slice(rSource, basegfx::B3DHomMatrix()));
             }
             else
             {
                 // there is depth, create Polygons for front,back and their default depth positions
-                ::basegfx::B2DPolyPolygon aFront(rSource);
-                ::basegfx::B2DPolyPolygon aBack(rSource);
-                const bool bBackScale(!::basegfx::fTools::equal(fBackScale, 1.0));
+                basegfx::B2DPolyPolygon aFront(rSource);
+                basegfx::B2DPolyPolygon aBack(rSource);
+                const bool bBackScale(!basegfx::fTools::equal(fBackScale, 1.0));
                 double fZFront(fDepth); // default depth for aFront
                 double fZBack(0.0); // default depth for aBack
-                ::basegfx::B2DPolyPolygon aOuterBack;
+                basegfx::B2DPolyPolygon aOuterBack;
 
                 if(bBackScale)
                 {
                     // avoid null zoom
-                    if(::basegfx::fTools::equalZero(fBackScale))
+                    if(basegfx::fTools::equalZero(fBackScale))
                     {
                         fBackScale = 0.000001;
                     }
@@ -472,9 +472,9 @@ namespace drawinglayer
                 {
                     const double fOffset(fDepth * fDiagonal * 0.5);
                     fZFront = fDepth - fOffset;
-                    ::basegfx::B2DPolyPolygon aOuterFront;
+                    basegfx::B2DPolyPolygon aOuterFront;
                     impGetOuterPolyPolygon(aFront, aOuterFront, fOffset, bCharacterMode);
-                    ::basegfx::B3DHomMatrix aTransformFront;
+                    basegfx::B3DHomMatrix aTransformFront;
                     aTransformFront.translate(0.0, 0.0, fDepth);
                     rSliceVector.push_back(slice(aOuterFront, aTransformFront, SLICETYPE_FRONTCAP));
                 }
@@ -488,7 +488,7 @@ namespace drawinglayer
 
                 // add front and back polygons at evtl. changed depths
                 {
-                    ::basegfx::B3DHomMatrix aTransformA, aTransformB;
+                    basegfx::B3DHomMatrix aTransformA, aTransformB;
 
                     aTransformA.translate(0.0, 0.0, fZFront);
                     rSliceVector.push_back(slice(aFront, aTransformA));
@@ -499,12 +499,12 @@ namespace drawinglayer
 
                 if(bCloseBack)
                 {
-                    rSliceVector.push_back(slice(aOuterBack, ::basegfx::B3DHomMatrix(), SLICETYPE_BACKCAP));
+                    rSliceVector.push_back(slice(aOuterBack, basegfx::B3DHomMatrix(), SLICETYPE_BACKCAP));
                 }
             }
         }
 
-        void extractLinesFromSlice(::basegfx::B3DPolyPolygon& rLine, const sliceVector& rSliceVector, bool bClosed)
+        void extractLinesFromSlice(basegfx::B3DPolyPolygon& rLine, const sliceVector& rSliceVector, bool bClosed)
         {
             const sal_uInt32 nNumSlices(rSliceVector.size());
 
@@ -517,17 +517,17 @@ namespace drawinglayer
                 }
 
                 // horizontal
-                const ::basegfx::B3DPolyPolygon& aFirstPolyPolygon(rSliceVector[0L].getB3DPolyPolygon());
+                const basegfx::B3DPolyPolygon& aFirstPolyPolygon(rSliceVector[0L].getB3DPolyPolygon());
                 const sal_uInt32 nPolygonCount(aFirstPolyPolygon.count());
 
                 for(sal_uInt32 b(0L); b < nPolygonCount; b++)
                 {
-                    const ::basegfx::B3DPolygon& aFirstPolygon(aFirstPolyPolygon.getB3DPolygon(0L));
+                    const basegfx::B3DPolygon& aFirstPolygon(aFirstPolyPolygon.getB3DPolygon(0L));
                     const sal_uInt32 nPointCount(aFirstPolygon.count());
 
                     for(sal_uInt32 c(0L); c < nPointCount; c++)
                     {
-                        ::basegfx::B3DPolygon aNew;
+                        basegfx::B3DPolygon aNew;
 
                         for(sal_uInt32 d(0L); d < nNumSlices; d++)
                         {
@@ -541,9 +541,9 @@ namespace drawinglayer
             }
         }
 
-        void extractPlanesFromSlice(::std::vector< ::basegfx::B3DPolyPolygon >& rFill, const sliceVector& rSliceVector,
+        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)
         {
             const sal_uInt32 nNumSlices(rSliceVector.size());
 
@@ -551,7 +551,7 @@ namespace drawinglayer
             {
                 // common parameters
                 const sal_uInt32 nLoopCount(bClosed ? nNumSlices : nNumSlices - 1L);
-                ::basegfx::B3DPolyPolygon aEdgeRounding;
+                basegfx::B3DPolyPolygon aEdgeRounding;
                 sal_uInt32 a;
 
                 // tetxture parameters
@@ -560,37 +560,37 @@ namespace drawinglayer
                 double fTexStart(0.0);
                 double fTexStop(1.0);
                 ::std::vector<double> aTexHeightArray;
-                ::basegfx::B3DRange aTexRangeFront;
-                ::basegfx::B3DRange aTexRangeBack;
+                basegfx::B3DRange aTexRangeFront;
+                basegfx::B3DRange aTexRangeBack;
 
                 if(bCreateTextureCoordinates)
                 {
-                    aTexRangeFront = ::basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon());
-                    aTexRangeBack = ::basegfx::tools::getRange(rSliceVector[nNumSlices - 1L].getB3DPolyPolygon());
+                    aTexRangeFront = basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon());
+                    aTexRangeBack = basegfx::tools::getRange(rSliceVector[nNumSlices - 1L].getB3DPolyPolygon());
 
                     if(aTexRangeBack.getDepth() > aTexRangeBack.getWidth())
                     {
                         // last polygon is rotated so that depth is bigger than width, exchange X and Z
                         // for making applyDefaultTextureCoordinatesParallel use Z instead of X for
                         // horizontal texture coordinate
-                        aTexRangeBack = ::basegfx::B3DRange(
+                        aTexRangeBack = basegfx::B3DRange(
                             aTexRangeBack.getMinZ(), aTexRangeBack.getMinY(), aTexRangeBack.getMinX(),
                             aTexRangeBack.getMaxZ(), aTexRangeBack.getMaxY(), aTexRangeBack.getMaxX());
                     }
 
-                    ::basegfx::B3DPoint aCenter(::basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon()).getCenter());
+                    basegfx::B3DPoint aCenter(basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon()).getCenter());
 
                     for(sal_uInt32 a(0L); a < nLoopCount; a++)
                     {
-                        const ::basegfx::B3DPoint aNextCenter(::basegfx::tools::getRange(rSliceVector[(a + 1L) % nNumSlices].getB3DPolyPolygon()).getCenter());
-                        const double fLength(::basegfx::B3DVector(aNextCenter - aCenter).getLength());
+                        const basegfx::B3DPoint aNextCenter(basegfx::tools::getRange(rSliceVector[(a + 1L) % nNumSlices].getB3DPolyPolygon()).getCenter());
+                        const double fLength(basegfx::B3DVector(aNextCenter - aCenter).getLength());
                         aTexHeightArray.push_back(fLength);
                         aCenter = aNextCenter;
                     }
 
                     const double fTexHeight(::std::accumulate(aTexHeightArray.begin(), aTexHeightArray.end(), 0.0));
 
-                    if(!::basegfx::fTools::equalZero(fTexHeight))
+                    if(!basegfx::fTools::equalZero(fTexHeight))
                     {
                         fInvTexHeight = 1.0 / fTexHeight;
                     }
@@ -601,8 +601,8 @@ namespace drawinglayer
                     const slice& rSliceA(rSliceVector[a]);
                     const slice& rSliceB(rSliceVector[(a + 1L) % nNumSlices]);
                     const bool bAcceptPair(SLICETYPE_REGULAR == rSliceA.getSliceType() && SLICETYPE_REGULAR == rSliceB.getSliceType());
-                    ::basegfx::B3DPolyPolygon aPolA(rSliceA.getB3DPolyPolygon());
-                    ::basegfx::B3DPolyPolygon aPolB(rSliceB.getB3DPolyPolygon());
+                    basegfx::B3DPolyPolygon aPolA(rSliceA.getB3DPolyPolygon());
+                    basegfx::B3DPolyPolygon aPolB(rSliceB.getB3DPolyPolygon());
 
                     if(bAcceptPair)
                     {
@@ -614,22 +614,22 @@ namespace drawinglayer
                         {
                             const sal_uInt32 nIndPrev((a + nNumSlices - 1L) % nNumSlices);
                             const slice& rSlicePrev(rSliceVector[nIndPrev]);
-                            ::basegfx::B3DPolyPolygon aPrev(rSlicePrev.getB3DPolyPolygon());
-                            ::basegfx::B3DPolyPolygon aPolAA(rSliceA.getB3DPolyPolygon());
+                            basegfx::B3DPolyPolygon aPrev(rSlicePrev.getB3DPolyPolygon());
+                            basegfx::B3DPolyPolygon aPolAA(rSliceA.getB3DPolyPolygon());
 
                             if(SLICETYPE_FRONTCAP == rSlicePrev.getSliceType())
                             {
-                                ::basegfx::B3DPolyPolygon aFront(rSlicePrev.getB3DPolyPolygon());
+                                basegfx::B3DPolyPolygon aFront(rSlicePrev.getB3DPolyPolygon());
                                 const bool bHasSlant(aPolAA != aPrev);
 
                                 if(bCreateTextureCoordinates)
                                 {
-                                    aFront = ::basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
+                                    aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
                                 }
 
                                 if(bCreateNormals)
                                 {
-                                    const ::basegfx::B3DVector aNormal(aFront.count() ? -aFront.getB3DPolygon(0L).getNormal() : ::basegfx::B3DVector(0.0, 0.0, -1.0));
+                                    const basegfx::B3DVector aNormal(aFront.count() ? -aFront.getB3DPolygon(0L).getNormal() : basegfx::B3DVector(0.0, 0.0, -1.0));
                                     impSetNormal(aFront, aNormal);
 
                                     if(bHasSlant)
@@ -704,22 +704,22 @@ namespace drawinglayer
                         {
                             const sal_uInt32 nIndNext((a + 2L) % nNumSlices);
                             const slice& rSliceNext(rSliceVector[nIndNext]);
-                            ::basegfx::B3DPolyPolygon aNext(rSliceNext.getB3DPolyPolygon());
-                            ::basegfx::B3DPolyPolygon aPolBB(rSliceB.getB3DPolyPolygon());
+                            basegfx::B3DPolyPolygon aNext(rSliceNext.getB3DPolyPolygon());
+                            basegfx::B3DPolyPolygon aPolBB(rSliceB.getB3DPolyPolygon());
 
                             if(SLICETYPE_BACKCAP == rSliceNext.getSliceType())
                             {
-                                ::basegfx::B3DPolyPolygon aBack(rSliceNext.getB3DPolyPolygon());
+                                basegfx::B3DPolyPolygon aBack(rSliceNext.getB3DPolyPolygon());
                                 const bool bHasSlant(aPolBB != aNext);
 
                                 if(bCreateTextureCoordinates)
                                 {
-                                    aBack = ::basegfx::tools::applyDefaultTextureCoordinatesParallel(aBack, aTexRangeBack);
+                                    aBack = basegfx::tools::applyDefaultTextureCoordinatesParallel(aBack, aTexRangeBack);
                                 }
 
                                 if(bCreateNormals)
                                 {
-                                    const ::basegfx::B3DVector aNormal(aBack.count() ? aBack.getB3DPolygon(0L).getNormal() : ::basegfx::B3DVector(0.0, 0.0, 1.0));
+                                    const basegfx::B3DVector aNormal(aBack.count() ? aBack.getB3DPolygon(0L).getNormal() : basegfx::B3DVector(0.0, 0.0, 1.0));
                                     impSetNormal(aBack, aNormal);
 
                                     if(bHasSlant)
@@ -812,12 +812,12 @@ namespace drawinglayer
 
                 for(a = 0L; a < aEdgeRounding.count(); a++)
                 {
-                    rFill.push_back(::basegfx::B3DPolyPolygon(aEdgeRounding.getB3DPolygon(a)));
+                    rFill.push_back(basegfx::B3DPolyPolygon(aEdgeRounding.getB3DPolygon(a)));
                 }
             }
         }
 
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx
index 764b0c30d650..117274b3ca42 100644
--- a/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrextrudeprimitive3d.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -69,9 +69,9 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void sdrExtrudePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void sdrExtrudePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             // get slices
             const sliceVector& rSliceVector = getSlices();
@@ -82,22 +82,22 @@ namespace drawinglayer
                 if(getSdrLFSAttribute().getFill())
                 {
                     sal_uInt32 a;
-                    ::basegfx::B3DRange aRange;
+                    basegfx::B3DRange aRange;
 
                     // decide what to create
                     const bool bCreateNormals(::com::sun::star::drawing::NormalsKind_SPECIFIC == getSdr3DObjectAttribute().getNormalsKind());
                     const bool bCreateTextureCoordiantesX(::com::sun::star::drawing::TextureProjectionMode_OBJECTSPECIFIC == getSdr3DObjectAttribute().getTextureProjectionX());
                     const bool bCreateTextureCoordiantesY(::com::sun::star::drawing::TextureProjectionMode_OBJECTSPECIFIC == getSdr3DObjectAttribute().getTextureProjectionY());
                     double fRelativeTextureWidth(1.0);
-                    ::basegfx::B2DHomMatrix aTexTransform;
+                    basegfx::B2DHomMatrix aTexTransform;
 
                     if(bCreateTextureCoordiantesX || bCreateTextureCoordiantesY)
                     {
-                        const ::basegfx::B2DPolygon aFirstPolygon(maCorrectedPolyPolygon.getB2DPolygon(0L));
-                        const double fFrontLength(::basegfx::tools::getLength(aFirstPolygon));
-                        const double fFrontArea(::basegfx::tools::getArea(aFirstPolygon));
+                        const basegfx::B2DPolygon aFirstPolygon(maCorrectedPolyPolygon.getB2DPolygon(0L));
+                        const double fFrontLength(basegfx::tools::getLength(aFirstPolygon));
+                        const double fFrontArea(basegfx::tools::getArea(aFirstPolygon));
                         const double fSqrtFrontArea(sqrt(fFrontArea));
-                        fRelativeTextureWidth = ::basegfx::fTools::equalZero(fSqrtFrontArea) ? 1.0 : fFrontLength / fSqrtFrontArea;
+                        fRelativeTextureWidth = basegfx::fTools::equalZero(fSqrtFrontArea) ? 1.0 : fFrontLength / fSqrtFrontArea;
                         fRelativeTextureWidth = (double)((sal_uInt32)(fRelativeTextureWidth - 0.5));
 
                         if(fRelativeTextureWidth < 1.0)
@@ -112,7 +112,7 @@ namespace drawinglayer
                     }
 
                     // create geometry
-                    ::std::vector< ::basegfx::B3DPolyPolygon > aFill;
+                    ::std::vector< basegfx::B3DPolyPolygon > aFill;
                     extractPlanesFromSlice(aFill, rSliceVector,
                         bCreateNormals, mbSmoothHorizontalNormals, mbSmoothNormals, mbSmoothLids, false,
                         0.5, 0.6, bCreateTextureCoordiantesX || bCreateTextureCoordiantesY, aTexTransform);
@@ -120,7 +120,7 @@ namespace drawinglayer
                     // get full range
                     for(a = 0L; a < aFill.size(); a++)
                     {
-                        aRange.expand(::basegfx::tools::getRange(aFill[a]));
+                        aRange.expand(basegfx::tools::getRange(aFill[a]));
                     }
 
                     // normal creation
@@ -128,11 +128,11 @@ namespace drawinglayer
                         if(::com::sun::star::drawing::NormalsKind_SPHERE == getSdr3DObjectAttribute().getNormalsKind())
                         {
                             // create sphere normals
-                            const ::basegfx::B3DPoint aCenter(aRange.getCenter());
+                            const basegfx::B3DPoint aCenter(aRange.getCenter());
 
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::applyDefaultNormalsSphere(aFill[a], aCenter);
+                                aFill[a] = basegfx::tools::applyDefaultNormalsSphere(aFill[a], aCenter);
                             }
                         }
                         else if(::com::sun::star::drawing::NormalsKind_FLAT == getSdr3DObjectAttribute().getNormalsKind())
@@ -148,7 +148,7 @@ namespace drawinglayer
                             // invert normals
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::invertNormals(aFill[a]);
+                                aFill[a] = basegfx::tools::invertNormals(aFill[a]);
                             }
                         }
                     }
@@ -169,23 +169,23 @@ namespace drawinglayer
 
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill[a], aRange, bParallelX, bParallelY);
+                                aFill[a] = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill[a], aRange, bParallelX, bParallelY);
                             }
                         }
 
                         if(bSphereX || bSphereY)
                         {
                             // apply spherical texture coordinates in X and/or Y
-                            const ::basegfx::B3DPoint aCenter(aRange.getCenter());
+                            const basegfx::B3DPoint aCenter(aRange.getCenter());
 
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill[a], aCenter, bSphereX, bSphereY);
+                                aFill[a] = basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill[a], aCenter, bSphereX, bSphereY);
                             }
                         }
 
                         // transform texture coordinates to texture size
-                        ::basegfx::B2DHomMatrix aTexMatrix;
+                        basegfx::B2DHomMatrix aTexMatrix;
                         aTexMatrix.scale(maTextureSize.getX(), maTextureSize.getY());
 
                         for(a = 0L; a < aFill.size(); a++)
@@ -204,7 +204,7 @@ namespace drawinglayer
                 // add line
                 if(getSdrLFSAttribute().getLine())
                 {
-                    ::basegfx::B3DPolyPolygon aLine;
+                    basegfx::B3DPolyPolygon aLine;
                     extractLinesFromSlice(aLine, rSliceVector, false);
                     add3DPolyPolygonLinePrimitive(aLine, maTransform, rTarget, *maSdrLFSAttribute.getLine());
                 }
@@ -223,8 +223,8 @@ namespace drawinglayer
 
             // prepare the polygon
             maCorrectedPolyPolygon.removeDoublePoints();
-            maCorrectedPolyPolygon = ::basegfx::tools::correctOrientations(maCorrectedPolyPolygon);
-            maCorrectedPolyPolygon = ::basegfx::tools::correctOutmostPolygon(maCorrectedPolyPolygon);
+            maCorrectedPolyPolygon = basegfx::tools::correctOrientations(maCorrectedPolyPolygon);
+            maCorrectedPolyPolygon = basegfx::tools::correctOutmostPolygon(maCorrectedPolyPolygon);
 
             // prepare slices as geometry
             createExtrudeSlices(maSlices, maCorrectedPolyPolygon, mfBackScale, mfDiagonal, mfDepth, mbCharacterMode, mbCloseFront, mbCloseBack);
@@ -242,11 +242,11 @@ namespace drawinglayer
         }
 
         sdrExtrudePrimitive3D::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,
@@ -269,17 +269,17 @@ namespace drawinglayer
             mbCloseBack(bCloseBack)
         {
             // make sure depth is positive
-            if(::basegfx::fTools::lessOrEqual(mfDepth, 0.0))
+            if(basegfx::fTools::lessOrEqual(mfDepth, 0.0))
             {
                 mfDepth = 0.0;
             }
 
             // make sure the percentage value mfDiagonal is between 0.0 and 1.0
-            if(::basegfx::fTools::lessOrEqual(mfDiagonal, 0.0))
+            if(basegfx::fTools::lessOrEqual(mfDiagonal, 0.0))
             {
                 mfDiagonal = 0.0;
             }
-            else if(::basegfx::fTools::moreOrEqual(mfDiagonal, 1.0))
+            else if(basegfx::fTools::moreOrEqual(mfDiagonal, 1.0))
             {
                 mfDiagonal = 1.0;
             }
@@ -301,7 +301,7 @@ namespace drawinglayer
         {
         }
 
-        bool sdrExtrudePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool sdrExtrudePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(sdrPrimitive3D::operator==(rPrimitive))
             {
@@ -326,7 +326,7 @@ namespace drawinglayer
             return CreatePrimitiveID('S', 'X', 'T', '3');
         }
 
-        ::basegfx::B3DRange sdrExtrudePrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange sdrExtrudePrimitive3D::get3DRange() const
         {
             // use defaut from sdrPrimitive3D which uses transformation expanded by line width/2
             // The parent implementation which uses the ranges of the decomposition would be more
@@ -334,9 +334,9 @@ namespace drawinglayer
             // the range of the non-transformed geometry and transform it then. This leads to different
             // ranges where the new method is more correct, but the need to keep the old behaviour
             // has priority here.
-            return get3DRangeFromSlices(getSlices(), rViewInformation);
+            return get3DRangeFromSlices(getSlices());
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx
index 0a1bc369001d..5ef59dbeedec 100644
--- a/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrlatheprimitive3d.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:02 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -65,29 +65,29 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void sdrLathePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void sdrLathePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             // get slices
             const sliceVector& rSliceVector = getSlices();
 
             if(rSliceVector.size())
             {
-                const bool bBackScale(!::basegfx::fTools::equal(mfBackScale, 1.0));
-                const bool bClosedRotation(!bBackScale && mnHorizontalSegments && ::basegfx::fTools::equal(mfRotation, F_2PI));
+                const bool bBackScale(!basegfx::fTools::equal(mfBackScale, 1.0));
+                const bool bClosedRotation(!bBackScale && mnHorizontalSegments && basegfx::fTools::equal(mfRotation, F_2PI));
 
                 // add fill
                 if(getSdrLFSAttribute().getFill())
                 {
                     sal_uInt32 a;
-                    ::basegfx::B3DRange aRange;
+                    basegfx::B3DRange aRange;
 
                     // decide what to create
                     const bool bCreateNormals(::com::sun::star::drawing::NormalsKind_SPECIFIC == getSdr3DObjectAttribute().getNormalsKind());
                     const bool bCreateTextureCoordiantesX(::com::sun::star::drawing::TextureProjectionMode_OBJECTSPECIFIC == getSdr3DObjectAttribute().getTextureProjectionX());
                     const bool bCreateTextureCoordiantesY(::com::sun::star::drawing::TextureProjectionMode_OBJECTSPECIFIC == getSdr3DObjectAttribute().getTextureProjectionY());
-                    ::basegfx::B2DHomMatrix aTexTransform;
+                    basegfx::B2DHomMatrix aTexTransform;
 
                     if(bCreateTextureCoordiantesX || bCreateTextureCoordiantesY)
                     {
@@ -102,7 +102,7 @@ namespace drawinglayer
                     }
 
                     // create geometry
-                    ::std::vector< ::basegfx::B3DPolyPolygon > aFill;
+                    ::std::vector< basegfx::B3DPolyPolygon > aFill;
                     extractPlanesFromSlice(aFill, rSliceVector,
                         bCreateNormals, mbSmoothHorizontalNormals, mbSmoothNormals, mbSmoothLids, bClosedRotation,
                         0.85, 0.6, bCreateTextureCoordiantesX || bCreateTextureCoordiantesY, aTexTransform);
@@ -110,7 +110,7 @@ namespace drawinglayer
                     // get full range
                     for(a = 0L; a < aFill.size(); a++)
                     {
-                        aRange.expand(::basegfx::tools::getRange(aFill[a]));
+                        aRange.expand(basegfx::tools::getRange(aFill[a]));
                     }
 
                     // normal creation
@@ -118,11 +118,11 @@ namespace drawinglayer
                         if(::com::sun::star::drawing::NormalsKind_SPHERE == getSdr3DObjectAttribute().getNormalsKind())
                         {
                             // create sphere normals
-                            const ::basegfx::B3DPoint aCenter(aRange.getCenter());
+                            const basegfx::B3DPoint aCenter(aRange.getCenter());
 
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::applyDefaultNormalsSphere(aFill[a], aCenter);
+                                aFill[a] = basegfx::tools::applyDefaultNormalsSphere(aFill[a], aCenter);
                             }
                         }
                         else if(::com::sun::star::drawing::NormalsKind_FLAT == getSdr3DObjectAttribute().getNormalsKind())
@@ -138,7 +138,7 @@ namespace drawinglayer
                             // invert normals
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::invertNormals(aFill[a]);
+                                aFill[a] = basegfx::tools::invertNormals(aFill[a]);
                             }
                         }
                     }
@@ -159,23 +159,23 @@ namespace drawinglayer
 
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill[a], aRange, bParallelX, bParallelY);
+                                aFill[a] = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill[a], aRange, bParallelX, bParallelY);
                             }
                         }
 
                         if(bSphereX || bSphereY)
                         {
                             // apply spherical texture coordinates in X and/or Y
-                            const ::basegfx::B3DPoint aCenter(aRange.getCenter());
+                            const basegfx::B3DPoint aCenter(aRange.getCenter());
 
                             for(a = 0L; a < aFill.size(); a++)
                             {
-                                aFill[a] = ::basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill[a], aCenter, bSphereX, bSphereY);
+                                aFill[a] = basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill[a], aCenter, bSphereX, bSphereY);
                             }
                         }
 
                         // transform texture coordinates to texture size
-                        ::basegfx::B2DHomMatrix aTexMatrix;
+                        basegfx::B2DHomMatrix aTexMatrix;
                         aTexMatrix.scale(maTextureSize.getX(), maTextureSize.getY());
 
                         for(a = 0L; a < aFill.size(); a++)
@@ -194,7 +194,7 @@ namespace drawinglayer
                 // add line
                 if(getSdrLFSAttribute().getLine())
                 {
-                    ::basegfx::B3DPolyPolygon aLine;
+                    basegfx::B3DPolyPolygon aLine;
                     extractLinesFromSlice(aLine, rSliceVector, bClosedRotation);
                     add3DPolyPolygonLinePrimitive(aLine, maTransform, rTarget, *maSdrLFSAttribute.getLine());
                 }
@@ -210,20 +210,20 @@ namespace drawinglayer
         void sdrLathePrimitive3D::impCreateSlices()
         {
             // prepare the polygon
-            ::basegfx::B2DPolyPolygon aCandidate(::basegfx::tools::adaptiveSubdivideByDistance(maPolyPolygon));
+            basegfx::B2DPolyPolygon aCandidate(basegfx::tools::adaptiveSubdivideByDistance(maPolyPolygon));
             aCandidate.removeDoublePoints();
-            aCandidate = ::basegfx::tools::correctOrientations(aCandidate);
-            aCandidate = ::basegfx::tools::correctOutmostPolygon(aCandidate);
+            aCandidate = basegfx::tools::correctOrientations(aCandidate);
+            aCandidate = basegfx::tools::correctOutmostPolygon(aCandidate);
 
             // check edge count of first sub-polygon. If different, reSegment polyPolygon. This ensures
             // that for polyPolygons, the subPolys 1..n only get reSegmented when polygon 0L is different
             // at all (and not always)
-            const ::basegfx::B2DPolygon aSubCandidate(aCandidate.getB2DPolygon(0L));
+            const basegfx::B2DPolygon aSubCandidate(aCandidate.getB2DPolygon(0L));
             const sal_uInt32 nSubEdgeCount(aSubCandidate.isClosed() ? aSubCandidate.count() : (aSubCandidate.count() ? aSubCandidate.count() - 1L : 0L));
 
             if(nSubEdgeCount != mnVerticalSegments)
             {
-                aCandidate = ::basegfx::tools::reSegmentPolyPolygon(aCandidate, mnVerticalSegments);
+                aCandidate = basegfx::tools::reSegmentPolyPolygon(aCandidate, mnVerticalSegments);
             }
 
             // prepare slices as geometry
@@ -242,11 +242,11 @@ namespace drawinglayer
         }
 
         sdrLathePrimitive3D::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,
@@ -273,17 +273,17 @@ namespace drawinglayer
             mbCloseBack(bCloseBack)
         {
             // make sure Rotation is positive
-            if(::basegfx::fTools::lessOrEqual(mfRotation, 0.0))
+            if(basegfx::fTools::lessOrEqual(mfRotation, 0.0))
             {
                 mfRotation = 0.0;
             }
 
             // make sure the percentage value mfDiagonal is between 0.0 and 1.0
-            if(::basegfx::fTools::lessOrEqual(mfDiagonal, 0.0))
+            if(basegfx::fTools::lessOrEqual(mfDiagonal, 0.0))
             {
                 mfDiagonal = 0.0;
             }
-            else if(::basegfx::fTools::moreOrEqual(mfDiagonal, 1.0))
+            else if(basegfx::fTools::moreOrEqual(mfDiagonal, 1.0))
             {
                 mfDiagonal = 1.0;
             }
@@ -305,7 +305,7 @@ namespace drawinglayer
         {
         }
 
-        bool sdrLathePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool sdrLathePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(sdrPrimitive3D::operator==(rPrimitive))
             {
@@ -332,7 +332,7 @@ namespace drawinglayer
             return CreatePrimitiveID('S', 'L', 'A', '3');
         }
 
-        ::basegfx::B3DRange sdrLathePrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange sdrLathePrimitive3D::get3DRange() const
         {
             // use defaut from sdrPrimitive3D which uses transformation expanded by line width/2
             // The parent implementation which uses the ranges of the decomposition would be more
@@ -340,9 +340,9 @@ namespace drawinglayer
             // the range of the non-transformed geometry and transform it then. This leads to different
             // ranges where the new method is more correct, but the need to keep the old behaviour
             // has priority here.
-            return get3DRangeFromSlices(getSlices(), rViewInformation);
+            return get3DRangeFromSlices(getSlices());
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrprimitive3d.cxx
index 7d3f481c4004..bc7f5a7878bc 100644
--- a/drawinglayer/source/primitive3d/sdrprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrprimitive3d.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:03 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:15 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -37,8 +37,8 @@
 #include <drawinglayer/primitive3d/sdrprimitive3d.hxx>
 #endif
 
-#ifndef _DRAWINGLAYER_PRIMITIVE_SDRATTRIBUTE_HXX
-#include <drawinglayer/primitive/sdrattribute.hxx>
+#ifndef _DRAWINGLAYER_ATTRIBUTE_SDRATTRIBUTE_HXX
+#include <drawinglayer/attribute/sdrattribute.hxx>
 #endif
 
 #ifndef _BGFX_POLYPOLYGON_B3DPOLYGONTOOLS_HXX
@@ -49,18 +49,18 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        ::basegfx::B3DRange sdrPrimitive3D::getStandard3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange sdrPrimitive3D::getStandard3DRange() const
         {
-            ::basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
+            basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
             aUnitRange.transform(getTransform());
 
             if(maSdrLFSAttribute.getLine())
             {
-                const sdrLineAttribute& rLine = *maSdrLFSAttribute.getLine();
+                const attribute::sdrLineAttribute& rLine = *maSdrLFSAttribute.getLine();
 
-                if(rLine.isVisible() && !::basegfx::fTools::equalZero(rLine.getWidth()))
+                if(rLine.isVisible() && !basegfx::fTools::equalZero(rLine.getWidth()))
                 {
                     // expand by hald LineWidth as tube radius
                     aUnitRange.grow(rLine.getWidth() / 2.0);
@@ -70,24 +70,24 @@ namespace drawinglayer
             return aUnitRange;
         }
 
-        ::basegfx::B3DRange sdrPrimitive3D::get3DRangeFromSlices(const sliceVector& rSlices, const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange sdrPrimitive3D::get3DRangeFromSlices(const sliceVector& rSlices) const
         {
-            ::basegfx::B3DRange aRetval;
+            basegfx::B3DRange aRetval;
 
             if(rSlices.size())
             {
                 for(sal_uInt32 a(0L); a < rSlices.size(); a++)
                 {
-                    aRetval.expand(::basegfx::tools::getRange(rSlices[a].getB3DPolyPolygon()));
+                    aRetval.expand(basegfx::tools::getRange(rSlices[a].getB3DPolyPolygon()));
                 }
 
                 aRetval.transform(getTransform());
 
                 if(maSdrLFSAttribute.getLine())
                 {
-                    const sdrLineAttribute& rLine = *maSdrLFSAttribute.getLine();
+                    const attribute::sdrLineAttribute& rLine = *maSdrLFSAttribute.getLine();
 
-                    if(rLine.isVisible() && !::basegfx::fTools::equalZero(rLine.getWidth()))
+                    if(rLine.isVisible() && !basegfx::fTools::equalZero(rLine.getWidth()))
                     {
                         // expand by hald LineWidth as tube radius
                         aRetval.grow(rLine.getWidth() / 2.0);
@@ -99,11 +99,12 @@ namespace drawinglayer
         }
 
         sdrPrimitive3D::sdrPrimitive3D(
-            const ::basegfx::B3DHomMatrix& rTransform,
-            const ::basegfx::B2DVector& rTextureSize,
-            const sdrLineFillShadowAttribute& rSdrLFSAttribute,
-            const sdr3DObjectAttribute& rSdr3DObjectAttribute)
-        :   maTransform(rTransform),
+            const basegfx::B3DHomMatrix& rTransform,
+            const basegfx::B2DVector& rTextureSize,
+            const attribute::sdrLineFillShadowAttribute& rSdrLFSAttribute,
+            const attribute::sdr3DObjectAttribute& rSdr3DObjectAttribute)
+        :   basePrimitive3D(),
+            maTransform(rTransform),
             maTextureSize(rTextureSize),
             maSdrLFSAttribute(rSdrLFSAttribute),
             maSdr3DObjectAttribute(rSdr3DObjectAttribute)
@@ -114,7 +115,7 @@ namespace drawinglayer
         {
         }
 
-        bool sdrPrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool sdrPrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(getID() == rPrimitive.getID())
             {
@@ -128,7 +129,7 @@ namespace drawinglayer
 
             return false;
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx
index 7f12d62b0835..66f31f67deb8 100644
--- a/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: sdrsphereprimitive3d.cxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:03 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:16 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -61,11 +61,11 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void sdrSpherePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void sdrSpherePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
-            const ::basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
+            const basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
 
             // add fill
             if(getSdrLFSAttribute().getFill())
@@ -74,14 +74,14 @@ namespace drawinglayer
                     || ::com::sun::star::drawing::NormalsKind_SPHERE == getSdr3DObjectAttribute().getNormalsKind());
 
                 // create unit geometry
-                ::basegfx::B3DPolyPolygon aFill(::basegfx::tools::createSphereFillPolyPolygonFromB3DRange(aUnitRange,
+                basegfx::B3DPolyPolygon aFill(basegfx::tools::createSphereFillPolyPolygonFromB3DRange(aUnitRange,
                     getHorizontalSegments(), getVerticalSegments(), bCreateNormals));
 
                 // normal inversion
                 if(bCreateNormals && getSdr3DObjectAttribute().getNormalsInvert() && aFill.areNormalsUsed())
                 {
                     // invert normals
-                    aFill = ::basegfx::tools::invertNormals(aFill);
+                    aFill = basegfx::tools::invertNormals(aFill);
                 }
 
                 // texture coordinates
@@ -99,8 +99,8 @@ namespace drawinglayer
                     if(bParallelX || bParallelY)
                     {
                         // apply parallel texture coordinates in X and/or Y
-                        const ::basegfx::B3DRange aRange(::basegfx::tools::getRange(aFill));
-                        aFill = ::basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
+                        const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
+                        aFill = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
                     }
 
                     if(bSphereX || bObjectSpecificX || bSphereY || bObjectSpecificY)
@@ -114,38 +114,38 @@ namespace drawinglayer
                             // create a old version from it by rotating to old state before applying
                             // the texture coordinates to emulate old behaviour
                             fRelativeAngle = F_2PI * ((double)((getHorizontalSegments() >> 1L)  - 1L) / (double)getHorizontalSegments());
-                            ::basegfx::B3DHomMatrix aRot;
+                            basegfx::B3DHomMatrix aRot;
                             aRot.rotate(0.0, fRelativeAngle, 0.0);
                             aFill.transform(aRot);
                         }
 
                         // apply spherical texture coordinates in X and/or Y
-                        const ::basegfx::B3DRange aRange(::basegfx::tools::getRange(aFill));
-                        const ::basegfx::B3DPoint aCenter(aRange.getCenter());
-                        aFill = ::basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill, aCenter,
+                        const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
+                        const basegfx::B3DPoint aCenter(aRange.getCenter());
+                        aFill = basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill, aCenter,
                             bSphereX || bObjectSpecificX, bSphereY || bObjectSpecificY);
 
                         if(bObjectSpecificX)
                         {
                             // rotate back again
-                            ::basegfx::B3DHomMatrix aRot;
+                            basegfx::B3DHomMatrix aRot;
                             aRot.rotate(0.0, -fRelativeAngle, 0.0);
                             aFill.transform(aRot);
                         }
                     }
 
                     // transform texture coordinates to texture size
-                    ::basegfx::B2DHomMatrix aTexMatrix;
+                    basegfx::B2DHomMatrix aTexMatrix;
                     aTexMatrix.scale(maTextureSize.getX(), maTextureSize.getY());
                     aFill.transformTextureCoordiantes(aTexMatrix);
                 }
 
                 // build vector of PolyPolygons
-                ::std::vector< ::basegfx::B3DPolyPolygon > a3DPolyPolygonVector;
+                ::std::vector< basegfx::B3DPolyPolygon > a3DPolyPolygonVector;
 
                 for(sal_uInt32 a(0L); a < aFill.count(); a++)
                 {
-                    a3DPolyPolygonVector.push_back(::basegfx::B3DPolyPolygon(aFill.getB3DPolygon(a)));
+                    a3DPolyPolygonVector.push_back(basegfx::B3DPolyPolygon(aFill.getB3DPolygon(a)));
                 }
 
                 // create single PolyPolygonFill primitives
@@ -158,7 +158,7 @@ namespace drawinglayer
             // add line
             if(maSdrLFSAttribute.getLine())
             {
-                ::basegfx::B3DPolyPolygon aSphere(::basegfx::tools::createSpherePolyPolygonFromB3DRange(aUnitRange, getHorizontalSegments(), getVerticalSegments()));
+                basegfx::B3DPolyPolygon aSphere(basegfx::tools::createSpherePolyPolygonFromB3DRange(aUnitRange, getHorizontalSegments(), getVerticalSegments()));
                 add3DPolyPolygonLinePrimitive(aSphere, maTransform, rTarget, *maSdrLFSAttribute.getLine());
             }
 
@@ -170,10 +170,10 @@ namespace drawinglayer
         }
 
         sdrSpherePrimitive3D::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)
         :   sdrPrimitive3D(rTransform, rTextureSize, rSdrLFSAttribute, rSdr3DObjectAttribute),
             mnHorizontalSegments(nHorizontalSegments),
@@ -185,7 +185,7 @@ namespace drawinglayer
         {
         }
 
-        bool sdrSpherePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool sdrSpherePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(sdrPrimitive3D::operator==(rPrimitive))
             {
@@ -202,7 +202,7 @@ namespace drawinglayer
             return CreatePrimitiveID('S', 'S', 'P', '3');
         }
 
-        ::basegfx::B3DRange sdrSpherePrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange sdrSpherePrimitive3D::get3DRange() const
         {
             // use defaut from sdrPrimitive3D which uses transformation expanded by line width/2
             // The parent implementation which uses the ranges of the decomposition would be more
@@ -210,9 +210,9 @@ namespace drawinglayer
             // the range of the non-transformed geometry and transform it then. This leads to different
             // ranges where the new method is more correct, but the need to keep the old behaviour
             // has priority here.
-            return getStandard3DRange(rViewInformation);
+            return getStandard3DRange();
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/shadowprimitive3d.cxx b/drawinglayer/source/primitive3d/shadowprimitive3d.cxx
index 1848fc897c48..f806265eefc2 100644
--- a/drawinglayer/source/primitive3d/shadowprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/shadowprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: shadowprimitive3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:03 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:16 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -41,12 +41,12 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         shadowPrimitive3D::shadowPrimitive3D(
-            const ::basegfx::B2DHomMatrix& rShadowTransform, const ::basegfx::BColor& rShadowColor,
-            double fShadowTransparence, bool bShadow3D, const primitiveVector& rPrimitiveVector)
-        :   vectorPrimitive(rPrimitiveVector),
+            const basegfx::B2DHomMatrix& rShadowTransform, const basegfx::BColor& rShadowColor,
+            double fShadowTransparence, bool bShadow3D, const primitiveVector3D& rPrimitiveVector)
+        :   vectorPrimitive3D(rPrimitiveVector),
             maShadowTransform(rShadowTransform),
             maShadowColor(rShadowColor),
             mfShadowTransparence(fShadowTransparence),
@@ -58,9 +58,9 @@ namespace drawinglayer
         {
         }
 
-        bool shadowPrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool shadowPrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
-            if(vectorPrimitive::operator==(rPrimitive))
+            if(vectorPrimitive3D::operator==(rPrimitive))
             {
                 const shadowPrimitive3D& rCompare = (shadowPrimitive3D&)rPrimitive;
                 return (maShadowTransform == rCompare.maShadowTransform
@@ -76,7 +76,7 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('S', 'H', 'D', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/textureprimitive3d.cxx b/drawinglayer/source/primitive3d/textureprimitive3d.cxx
index 135fcd5b4df3..a220c5c76ae4 100644
--- a/drawinglayer/source/primitive3d/textureprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/textureprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: textureprimitive3d.cxx,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 13:58:03 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:16 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -41,13 +41,13 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         texturePrimitive3D::texturePrimitive3D(
-            const primitiveVector& rPrimitiveVector,
-            const ::basegfx::B2DVector& rTextureSize,
+            const primitiveVector3D& rPrimitiveVector,
+            const basegfx::B2DVector& rTextureSize,
             bool bModulate, bool bFilter)
-        :   vectorPrimitive(rPrimitiveVector),
+        :   vectorPrimitive3D(rPrimitiveVector),
             maTextureSize(rTextureSize),
             mbModulate(bModulate),
             mbFilter(bFilter)
@@ -58,9 +58,9 @@ namespace drawinglayer
         {
         }
 
-        bool texturePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool texturePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
-            if(vectorPrimitive::operator==(rPrimitive))
+            if(vectorPrimitive3D::operator==(rPrimitive))
             {
                 const texturePrimitive3D& rCompare = (texturePrimitive3D&)rPrimitive;
                 return (mbModulate == rCompare.mbModulate && mbFilter == rCompare.mbFilter);
@@ -68,16 +68,16 @@ namespace drawinglayer
 
             return false;
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void simpleTransparenceTexturePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void simpleTransparenceTexturePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             if(0.0 == mfTransparence)
             {
@@ -87,10 +87,10 @@ namespace drawinglayer
             else if(mfTransparence > 0.0 && mfTransparence < 1.0)
             {
                 // create transparenceTexturePrimitive3D with fixed transparence as replacement
-                const ::basegfx::BColor aGray(mfTransparence, mfTransparence, mfTransparence);
-                const fillGradientAttribute aFillGradient(GRADIENTSTYLE_LINEAR, 0.0, 0.0, 0.0, 0.0, aGray, aGray, 1);
-                basePrimitive* pNewTransparenceTexturePrimitive3D = new transparenceTexturePrimitive3D(aFillGradient, maPrimitiveVector, maTextureSize);
-                rTarget.push_back(referencedPrimitive(*pNewTransparenceTexturePrimitive3D));
+                const basegfx::BColor aGray(mfTransparence, mfTransparence, mfTransparence);
+                const attribute::fillGradientAttribute aFillGradient(attribute::GRADIENTSTYLE_LINEAR, 0.0, 0.0, 0.0, 0.0, aGray, aGray, 1);
+                basePrimitive3D* pNewTransparenceTexturePrimitive3D = new transparenceTexturePrimitive3D(aFillGradient, maPrimitiveVector, maTextureSize);
+                rTarget.push_back(referencedPrimitive3D(*pNewTransparenceTexturePrimitive3D));
             }
             else
             {
@@ -100,8 +100,8 @@ namespace drawinglayer
 
         simpleTransparenceTexturePrimitive3D::simpleTransparenceTexturePrimitive3D(
             double fTransparence,
-            const primitiveVector& rPrimitiveVector)
-        :   texturePrimitive3D(rPrimitiveVector, ::basegfx::B2DVector(), false, false),
+            const primitiveVector3D& rPrimitiveVector)
+        :   texturePrimitive3D(rPrimitiveVector, basegfx::B2DVector(), false, false),
             mfTransparence(fTransparence)
         {
         }
@@ -110,7 +110,7 @@ namespace drawinglayer
         {
         }
 
-        bool simpleTransparenceTexturePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool simpleTransparenceTexturePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(texturePrimitive3D::operator==(rPrimitive))
             {
@@ -125,24 +125,24 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('S', 'T', 'X', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void gradientTexturePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void gradientTexturePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             rTarget.insert(rTarget.end(), maPrimitiveVector.begin(), maPrimitiveVector.end());
         }
 
         gradientTexturePrimitive3D::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)
         :   texturePrimitive3D(rPrimitiveVector, rTextureSize, bModulate, bFilter),
@@ -154,7 +154,7 @@ namespace drawinglayer
         {
         }
 
-        bool gradientTexturePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool gradientTexturePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(texturePrimitive3D::operator==(rPrimitive))
             {
@@ -169,24 +169,24 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('G', 'R', 'X', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        void bitmapTexturePrimitive3D::decompose(primitiveVector& rTarget, const ::drawinglayer::geometry::viewInformation& rViewInformation)
+        void bitmapTexturePrimitive3D::decompose(primitiveVector3D& rTarget)
         {
             rTarget.insert(rTarget.end(), maPrimitiveVector.begin(), maPrimitiveVector.end());
         }
 
         bitmapTexturePrimitive3D::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)
         :   texturePrimitive3D(rPrimitiveVector, rTextureSize, bModulate, bFilter),
             maBitmap(rBitmap)
@@ -197,7 +197,7 @@ namespace drawinglayer
         {
         }
 
-        bool bitmapTexturePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool bitmapTexturePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             if(texturePrimitive3D::operator==(rPrimitive))
             {
@@ -212,19 +212,19 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('B', 'M', 'X', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
         transparenceTexturePrimitive3D::transparenceTexturePrimitive3D(
-            const fillGradientAttribute& rGradient,
-            const primitiveVector& rPrimitiveVector,
-            const ::basegfx::B2DVector& rTextureSize)
+            const attribute::fillGradientAttribute& rGradient,
+            const primitiveVector3D& rPrimitiveVector,
+            const basegfx::B2DVector& rTextureSize)
         :   gradientTexturePrimitive3D(rGradient, rPrimitiveVector, rTextureSize, false, false)
         {
         }
@@ -233,7 +233,7 @@ namespace drawinglayer
         {
         }
 
-        bool transparenceTexturePrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool transparenceTexturePrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
             return (gradientTexturePrimitive3D::operator==(rPrimitive));
         }
@@ -242,7 +242,7 @@ namespace drawinglayer
         {
             return CreatePrimitiveID('T', 'R', 'X', '3');
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/drawinglayer/source/primitive3d/transformprimitive3d.cxx b/drawinglayer/source/primitive3d/transformprimitive3d.cxx
index 7464ea0187fc..22fafbcac2b2 100644
--- a/drawinglayer/source/primitive3d/transformprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/transformprimitive3d.cxx
@@ -4,9 +4,9 @@
  *
  *  $RCSfile: transformprimitive3d.cxx,v $
  *
- *  $Revision: 1.1 $
+ *  $Revision: 1.2 $
  *
- *  last change: $Author: aw $ $Date: 2006-06-02 14:12:39 $
+ *  last change: $Author: aw $ $Date: 2006-08-09 16:51:16 $
  *
  *  The Contents of this file are made available subject to
  *  the terms of GNU Lesser General Public License Version 2.1.
@@ -41,10 +41,10 @@
 
 namespace drawinglayer
 {
-    namespace primitive
+    namespace primitive3d
     {
-        transformPrimitive3D::transformPrimitive3D(const ::basegfx::B3DHomMatrix& rTransformation, const primitiveVector& rPrimitiveVector)
-        :   vectorPrimitive(rPrimitiveVector),
+        transformPrimitive3D::transformPrimitive3D(const basegfx::B3DHomMatrix& rTransformation, const primitiveVector3D& rPrimitiveVector)
+        :   vectorPrimitive3D(rPrimitiveVector),
             maTransformation(rTransformation)
         {
         }
@@ -53,9 +53,9 @@ namespace drawinglayer
         {
         }
 
-        bool transformPrimitive3D::operator==(const basePrimitive& rPrimitive) const
+        bool transformPrimitive3D::operator==(const basePrimitive3D& rPrimitive) const
         {
-            if(vectorPrimitive::operator==(rPrimitive))
+            if(vectorPrimitive3D::operator==(rPrimitive))
             {
                 const transformPrimitive3D& rCompare = static_cast< const transformPrimitive3D& >(rPrimitive);
                 return (maTransformation == rCompare.maTransformation);
@@ -69,13 +69,13 @@ namespace drawinglayer
             return CreatePrimitiveID('T', 'R', 'N', '3');
         }
 
-        ::basegfx::B3DRange transformPrimitive3D::get3DRange(const ::drawinglayer::geometry::viewInformation& rViewInformation) const
+        basegfx::B3DRange transformPrimitive3D::get3DRange() const
         {
-            ::basegfx::B3DRange aRetval(::drawinglayer::primitive::get3DRangeFromVector(maPrimitiveVector, rViewInformation));
+            basegfx::B3DRange aRetval(get3DRangeFromVector(maPrimitiveVector));
             aRetval.transform(maTransformation);
             return aRetval;
         }
-    } // end of namespace primitive
+    } // end of namespace primitive3d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////