Removed in-between namespaces (curve, matrix, numeric, point, polygon, range, tuple, vector). Names were too common and e.g. vector leaded to problems with some defines. This is now avoided. Also some bug fixes, addition of 3d polygon tooling etc.

4 files changed, 640 insertions, 658 deletions

diff --git a/basegfx/inc/basegfx/point/b2dhompoint.hxx b/basegfx/inc/basegfx/point/b2dhompoint.hxx
index 3b145bf4e444..911e61a884fd 100644
--- a/basegfx/inc/basegfx/point/b2dhompoint.hxx
+++ b/basegfx/inc/basegfx/point/b2dhompoint.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: b2dhompoint.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2003-11-06 16:30:23 $
+ *  last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -68,209 +68,206 @@
 
 namespace basegfx
 {
-    namespace point
+    /** Basic homogen Point class with two double values and one homogen factor
+
+        This class provides access to homogen coordinates in 2D.
+        For this purpose all the operators which need to do specific
+        action due to their homogenity are implemented here.
+        The only caveat are member methods which are declared as const
+        but do change the content. These are documented for that reason.
+        The class is designed to provide homogenous coordinates without
+        direct access to the homogen part (mfW). This is also the reason
+        for leaving out the [] operators which return references to members.
+
+        @see B2DTuple
+    */
+    class B2DHomPoint
     {
-        /** Basic homogen Point class with two double values and one homogen factor
-
-            This class provides access to homogen coordinates in 2D.
-            For this purpose all the operators which need to do specific
-            action due to their homogenity are implemented here.
-            The only caveat are member methods which are declared as const
-            but do change the content. These are documented for that reason.
-            The class is designed to provide homogenous coordinates without
-            direct access to the homogen part (mfW). This is also the reason
-            for leaving out the [] operators which return references to members.
-
-            @see B2DTuple
+    protected:
+        /// This member contains the coordinate part of the point
+        ::basegfx::B2DTuple                 maTuple;
+
+        /// This Member holds the homogenous part of the point
+        double                                      mfW;
+
+        /** Test if this homogen point does have a homogenous part
+
+            @return Returns sal_True if this point has no homogenous part
         */
-        class B2DHomPoint
-        {
-        protected:
-            /// This member contains the coordinate part of the point
-            ::basegfx::tuple::B2DTuple                  maTuple;
-
-            /// This Member holds the homogenous part of the point
-            double                                      mfW;
-
-            /** Test if this homogen point does have a homogenous part
-
-                @return Returns sal_True if this point has no homogenous part
-            */
-            sal_Bool implIsHomogenized() const;
-
-            /** Remove homogenous part of this Point
-
-                This method does necessary calculations to remove
-                the evtl. homogenous part of this Point. This may
-                change all members.
-            */
-            void implHomogenize();
+        sal_Bool implIsHomogenized() const;
 
-            /** Test and on demand remove homogenous part
-
-                This method tests if this Point does have a homogenous part
-                and then evtl. takes actions to remove that part.
-
-                @attention Even when this method is const it may change all
-                members of this instance. This is due to the fact that changing
-                the homogenous part of a homogenous point does from a mathematical
-                point of view not change the point at all.
-            */
-            void implTestAndHomogenize() const;
+        /** Remove homogenous part of this Point
+
+            This method does necessary calculations to remove
+            the evtl. homogenous part of this Point. This may
+            change all members.
+        */
+        void implHomogenize();
+
+        /** Test and on demand remove homogenous part
+
+            This method tests if this Point does have a homogenous part
+            and then evtl. takes actions to remove that part.
+
+            @attention Even when this method is const it may change all
+            members of this instance. This is due to the fact that changing
+            the homogenous part of a homogenous point does from a mathematical
+            point of view not change the point at all.
+        */
+        void implTestAndHomogenize() const;
 
-        public:
-            /** Create a homogen point
+    public:
+        /** Create a homogen point
 
-                @param fVal
-                This parameter is used to initialize the coordinate
-                part of the Point. The homogenous part is initialized to 1.0.
-            */
-            B2DHomPoint(double fVal = 0.0)
-            :   maTuple(fVal),
-                mfW(1.0)
-            {}
+            @param fVal
+            This parameter is used to initialize the coordinate
+            part of the Point. The homogenous part is initialized to 1.0.
+        */
+        B2DHomPoint(double fVal = 0.0)
+        :   maTuple(fVal),
+            mfW(1.0)
+        {}
 
-            /** Create a homogen point
+        /** Create a homogen point
 
-                @param fX
-                This parameter is used to initialize the X-coordinate
-                of the Point. The homogenous part is initialized to 1.0.
+            @param fX
+            This parameter is used to initialize the X-coordinate
+            of the Point. The homogenous part is initialized to 1.0.
 
-                @param fY
-                This parameter is used to initialize the Y-coordinate
-                of the Point. The homogenous part is initialized to 1.0.
-            */
-            B2DHomPoint(double fX, double fY)
-            :   maTuple(fX, fY),
-                mfW(1.0)
-            {}
+            @param fY
+            This parameter is used to initialize the Y-coordinate
+            of the Point. The homogenous part is initialized to 1.0.
+        */
+        B2DHomPoint(double fX, double fY)
+        :   maTuple(fX, fY),
+            mfW(1.0)
+        {}
 
-            /** Create a copy of a 2D Point
+        /** Create a copy of a 2D Point
 
-                @param rVec
-                The 2D point which will be copied. The homogenous part
-                is initialized to 1.0.
-            */
-            B2DHomPoint(const B2DPoint& rVec)
-            :   maTuple(rVec),
-                mfW(1.0)
-            {}
+            @param rVec
+            The 2D point which will be copied. The homogenous part
+            is initialized to 1.0.
+        */
+        B2DHomPoint(const B2DPoint& rVec)
+        :   maTuple(rVec),
+            mfW(1.0)
+        {}
 
-            /** Create a copy of a homogen point
+        /** Create a copy of a homogen point
 
-                @param rVec
-                The homogen point which will be copied. The homogenous part
-                is copied, too.
-            */
-            B2DHomPoint(const B2DHomPoint& rVec)
-            :   maTuple(rVec.maTuple.getX(), rVec.maTuple.getY()),
-                mfW(rVec.mfW)
-            {}
+            @param rVec
+            The homogen point which will be copied. The homogenous part
+            is copied, too.
+        */
+        B2DHomPoint(const B2DHomPoint& rVec)
+        :   maTuple(rVec.maTuple.getX(), rVec.maTuple.getY()),
+            mfW(rVec.mfW)
+        {}
 
-            ~B2DHomPoint()
-            {}
+        ~B2DHomPoint()
+        {}
 
-            /** Get a 2D point from this homogenous point
+        /** Get a 2D point from this homogenous point
 
-                This method normalizes this homogen point if necessary and
-                returns the corresponding 2D point for this homogen point.
+            This method normalizes this homogen point if necessary and
+            returns the corresponding 2D point for this homogen point.
 
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            B2DPoint getB2DPoint() const;
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        B2DPoint getB2DPoint() const;
 
-            /** Get X-coordinate
+        /** Get X-coordinate
 
-                This method normalizes this homogen point if necessary and
-                returns the corresponding X-coordinate for this homogen point.
+            This method normalizes this homogen point if necessary and
+            returns the corresponding X-coordinate for this homogen point.
 
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            double getX() const;
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        double getX() const;
 
-            /** Get Y-coordinate
+        /** Get Y-coordinate
 
-                This method normalizes this homogen point if necessary and
-                returns the corresponding Y-coordinate for this homogen point.
+            This method normalizes this homogen point if necessary and
+            returns the corresponding Y-coordinate for this homogen point.
 
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            double getY() const;
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        double getY() const;
 
-            /** Set X-coordinate of the homogen point.
+        /** Set X-coordinate of the homogen point.
 
-                This method sets the X-coordinate of the homogen point. If
-                the point does have a homogenous part this is taken into account.
+            This method sets the X-coordinate of the homogen point. If
+            the point does have a homogenous part this is taken into account.
 
-                @param fX
-                The to-be-set X-coordinate without homogenous part.
-            */
-            void setX(double fX);
+            @param fX
+            The to-be-set X-coordinate without homogenous part.
+        */
+        void setX(double fX);
 
-            /** Set Y-coordinate of the homogen point.
+        /** Set Y-coordinate of the homogen point.
 
-                This method sets the Y-coordinate of the homogen point. If
-                the point does have a homogenous part this is taken into account.
+            This method sets the Y-coordinate of the homogen point. If
+            the point does have a homogenous part this is taken into account.
 
-                @param fY
-                The to-be-set Y-coordinate without homogenous part.
-            */
-            void setY(double fY);
+            @param fY
+            The to-be-set Y-coordinate without homogenous part.
+        */
+        void setY(double fY);
 
-            // operators
-            //////////////////////////////////////////////////////////////////////
+        // operators
+        //////////////////////////////////////////////////////////////////////
 
-            B2DHomPoint& operator+=( const B2DHomPoint& rPnt );
+        B2DHomPoint& operator+=( const B2DHomPoint& rPnt );
 
-            B2DHomPoint& operator-=( const B2DHomPoint& rPnt );
+        B2DHomPoint& operator-=( const B2DHomPoint& rPnt );
 
-            B2DHomPoint& operator*=(double t);
+        B2DHomPoint& operator*=(double t);
 
-            B2DHomPoint& operator*=( const matrix::B2DHomMatrix& rMat );
+        B2DHomPoint& operator*=( const B2DHomMatrix& rMat );
 
-            B2DHomPoint& operator/=(double t);
+        B2DHomPoint& operator/=(double t);
 
-            B2DHomPoint& operator-(void);
+        B2DHomPoint& operator-(void);
 
-            sal_Bool operator==( const B2DHomPoint& rPnt ) const;
+        sal_Bool operator==( const B2DHomPoint& rPnt ) const;
 
-            sal_Bool operator!=( const B2DHomPoint& rPnt ) const;
+        sal_Bool operator!=( const B2DHomPoint& rPnt ) const;
 
-            B2DHomPoint& operator=( const B2DHomPoint& rPnt );
-        };
+        B2DHomPoint& operator=( const B2DHomPoint& rPnt );
+    };
 
-        // external operators
-        //////////////////////////////////////////////////////////////////////////
+    // external operators
+    //////////////////////////////////////////////////////////////////////////
 
-        B2DHomPoint min(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+    B2DHomPoint min(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-        B2DHomPoint max(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+    B2DHomPoint max(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-        B2DHomPoint abs(const B2DHomPoint& rVec);
+    B2DHomPoint abs(const B2DHomPoint& rVec);
 
-        B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t);
+    B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t);
 
-        B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2);
+    B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2);
 
-        B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3);
+    B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3);
 
-        B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+    B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-        B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+    B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-        B2DHomPoint operator*(const B2DHomPoint& rVec, double t);
+    B2DHomPoint operator*(const B2DHomPoint& rVec, double t);
 
-        B2DHomPoint operator*(double t, const B2DHomPoint& rVec);
+    B2DHomPoint operator*(double t, const B2DHomPoint& rVec);
 
-        B2DHomPoint operator*( const matrix::B2DHomMatrix& rMat, const B2DHomPoint& rPoint );
+    B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint );
 
-        B2DHomPoint operator/(const B2DHomPoint& rVec, double t);
+    B2DHomPoint operator/(const B2DHomPoint& rVec, double t);
 
-        B2DHomPoint operator/(double t, const B2DHomPoint& rVec);
-    } // end of namespace point
+    B2DHomPoint operator/(double t, const B2DHomPoint& rVec);
 } // end of namespace basegfx
 
 #endif // _BGFX_POINT_B2DHOMPOINT_HXX
diff --git a/basegfx/inc/basegfx/point/b2dpoint.hxx b/basegfx/inc/basegfx/point/b2dpoint.hxx
index eb5f042f69e8..ed07229f4e59 100644
--- a/basegfx/inc/basegfx/point/b2dpoint.hxx
+++ b/basegfx/inc/basegfx/point/b2dpoint.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: b2dpoint.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2003-11-26 14:39:54 $
+ *  last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -68,104 +68,98 @@
 
 namespace basegfx
 {
-    namespace matrix
-    {
-        // predeclaration
-        class B2DHomMatrix;
-    } // end of namespace matrix;
+    // predeclaration
+    class B2DHomMatrix;
+
+    /** Base Point class with two double values
+
+        This class derives all operators and common handling for
+        a 2D data class from B2DTuple. All necessary extensions
+        which are special for points will be added here.
 
-    namespace point
+        @see B2DTuple
+    */
+    class B2DPoint : public ::basegfx::B2DTuple
     {
-        /** Base Point class with two double values
+    public:
+        /** Create a 2D Point
+
+            @param fVal
+            This parameter is used to initialize the coordinate
+            part of the 2D Point.
+        */
+        B2DPoint(double fVal = 0.0)
+        :   B2DTuple(fVal)
+        {}
+
+        /** Create a 2D Point
+
+            @param fX
+            This parameter is used to initialize the X-coordinate
+            of the 2D Point.
+
+            @param fY
+            This parameter is used to initialize the Y-coordinate
+            of the 2D Point.
+        */
+        B2DPoint(double fX, double fY)
+        :   B2DTuple(fX, fY)
+        {}
+
+        /** Create a copy of a 2D Point
+
+            @param rPoint
+            The 2D Point which will be copied.
+        */
+        B2DPoint(const B2DPoint& rPoint)
+        :   B2DTuple(rPoint)
+        {}
 
-            This class derives all operators and common handling for
-            a 2D data class from B2DTuple. All necessary extensions
-            which are special for points will be added here.
+        /** constructor with tuple to allow copy-constructing
+            from B2DTuple-based classes
+        */
+        B2DPoint(const ::basegfx::B2DTuple& rTuple)
+        :   B2DTuple(rTuple)
+        {}
+
+        ~B2DPoint()
+        {}
+
+        /** *=operator to allow usage from B2DPoint, too
+        */
+        B2DPoint& operator*=( const B2DPoint& rPnt )
+        {
+            mfX *= rPnt.mfX;
+            mfY *= rPnt.mfY;
+            return *this;
+        }
+
+        /** *=operator to allow usage from B2DPoint, too
+        */
+        B2DPoint& operator*=(double t)
+        {
+            mfX *= t;
+            mfY *= t;
+            return *this;
+        }
+
+        /** assignment operator to allow assigning the results
+            of B2DTuple calculations
+        */
+        B2DPoint& operator=( const ::basegfx::B2DTuple& rPoint );
+
+        /** Transform point by given transformation matrix.
 
-            @see B2DTuple
+            The translational components of the matrix are, in
+            contrast to B2DVector, applied.
         */
-        class B2DPoint : public ::basegfx::tuple::B2DTuple
+        B2DPoint& operator*=( const ::basegfx::B2DHomMatrix& rMat );
+
+        static const B2DPoint& getEmptyPoint()
         {
-        public:
-            /** Create a 2D Point
-
-                @param fVal
-                This parameter is used to initialize the coordinate
-                part of the 2D Point.
-            */
-            B2DPoint(double fVal = 0.0)
-            :   B2DTuple(fVal)
-            {}
-
-            /** Create a 2D Point
-
-                @param fX
-                This parameter is used to initialize the X-coordinate
-                of the 2D Point.
-
-                @param fY
-                This parameter is used to initialize the Y-coordinate
-                of the 2D Point.
-            */
-            B2DPoint(double fX, double fY)
-            :   B2DTuple(fX, fY)
-            {}
-
-            /** Create a copy of a 2D Point
-
-                @param rPoint
-                The 2D Point which will be copied.
-            */
-            B2DPoint(const B2DPoint& rPoint)
-            :   B2DTuple(rPoint)
-            {}
-
-            /** constructor with tuple to allow copy-constructing
-                from B2DTuple-based classes
-            */
-            B2DPoint(const ::basegfx::tuple::B2DTuple& rTuple)
-            :   B2DTuple(rTuple)
-            {}
-
-            ~B2DPoint()
-            {}
-
-            /** *=operator to allow usage from B2DPoint, too
-            */
-            B2DPoint& operator*=( const B2DPoint& rPnt )
-            {
-                mfX *= rPnt.mfX;
-                mfY *= rPnt.mfY;
-                return *this;
-            }
-
-            /** *=operator to allow usage from B2DPoint, too
-            */
-            B2DPoint& operator*=(double t)
-            {
-                mfX *= t;
-                mfY *= t;
-                return *this;
-            }
-
-            /** assignment operator to allow assigning the results
-                of B2DTuple calculations
-            */
-            B2DPoint& operator=( const ::basegfx::tuple::B2DTuple& rPoint );
-
-            /** Transform point by given transformation matrix.
-
-                The translational components of the matrix are, in
-                contrast to B2DVector, applied.
-            */
-            B2DPoint& operator*=( const ::basegfx::matrix::B2DHomMatrix& rMat );
-
-            static const B2DPoint& getEmptyPoint()
-            {
-                return (const B2DPoint&) ::basegfx::tuple::B2DTuple::getEmptyTuple();
-            }
-        };
-    } // end of namespace point
+            return (const B2DPoint&) ::basegfx::B2DTuple::getEmptyTuple();
+        }
+    };
 } // end of namespace basegfx
 
 #endif //  _BGFX_POINT_B2DPOINT_HXX
diff --git a/basegfx/inc/basegfx/point/b3dhompoint.hxx b/basegfx/inc/basegfx/point/b3dhompoint.hxx
index 7cd82c364a7f..08079b90a983 100644
--- a/basegfx/inc/basegfx/point/b3dhompoint.hxx
+++ b/basegfx/inc/basegfx/point/b3dhompoint.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: b3dhompoint.hxx,v $
  *
- *  $Revision: 1.4 $
+ *  $Revision: 1.5 $
  *
- *  last change: $Author: aw $ $Date: 2003-11-10 11:45:47 $
+ *  last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -68,379 +68,376 @@
 
 namespace basegfx
 {
-    namespace point
+    /** Basic homogen Point class with three double values and one homogen factor
+
+        This class provides access to homogen coordinates in 3D.
+        For this purpose all the operators which need to do specific
+        action due to their homogenity are implemented here.
+        The only caveat are member methods which are declared as const
+        but do change the content. These are documented for that reason.
+        The class is designed to provide homogenous coordinates without
+        direct access to the homogen part (mfW). This is also the reason
+        for leaving out the [] operators which return references to members.
+
+        @see B3DTuple
+    */
+    class B3DHomPoint
     {
-        /** Basic homogen Point class with three double values and one homogen factor
-
-            This class provides access to homogen coordinates in 3D.
-            For this purpose all the operators which need to do specific
-            action due to their homogenity are implemented here.
-            The only caveat are member methods which are declared as const
-            but do change the content. These are documented for that reason.
-            The class is designed to provide homogenous coordinates without
-            direct access to the homogen part (mfW). This is also the reason
-            for leaving out the [] operators which return references to members.
-
-            @see B3DTuple
-        */
-        class B3DHomPoint
-        {
-        protected:
-            /// This member contains the coordinate part of the point
-            ::basegfx::tuple::B3DTuple                  maTuple;
+    protected:
+        /// This member contains the coordinate part of the point
+        ::basegfx::B3DTuple                 maTuple;
 
-            /// This Member holds the homogenous part of the point
-            double                                      mfW;
+        /// This Member holds the homogenous part of the point
+        double                                      mfW;
 
-            /** Test if this homogen point does have a homogenous part
+        /** Test if this homogen point does have a homogenous part
 
-                @return Returns sal_True if this point has no homogenous part
-            */
-            sal_Bool implIsHomogenized() const
-            {
-                const double fOne(1.0);
-                return ::basegfx::numeric::fTools::equal(mfW, fOne);
-            }
+            @return Returns sal_True if this point has no homogenous part
+        */
+        sal_Bool implIsHomogenized() const
+        {
+            const double fOne(1.0);
+            return ::basegfx::fTools::equal(mfW, fOne);
+        }
 
-            /** Remove homogenous part of this Point
+        /** Remove homogenous part of this Point
 
-                This method does necessary calculations to remove
-                the evtl. homogenous part of this Point. This may
-                change all members.
-            */
-            void implHomogenize();
+            This method does necessary calculations to remove
+            the evtl. homogenous part of this Point. This may
+            change all members.
+        */
+        void implHomogenize();
 
-            /** Test and on demand remove homogenous part
+        /** Test and on demand remove homogenous part
 
-                This method tests if this Point does have a homogenous part
-                and then evtl. takes actions to remove that part.
+            This method tests if this Point does have a homogenous part
+            and then evtl. takes actions to remove that part.
 
-                @attention Even when this method is const it may change all
-                members of this instance. This is due to the fact that changing
-                the homogenous part of a homogenous point does from a mathematical
-                point of view not change the point at all.
-            */
-            void implTestAndHomogenize() const
-            {
-                if(!implIsHomogenized())
-                    ((B3DHomPoint*)this)->implHomogenize();
-            }
+            @attention Even when this method is const it may change all
+            members of this instance. This is due to the fact that changing
+            the homogenous part of a homogenous point does from a mathematical
+            point of view not change the point at all.
+        */
+        void implTestAndHomogenize() const
+        {
+            if(!implIsHomogenized())
+                ((B3DHomPoint*)this)->implHomogenize();
+        }
 
-        public:
-            /** Create a homogen point
-
-                @param fVal
-                This parameter is used to initialize the coordinate
-                part of the Point. The homogenous part is initialized to 1.0.
-            */
-            B3DHomPoint(double fVal = 0.0)
-            :   maTuple(fVal),
-                mfW(1.0)
-            {}
-
-            /** Create a homogen point
-
-                @param fX
-                This parameter is used to initialize the X-coordinate
-                of the Point. The homogenous part is initialized to 1.0.
-
-                @param fY
-                This parameter is used to initialize the Y-coordinate
-                of the Point. The homogenous part is initialized to 1.0.
-
-                @param fZ
-                This parameter is used to initialize the Z-coordinate
-                of the Point. The homogenous part is initialized to 1.0.
-            */
-            B3DHomPoint(double fX, double fY, double fZ)
-            :   maTuple(fX, fY, fZ),
-                mfW(1.0)
-            {}
-
-            /** Create a copy of a 3D Point
-
-                @param rVec
-                The 3D point which will be copied. The homogenous part
-                is initialized to 1.0.
-            */
-            B3DHomPoint(const B3DPoint& rVec)
-            :   maTuple(rVec),
-                mfW(1.0)
-            {}
-
-            /** Create a copy of a homogen point
-
-                @param rVec
-                The homogen point which will be copied. The homogenous part
-                is copied, too.
-            */
-            B3DHomPoint(const B3DHomPoint& rVec)
-            :   maTuple(rVec.maTuple.getX(), rVec.maTuple.getY(), rVec.maTuple.getZ()),
-                mfW(rVec.mfW)
-            {}
-
-            ~B3DHomPoint()
-            {}
-
-            /** get a 3D point from this homogenous point
-
-                This method normalizes this homogen point if necessary and
-                returns the corresponding 3D point for this homogen point.
-
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            B3DPoint getB3DPoint() const
-            {
-                implTestAndHomogenize();
-                return B3DPoint(maTuple.getX(), maTuple.getY(), maTuple.getZ());
-            }
+    public:
+        /** Create a homogen point
 
-            /** get X-coordinate
+            @param fVal
+            This parameter is used to initialize the coordinate
+            part of the Point. The homogenous part is initialized to 1.0.
+        */
+        B3DHomPoint(double fVal = 0.0)
+        :   maTuple(fVal),
+            mfW(1.0)
+        {}
 
-                This method normalizes this homogen point if necessary and
-                returns the corresponding X-coordinate for this homogen point.
+        /** Create a homogen point
 
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            double getX() const
-            {
-                implTestAndHomogenize();
-                return maTuple.getX();
-            }
+            @param fX
+            This parameter is used to initialize the X-coordinate
+            of the Point. The homogenous part is initialized to 1.0.
 
-            /** get Y-coordinate
+            @param fY
+            This parameter is used to initialize the Y-coordinate
+            of the Point. The homogenous part is initialized to 1.0.
 
-                This method normalizes this homogen point if necessary and
-                returns the corresponding Y-coordinate for this homogen point.
+            @param fZ
+            This parameter is used to initialize the Z-coordinate
+            of the Point. The homogenous part is initialized to 1.0.
+        */
+        B3DHomPoint(double fX, double fY, double fZ)
+        :   maTuple(fX, fY, fZ),
+            mfW(1.0)
+        {}
 
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            double getY() const
-            {
-                implTestAndHomogenize();
-                return maTuple.getY();
-            }
+        /** Create a copy of a 3D Point
 
-            /** get Z-coordinate
+            @param rVec
+            The 3D point which will be copied. The homogenous part
+            is initialized to 1.0.
+        */
+        B3DHomPoint(const B3DPoint& rVec)
+        :   maTuple(rVec),
+            mfW(1.0)
+        {}
 
-                This method normalizes this homogen point if necessary and
-                returns the corresponding Z-coordinate for this homogen point.
+        /** Create a copy of a homogen point
 
-                @attention Even when this method is const it may change all
-                members of this instance.
-            */
-            double getZ() const
-            {
-                implTestAndHomogenize();
-                return maTuple.getY();
-            }
+            @param rVec
+            The homogen point which will be copied. The homogenous part
+            is copied, too.
+        */
+        B3DHomPoint(const B3DHomPoint& rVec)
+        :   maTuple(rVec.maTuple.getX(), rVec.maTuple.getY(), rVec.maTuple.getZ()),
+            mfW(rVec.mfW)
+        {}
 
-            /** Set X-coordinate of the homogen point.
+        ~B3DHomPoint()
+        {}
 
-                This method sets the X-coordinate of the homogen point. If
-                the point does have a homogenous part this is taken into account.
+        /** get a 3D point from this homogenous point
 
-                @param fX
-                The to-be-set X-coordinate without homogenous part.
-            */
-            void setX(double fX)
-            {
-                maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
-            }
+            This method normalizes this homogen point if necessary and
+            returns the corresponding 3D point for this homogen point.
 
-            /** Set Y-coordinate of the homogen point.
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        B3DPoint getB3DPoint() const
+        {
+            implTestAndHomogenize();
+            return B3DPoint(maTuple.getX(), maTuple.getY(), maTuple.getZ());
+        }
 
-                This method sets the Y-coordinate of the homogen point. If
-                the point does have a homogenous part this is taken into account.
+        /** get X-coordinate
 
-                @param fY
-                The to-be-set Y-coordinate without homogenous part.
-            */
-            void setY(double fY)
-            {
-                maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
-            }
+            This method normalizes this homogen point if necessary and
+            returns the corresponding X-coordinate for this homogen point.
 
-            /** Set Z-coordinate of the homogen point.
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        double getX() const
+        {
+            implTestAndHomogenize();
+            return maTuple.getX();
+        }
 
-                This method sets the Z-coordinate of the homogen point. If
-                the point does have a homogenous part this is taken into account.
+        /** get Y-coordinate
 
-                @param fZ
-                The to-be-set Z-coordinate without homogenous part.
-            */
-            void setZ(double fZ)
-            {
-                maTuple.setZ(implIsHomogenized() ? fZ : fZ * mfW );
-            }
+            This method normalizes this homogen point if necessary and
+            returns the corresponding Y-coordinate for this homogen point.
 
-            // operators
-            //////////////////////////////////////////////////////////////////////
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        double getY() const
+        {
+            implTestAndHomogenize();
+            return maTuple.getY();
+        }
 
-            B3DHomPoint& operator+=( const B3DHomPoint& rPnt )
-            {
-                maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
-                maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
-                maTuple.setZ(getZ() * rPnt.mfW + rPnt.getZ() * mfW);
-                mfW = mfW * rPnt.mfW;
+        /** get Z-coordinate
 
-                return *this;
-            }
+            This method normalizes this homogen point if necessary and
+            returns the corresponding Z-coordinate for this homogen point.
 
-            B3DHomPoint& operator-=( const B3DHomPoint& rPnt )
-            {
-                maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
-                maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
-                maTuple.setZ(getZ() * rPnt.mfW - rPnt.getZ() * mfW);
-                mfW = mfW * rPnt.mfW;
+            @attention Even when this method is const it may change all
+            members of this instance.
+        */
+        double getZ() const
+        {
+            implTestAndHomogenize();
+            return maTuple.getY();
+        }
 
-                return *this;
-            }
+        /** Set X-coordinate of the homogen point.
 
-            B3DHomPoint& operator*=(double t)
-            {
-                if(!::basegfx::numeric::fTools::equalZero(t))
-                {
-                    mfW /= t;
-                }
+            This method sets the X-coordinate of the homogen point. If
+            the point does have a homogenous part this is taken into account.
 
-                return *this;
-            }
-
-            B3DHomPoint& operator/=(double t)
-            {
-                mfW *= t;
-                return *this;
-            }
+            @param fX
+            The to-be-set X-coordinate without homogenous part.
+        */
+        void setX(double fX)
+        {
+            maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
+        }
 
-            B3DHomPoint& operator-(void)
-            {
-                mfW = -mfW;
-                return *this;
-            }
+        /** Set Y-coordinate of the homogen point.
 
-            sal_Bool operator==( const B3DHomPoint& rPnt ) const
-            {
-                implTestAndHomogenize();
-                return (maTuple == rPnt.maTuple);
-            }
+            This method sets the Y-coordinate of the homogen point. If
+            the point does have a homogenous part this is taken into account.
 
-            sal_Bool operator!=( const B3DHomPoint& rPnt ) const
-            {
-                implTestAndHomogenize();
-                return (maTuple != rPnt.maTuple);
-            }
+            @param fY
+            The to-be-set Y-coordinate without homogenous part.
+        */
+        void setY(double fY)
+        {
+            maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
+        }
 
-            B3DHomPoint& operator=( const B3DHomPoint& rPnt )
-            {
-                maTuple = rPnt.maTuple;
-                mfW = rPnt.mfW;
-                return *this;
-            }
-        };
+        /** Set Z-coordinate of the homogen point.
 
-        // external operators
-        //////////////////////////////////////////////////////////////////////////
+            This method sets the Z-coordinate of the homogen point. If
+            the point does have a homogenous part this is taken into account.
 
-        inline B3DHomPoint min(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+            @param fZ
+            The to-be-set Z-coordinate without homogenous part.
+        */
+        void setZ(double fZ)
         {
-            B3DHomPoint aMin(
-                (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
-                (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
-                (rVecB.getZ() < rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
-            return aMin;
+            maTuple.setZ(implIsHomogenized() ? fZ : fZ * mfW );
         }
 
-        inline B3DHomPoint max(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
-        {
-            B3DHomPoint aMax(
-                (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
-                (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
-                (rVecB.getZ() > rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
-            return aMax;
-        }
+        // operators
+        //////////////////////////////////////////////////////////////////////
 
-        inline B3DHomPoint abs(const B3DHomPoint& rVec)
+        B3DHomPoint& operator+=( const B3DHomPoint& rPnt )
         {
-            B3DHomPoint aAbs(
-                (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
-                (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY(),
-                (0.0 > rVec.getZ()) ? -rVec.getZ() : rVec.getZ());
-            return aAbs;
-        }
+            maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
+            maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
+            maTuple.setZ(getZ() * rPnt.mfW + rPnt.getZ() * mfW);
+            mfW = mfW * rPnt.mfW;
 
-        inline B3DHomPoint interpolate(B3DHomPoint& rOld1, B3DHomPoint& rOld2, double t)
-        {
-            B3DHomPoint aInt(
-                ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
-                ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
-                ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
-            return aInt;
+            return *this;
         }
 
-        inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2)
+        B3DHomPoint& operator-=( const B3DHomPoint& rPnt )
         {
-            B3DHomPoint aAvg(
-                (rOld1.getX() + rOld2.getX()) * 0.5,
-                (rOld1.getY() + rOld2.getY()) * 0.5,
-                (rOld1.getZ() + rOld2.getZ()) * 0.5);
-            return aAvg;
-        }
+            maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
+            maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
+            maTuple.setZ(getZ() * rPnt.mfW - rPnt.getZ() * mfW);
+            mfW = mfW * rPnt.mfW;
 
-        inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2, B3DHomPoint& rOld3)
-        {
-            B3DHomPoint aAvg(
-                (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
-                (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
-                (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
-            return aAvg;
+            return *this;
         }
 
-        inline B3DHomPoint operator+(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+        B3DHomPoint& operator*=(double t)
         {
-            B3DHomPoint aSum(rVecA);
-            aSum += rVecB;
-            return aSum;
+            if(!::basegfx::fTools::equalZero(t))
+            {
+                mfW /= t;
+            }
+
+            return *this;
         }
 
-        inline B3DHomPoint operator-(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+        B3DHomPoint& operator/=(double t)
         {
-            B3DHomPoint aSub(rVecA);
-            aSub -= rVecB;
-            return aSub;
+            mfW *= t;
+            return *this;
         }
 
-        inline B3DHomPoint operator*(const B3DHomPoint& rVec, double t)
+        B3DHomPoint& operator-(void)
         {
-            B3DHomPoint aNew(rVec);
-            aNew *= t;
-            return aNew;
+            mfW = -mfW;
+            return *this;
         }
 
-        inline B3DHomPoint operator*(double t, const B3DHomPoint& rVec)
+        sal_Bool operator==( const B3DHomPoint& rPnt ) const
         {
-            B3DHomPoint aNew(rVec);
-            aNew *= t;
-            return aNew;
+            implTestAndHomogenize();
+            return (maTuple == rPnt.maTuple);
         }
 
-        inline B3DHomPoint operator/(const B3DHomPoint& rVec, double t)
+        sal_Bool operator!=( const B3DHomPoint& rPnt ) const
         {
-            B3DHomPoint aNew(rVec);
-            aNew /= t;
-            return aNew;
+            implTestAndHomogenize();
+            return (maTuple != rPnt.maTuple);
         }
 
-        inline B3DHomPoint operator/(double t, const B3DHomPoint& rVec)
+        B3DHomPoint& operator=( const B3DHomPoint& rPnt )
         {
-            B3DHomPoint aNew(rVec);
-            aNew /= t;
-            return aNew;
+            maTuple = rPnt.maTuple;
+            mfW = rPnt.mfW;
+            return *this;
         }
-    } // end of namespace point
+    };
+
+    // external operators
+    //////////////////////////////////////////////////////////////////////////
+
+    inline B3DHomPoint min(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+    {
+        B3DHomPoint aMin(
+            (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
+            (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
+            (rVecB.getZ() < rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
+        return aMin;
+    }
+
+    inline B3DHomPoint max(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+    {
+        B3DHomPoint aMax(
+            (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
+            (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY(),
+            (rVecB.getZ() > rVecA.getZ()) ? rVecB.getZ() : rVecA.getZ());
+        return aMax;
+    }
+
+    inline B3DHomPoint abs(const B3DHomPoint& rVec)
+    {
+        B3DHomPoint aAbs(
+            (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
+            (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY(),
+            (0.0 > rVec.getZ()) ? -rVec.getZ() : rVec.getZ());
+        return aAbs;
+    }
+
+    inline B3DHomPoint interpolate(B3DHomPoint& rOld1, B3DHomPoint& rOld2, double t)
+    {
+        B3DHomPoint aInt(
+            ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
+            ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(),
+            ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ());
+        return aInt;
+    }
+
+    inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2)
+    {
+        B3DHomPoint aAvg(
+            (rOld1.getX() + rOld2.getX()) * 0.5,
+            (rOld1.getY() + rOld2.getY()) * 0.5,
+            (rOld1.getZ() + rOld2.getZ()) * 0.5);
+        return aAvg;
+    }
+
+    inline B3DHomPoint average(B3DHomPoint& rOld1, B3DHomPoint& rOld2, B3DHomPoint& rOld3)
+    {
+        B3DHomPoint aAvg(
+            (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
+            (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0),
+            (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0));
+        return aAvg;
+    }
+
+    inline B3DHomPoint operator+(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+    {
+        B3DHomPoint aSum(rVecA);
+        aSum += rVecB;
+        return aSum;
+    }
+
+    inline B3DHomPoint operator-(const B3DHomPoint& rVecA, const B3DHomPoint& rVecB)
+    {
+        B3DHomPoint aSub(rVecA);
+        aSub -= rVecB;
+        return aSub;
+    }
+
+    inline B3DHomPoint operator*(const B3DHomPoint& rVec, double t)
+    {
+        B3DHomPoint aNew(rVec);
+        aNew *= t;
+        return aNew;
+    }
+
+    inline B3DHomPoint operator*(double t, const B3DHomPoint& rVec)
+    {
+        B3DHomPoint aNew(rVec);
+        aNew *= t;
+        return aNew;
+    }
+
+    inline B3DHomPoint operator/(const B3DHomPoint& rVec, double t)
+    {
+        B3DHomPoint aNew(rVec);
+        aNew /= t;
+        return aNew;
+    }
+
+    inline B3DHomPoint operator/(double t, const B3DHomPoint& rVec)
+    {
+        B3DHomPoint aNew(rVec);
+        aNew /= t;
+        return aNew;
+    }
 } // end of namespace basegfx
 
 #endif // _BGFX_POINT_B3DHOMPOINT_HXX
diff --git a/basegfx/inc/basegfx/point/b3dpoint.hxx b/basegfx/inc/basegfx/point/b3dpoint.hxx
index 7f444b850234..06a4b7e346e1 100644
--- a/basegfx/inc/basegfx/point/b3dpoint.hxx
+++ b/basegfx/inc/basegfx/point/b3dpoint.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: b3dpoint.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: aw $ $Date: 2003-11-26 14:39:54 $
+ *  last change: $Author: aw $ $Date: 2003-11-28 11:17:51 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -68,116 +68,110 @@
 
 namespace basegfx
 {
-    namespace matrix
-    {
-        // predeclaration
-        class B3DHomMatrix;
-    } // end of namespace matrix;
+    // predeclaration
+    class B3DHomMatrix;
+
+    /** Base Point class with three double values
 
-    namespace point
+        This class derives all operators and common handling for
+        a 3D data class from B3DTuple. All necessary extensions
+        which are special for points will be added here.
+
+        @see B3DTuple
+    */
+    class B3DPoint : public ::basegfx::B3DTuple
     {
-        /** Base Point class with three double values
+    public:
+        /** Create a 3D Point
+
+            @param fVal
+            This parameter is used to initialize the coordinate
+            part of the 3D Point.
+        */
+        B3DPoint(double fVal = 0.0)
+        :   B3DTuple(fVal)
+        {}
+
+        /** Create a 3D Point
+
+            @param fX
+            This parameter is used to initialize the X-coordinate
+            of the 3D Point.
 
-            This class derives all operators and common handling for
-            a 3D data class from B3DTuple. All necessary extensions
-            which are special for points will be added here.
+            @param fY
+            This parameter is used to initialize the Y-coordinate
+            of the 3D Point.
 
-            @see B3DTuple
+            @param fZ
+            This parameter is used to initialize the Z-coordinate
+            of the 3D Point.
         */
-        class B3DPoint : public ::basegfx::tuple::B3DTuple
+        B3DPoint(double fX, double fY, double fZ)
+        :   B3DTuple(fX, fY, fZ)
+        {}
+
+        /** Create a copy of a 3D Point
+
+            @param rVec
+            The 3D Point which will be copied.
+        */
+        B3DPoint(const B3DPoint& rVec)
+        :   B3DTuple(rVec)
+        {}
+
+        /** constructor with tuple to allow copy-constructing
+            from B3DTuple-based classes
+        */
+        B3DPoint(const ::basegfx::B3DTuple& rTuple)
+        :   B3DTuple(rTuple)
+        {}
+
+        ~B3DPoint()
+        {}
+
+        /** *=operator to allow usage from B3DPoint, too
+        */
+        B3DPoint& operator*=( const B3DPoint& rPnt )
+        {
+            mfX *= rPnt.mfX;
+            mfY *= rPnt.mfY;
+            mfZ *= rPnt.mfZ;
+            return *this;
+        }
+
+        /** *=operator to allow usage from B3DPoint, too
+        */
+        B3DPoint& operator*=(double t)
+        {
+            mfX *= t;
+            mfY *= t;
+            mfZ *= t;
+            return *this;
+        }
+
+        /** assignment operator to allow assigning the results
+            of B3DTuple calculations
+        */
+        B3DPoint& operator=( const ::basegfx::B3DTuple& rVec )
+        {
+            mfX = rVec.getX();
+            mfY = rVec.getY();
+            mfZ = rVec.getZ();
+            return *this;
+        }
+
+        /** Transform point by given transformation matrix.
+
+            The translational components of the matrix are, in
+            contrast to B3DVector, applied.
+        */
+        B3DPoint& operator*=( const ::basegfx::B3DHomMatrix& rMat );
+
+        static const B3DPoint& getEmptyPoint()
         {
-        public:
-            /** Create a 3D Point
-
-                @param fVal
-                This parameter is used to initialize the coordinate
-                part of the 3D Point.
-            */
-            B3DPoint(double fVal = 0.0)
-            :   B3DTuple(fVal)
-            {}
-
-            /** Create a 3D Point
-
-                @param fX
-                This parameter is used to initialize the X-coordinate
-                of the 3D Point.
-
-                @param fY
-                This parameter is used to initialize the Y-coordinate
-                of the 3D Point.
-
-                @param fZ
-                This parameter is used to initialize the Z-coordinate
-                of the 3D Point.
-            */
-            B3DPoint(double fX, double fY, double fZ)
-            :   B3DTuple(fX, fY, fZ)
-            {}
-
-            /** Create a copy of a 3D Point
-
-                @param rVec
-                The 3D Point which will be copied.
-            */
-            B3DPoint(const B3DPoint& rVec)
-            :   B3DTuple(rVec)
-            {}
-
-            /** constructor with tuple to allow copy-constructing
-                from B3DTuple-based classes
-            */
-            B3DPoint(const ::basegfx::tuple::B3DTuple& rTuple)
-            :   B3DTuple(rTuple)
-            {}
-
-            ~B3DPoint()
-            {}
-
-            /** *=operator to allow usage from B3DPoint, too
-            */
-            B3DPoint& operator*=( const B3DPoint& rPnt )
-            {
-                mfX *= rPnt.mfX;
-                mfY *= rPnt.mfY;
-                mfZ *= rPnt.mfZ;
-                return *this;
-            }
-
-            /** *=operator to allow usage from B3DPoint, too
-            */
-            B3DPoint& operator*=(double t)
-            {
-                mfX *= t;
-                mfY *= t;
-                mfZ *= t;
-                return *this;
-            }
-
-            /** assignment operator to allow assigning the results
-                of B3DTuple calculations
-            */
-            B3DPoint& operator=( const ::basegfx::tuple::B3DTuple& rVec )
-            {
-                mfX = rVec.getX();
-                mfY = rVec.getY();
-                mfZ = rVec.getZ();
-                return *this;
-            }
-
-            /** Transform point by given transformation matrix.
-
-                The translational components of the matrix are, in
-                contrast to B3DVector, applied.
-            */
-            B3DPoint& operator*=( const ::basegfx::matrix::B3DHomMatrix& rMat );
-
-            static const B3DPoint& getEmptyPoint()
-            {
-                return (const B3DPoint&) ::basegfx::tuple::B3DTuple::getEmptyTuple();
-            }
-        };
-    } // end of namespace point
+            return (const B3DPoint&) ::basegfx::B3DTuple::getEmptyTuple();
+        }
+    };
 } // end of namespace basegfx
 
 #endif //  _BGFX_POINT_B3DPOINT_HXX