unusedcode.easy: Removed unused code

36 files changed, 0 insertions, 385 deletions

diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
index 3d0d22da4cad..e53a598ba967 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
@@ -226,9 +226,6 @@ namespace basegfx
         };
     } // end of namespace tools
 
-    /// Returns a string with svg's "matrix(m00,m10,m01,m11,m02,m12)" representation
-    ::rtl::OUString exportToSvg( const B2DHomMatrix& rMatrix );
-
 } // end of namespace basegfx
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/inc/basegfx/point/b2ipoint.hxx b/basegfx/inc/basegfx/point/b2ipoint.hxx
index b74b559d898b..c356e1c5855b 100644
--- a/basegfx/inc/basegfx/point/b2ipoint.hxx
+++ b/basegfx/inc/basegfx/point/b2ipoint.hxx
@@ -118,11 +118,6 @@ namespace basegfx
             contrast to B2DVector, applied.
         */
         B2IPoint& operator*=( const ::basegfx::B2DHomMatrix& rMat );
-
-        static const B2IPoint& getEmptyPoint()
-        {
-            return (const B2IPoint&) ::basegfx::B2ITuple::getEmptyTuple();
-        }
     };
 } // end of namespace basegfx
 
diff --git a/basegfx/inc/basegfx/point/b3ipoint.hxx b/basegfx/inc/basegfx/point/b3ipoint.hxx
index 334ff33a7b50..f773994728fe 100644
--- a/basegfx/inc/basegfx/point/b3ipoint.hxx
+++ b/basegfx/inc/basegfx/point/b3ipoint.hxx
@@ -130,11 +130,6 @@ namespace basegfx
             contrast to B3DVector, applied.
         */
         B3IPoint& operator*=( const ::basegfx::B3DHomMatrix& rMat );
-
-        static const B3IPoint& getEmptyPoint()
-        {
-            return (const B3IPoint&) ::basegfx::B3ITuple::getEmptyTuple();
-        }
     };
 } // end of namespace basegfx
 
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
index 707590de87ad..3443d7253615 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
@@ -187,26 +187,6 @@ namespace basegfx
         */
         B2DRange getB2DRange() const;
 
-        /** insert other 2D polygons
-
-            The default (with nIndex2 == 0 && nCount == 0) inserts the whole
-            rPoly at position nIndex
-
-            @param nIndex
-            Target index for points to be inserted
-
-            @param rPoly
-            The source for new points
-
-            @param nIndex2
-            The index to the first source point into rPoly
-
-            @param nCount
-            How many points to add from rPoly to this polygon. Null
-            means to copy all (starting from nIndex2)
-        */
-        void insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2 = 0, sal_uInt32 nCount = 0);
-
         /** append other 2D polygons
 
             The default (nIndex ==0 && nCount == 0) will append
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
index 359adf2d7d79..2aae89b64f58 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
@@ -69,9 +69,6 @@ namespace basegfx
         // assignment operator
         B3DPolygon& operator=(const B3DPolygon& rPolygon);
 
-        /// unshare this polygon with all internally shared instances
-        void makeUnique();
-
         // compare operators
         bool operator==(const B3DPolygon& rPolygon) const;
         bool operator!=(const B3DPolygon& rPolygon) const;
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
index 98ba7cc27892..fab75a1a860f 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
@@ -101,9 +101,6 @@ namespace basegfx
         // reset to empty state
         void clear();
 
-        // closed state
-        bool isClosed() const;
-
         // flip polygon direction
         void flip();
 
diff --git a/basegfx/inc/basegfx/range/b1drange.hxx b/basegfx/inc/basegfx/range/b1drange.hxx
index cac1efb075b6..97e0cb9f0a20 100644
--- a/basegfx/inc/basegfx/range/b1drange.hxx
+++ b/basegfx/inc/basegfx/range/b1drange.hxx
@@ -71,8 +71,6 @@ namespace basegfx
             expand(fStartValue2);
         }
 
-        BASEGFX_DLLPUBLIC explicit B1DRange( const B1IRange& rRange );
-
         /** Check if the interval set is empty
 
             @return false, if no value is in this set - having a
@@ -177,12 +175,6 @@ namespace basegfx
         }
     };
 
-    /** Round double to nearest integer for 1D range
-
-        @return the nearest integer for this range
-    */
-    BASEGFX_DLLPUBLIC B1IRange fround(const B1DRange& rRange);
-
 } // end of namespace basegfx
 
 
diff --git a/basegfx/inc/basegfx/range/b2drange.hxx b/basegfx/inc/basegfx/range/b2drange.hxx
index b8a51aeb8800..7d7edb05c654 100644
--- a/basegfx/inc/basegfx/range/b2drange.hxx
+++ b/basegfx/inc/basegfx/range/b2drange.hxx
@@ -292,12 +292,6 @@ namespace basegfx
         MyBasicRange        maRangeY;
     };
 
-    /** Round double to nearest integer for 2D range
-
-        @return the nearest integer for this range
-    */
-    BASEGFX_DLLPUBLIC B2IRange fround(const B2DRange& rRange);
-
     /** Compute the set difference of the two given ranges
 
         This method calculates the symmetric difference (aka XOR)
diff --git a/basegfx/inc/basegfx/range/b3drange.hxx b/basegfx/inc/basegfx/range/b3drange.hxx
index 353d16cddc69..8f1caf0febaf 100644
--- a/basegfx/inc/basegfx/range/b3drange.hxx
+++ b/basegfx/inc/basegfx/range/b3drange.hxx
@@ -83,8 +83,6 @@ namespace basegfx
             expand(rTuple2);
         }
 
-         BASEGFX_DLLPUBLIC explicit B3DRange(const B3IRange& rRange);
-
         bool isEmpty() const
         {
             return (
@@ -276,12 +274,6 @@ namespace basegfx
          BASEGFX_DLLPUBLIC void transform(const B3DHomMatrix& rMatrix);
     };
 
-    /** Round double to nearest integer for 3D range
-
-        @return the nearest integer for this range
-    */
-    BASEGFX_DLLPUBLIC B3IRange fround(const B3DRange& rRange);
-
 } // end of namespace basegfx
 
 
diff --git a/basegfx/inc/basegfx/tools/canvastools.hxx b/basegfx/inc/basegfx/tools/canvastools.hxx
index ea1924afb994..40f45e02a722 100644
--- a/basegfx/inc/basegfx/tools/canvastools.hxx
+++ b/basegfx/inc/basegfx/tools/canvastools.hxx
@@ -165,21 +165,11 @@ namespace basegfx
         BASEGFX_DLLPUBLIC ::basegfx::B2IVector      b2ISizeFromIntegerSize2D( const ::com::sun::star::geometry::IntegerSize2D& );
         BASEGFX_DLLPUBLIC ::basegfx::B2IRange       b2IRectangleFromIntegerRectangle2D( const ::com::sun::star::geometry::IntegerRectangle2D& );
 
-        BASEGFX_DLLPUBLIC ::com::sun::star::awt::Size       awtSizeFromB2ISize( const ::basegfx::B2IVector& );
-        BASEGFX_DLLPUBLIC ::com::sun::star::awt::Point          awtPointFromB2IPoint( const ::basegfx::B2IPoint& );
-        BASEGFX_DLLPUBLIC ::com::sun::star::awt::Rectangle  awtRectangleFromB2IRectangle( const ::basegfx::B2IRange& );
-
-        BASEGFX_DLLPUBLIC ::basegfx::B2IVector      b2ISizeFromAwtSize( const ::com::sun::star::awt::Size& );
-        BASEGFX_DLLPUBLIC ::basegfx::B2IPoint       b2IPointFromAwtPoint( const ::com::sun::star::awt::Point& );
         BASEGFX_DLLPUBLIC ::basegfx::B2IRange       b2IRectangleFromAwtRectangle( const ::com::sun::star::awt::Rectangle& );
 
         // Geometry comparisons
         // ===================================================================
 
-        BASEGFX_DLLPUBLIC bool awtSizeAreEqual( const ::com::sun::star::awt::Size& rA, const ::com::sun::star::awt::Size& rB );
-        BASEGFX_DLLPUBLIC bool awtPointAreEqual( const ::com::sun::star::awt::Point& rA, const ::com::sun::star::awt::Point& rB );
-        BASEGFX_DLLPUBLIC bool awtRectangleAreEqual( const ::com::sun::star::awt::Rectangle& rA, const ::com::sun::star::awt::Rectangle& rB );
-
         /** Return smalltest integer range, which completely contains
             given floating point range.
 
diff --git a/basegfx/inc/basegfx/tools/unopolypolygon.hxx b/basegfx/inc/basegfx/tools/unopolypolygon.hxx
index ca04b7a5f776..558ab7ea4c43 100644
--- a/basegfx/inc/basegfx/tools/unopolypolygon.hxx
+++ b/basegfx/inc/basegfx/tools/unopolypolygon.hxx
@@ -95,9 +95,6 @@ namespace unotools
                                              sal_Int32 nPointIndex,
                                              sal_Int32 nNumberOfPoints ) const;
 
-        /// Get cow copy of internal polygon. not thread-safe outside this object.
-        B2DPolyPolygon getPolyPolygonUnsafe() const;
-
         /// Called whenever internal polypolygon gets modified
         virtual void modifying() const {}
 
diff --git a/basegfx/inc/basegfx/tuple/b2i64tuple.hxx b/basegfx/inc/basegfx/tuple/b2i64tuple.hxx
index bbea7a532296..7af092b04601 100644
--- a/basegfx/inc/basegfx/tuple/b2i64tuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b2i64tuple.hxx
@@ -198,8 +198,6 @@ namespace basegfx
             mnY = rTup.mnY;
             return *this;
         }
-
-        static const B2I64Tuple& getEmptyTuple();
     };
 
     // external operators
diff --git a/basegfx/inc/basegfx/tuple/b2ituple.hxx b/basegfx/inc/basegfx/tuple/b2ituple.hxx
index 4072073026a9..12459e0d5765 100644
--- a/basegfx/inc/basegfx/tuple/b2ituple.hxx
+++ b/basegfx/inc/basegfx/tuple/b2ituple.hxx
@@ -196,8 +196,6 @@ namespace basegfx
             mnY = rTup.mnY;
             return *this;
         }
-
-        static const B2ITuple& getEmptyTuple();
     };
 
     // external operators
diff --git a/basegfx/inc/basegfx/tuple/b3dtuple.hxx b/basegfx/inc/basegfx/tuple/b3dtuple.hxx
index a202b3452365..0ed99431da2f 100644
--- a/basegfx/inc/basegfx/tuple/b3dtuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3dtuple.hxx
@@ -95,13 +95,6 @@ namespace basegfx
             mfZ( rTup.mfZ )
         {}
 
-        /** Create a copy of a 3D integer Tuple
-
-            @param rTup
-            The 3D Tuple which will be copied.
-        */
-        explicit B3DTuple(const B3ITuple& rTup);
-
         ~B3DTuple()
         {}
 
diff --git a/basegfx/inc/basegfx/tuple/b3i64tuple.hxx b/basegfx/inc/basegfx/tuple/b3i64tuple.hxx
index 598a1d9f3b36..9e8fa7f3fbd7 100644
--- a/basegfx/inc/basegfx/tuple/b3i64tuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3i64tuple.hxx
@@ -206,12 +206,6 @@ namespace basegfx
             return B3I64Tuple(-mnX, -mnY, -mnZ);
         }
 
-        bool equalZero() const
-        {
-            return (this == &getEmptyTuple() ||
-                (mnX == 0 && mnY == 0 && mnZ == 0));
-        }
-
         bool operator==( const B3I64Tuple& rTup ) const
         {
             return this == &rTup || (rTup.mnX == mnX && rTup.mnY == mnY && rTup.mnZ == mnZ);
@@ -229,8 +223,6 @@ namespace basegfx
             mnZ = rTup.mnZ;
             return *this;
         }
-
-        static const B3I64Tuple& getEmptyTuple();
     };
 
     // external operators
diff --git a/basegfx/inc/basegfx/tuple/b3ituple.hxx b/basegfx/inc/basegfx/tuple/b3ituple.hxx
index a822702ce87f..da3dc231dfc6 100644
--- a/basegfx/inc/basegfx/tuple/b3ituple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3ituple.hxx
@@ -205,12 +205,6 @@ namespace basegfx
             return B3ITuple(-mnX, -mnY, -mnZ);
         }
 
-        bool equalZero() const
-        {
-            return (this == &getEmptyTuple() ||
-                (mnX == 0 && mnY == 0 && mnZ == 0));
-        }
-
         bool operator==( const B3ITuple& rTup ) const
         {
             return this == &rTup || (rTup.mnX == mnX && rTup.mnY == mnY && rTup.mnZ == mnZ);
@@ -228,8 +222,6 @@ namespace basegfx
             mnZ = rTup.mnZ;
             return *this;
         }
-
-        static const B3ITuple& getEmptyTuple();
     };
 
     // external operators
diff --git a/basegfx/inc/basegfx/vector/b2dvector.hxx b/basegfx/inc/basegfx/vector/b2dvector.hxx
index 174dd5aac7e3..109f64602c24 100644
--- a/basegfx/inc/basegfx/vector/b2dvector.hxx
+++ b/basegfx/inc/basegfx/vector/b2dvector.hxx
@@ -142,14 +142,6 @@ namespace basegfx
         */
         B2DVector& normalize();
 
-        /** Test if this 2D Vector is normalized
-
-            @return
-            true if lenth of vector is equal to 1.0
-            false else
-        */
-        bool isNormalized() const;
-
         /** Calculate the Scalar with another 2D Vector
 
             @param rVec
diff --git a/basegfx/inc/basegfx/vector/b2ivector.hxx b/basegfx/inc/basegfx/vector/b2ivector.hxx
index 2fcbc540b755..e1df2b49750d 100644
--- a/basegfx/inc/basegfx/vector/b2ivector.hxx
+++ b/basegfx/inc/basegfx/vector/b2ivector.hxx
@@ -141,20 +141,6 @@ namespace basegfx
     // external operators
     //////////////////////////////////////////////////////////////////////////
 
-    /** Test two vectors which need not to be normalized for parallelism
-
-        @param rVecA
-        The first 2D Vector
-
-        @param rVecB
-        The second 2D Vector
-
-        @return
-        bool if the two values are parallel. Also true if
-        one of the vectors is empty.
-    */
-    BASEGFX_DLLPUBLIC bool areParallel( const B2IVector& rVecA, const B2IVector& rVecB );
-
     /** Transform vector by given transformation matrix.
 
         Since this is a vector, translational components of the
diff --git a/basegfx/inc/basegfx/vector/b3ivector.hxx b/basegfx/inc/basegfx/vector/b3ivector.hxx
index 4dea54bc747c..42760d6dd90d 100644
--- a/basegfx/inc/basegfx/vector/b3ivector.hxx
+++ b/basegfx/inc/basegfx/vector/b3ivector.hxx
@@ -220,11 +220,6 @@ namespace basegfx
             matrix are disregarded.
         */
         B3IVector& operator*=( const B3DHomMatrix& rMat );
-
-        static const B3IVector& getEmptyVector()
-        {
-            return (const B3IVector&) ::basegfx::B3ITuple::getEmptyTuple();
-        }
     };
 
     // external operators
diff --git a/basegfx/source/matrix/b2dhommatrixtools.cxx b/basegfx/source/matrix/b2dhommatrixtools.cxx
index 574653446b34..2612d9f1e265 100644
--- a/basegfx/source/matrix/b2dhommatrixtools.cxx
+++ b/basegfx/source/matrix/b2dhommatrixtools.cxx
@@ -34,32 +34,6 @@
 
 namespace basegfx
 {
-    ::rtl::OUString exportToSvg( const B2DHomMatrix& rMatrix )
-    {
-        rtl::OUStringBuffer aStrBuf;
-        aStrBuf.appendAscii("matrix(");
-
-        aStrBuf.append(rMatrix.get(0,0));
-        aStrBuf.appendAscii(", ");
-
-        aStrBuf.append(rMatrix.get(1,0));
-        aStrBuf.appendAscii(", ");
-
-        aStrBuf.append(rMatrix.get(0,1));
-        aStrBuf.appendAscii(", ");
-
-        aStrBuf.append(rMatrix.get(1,1));
-        aStrBuf.appendAscii(", ");
-
-        aStrBuf.append(rMatrix.get(0,2));
-        aStrBuf.appendAscii(", ");
-
-        aStrBuf.append(rMatrix.get(1,2));
-        aStrBuf.appendAscii(")");
-
-        return aStrBuf.makeStringAndClear();
-    }
-
     namespace tools
     {
         void createSinCosOrthogonal(double& o_rSin, double& o_rCos, double fRadiant)
diff --git a/basegfx/source/polygon/b2dpolygon.cxx b/basegfx/source/polygon/b2dpolygon.cxx
index a7749220931c..3d7b9487ccb4 100644
--- a/basegfx/source/polygon/b2dpolygon.cxx
+++ b/basegfx/source/polygon/b2dpolygon.cxx
@@ -1484,30 +1484,6 @@ namespace basegfx
         return mpPolygon->getB2DRange(*this);
     }
 
-    void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
-    {
-        OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
-
-        if(rPoly.count())
-        {
-            if(!nCount)
-            {
-                nCount = rPoly.count();
-            }
-
-            if(0 == nIndex2 && nCount == rPoly.count())
-            {
-                mpPolygon->insert(nIndex, *rPoly.mpPolygon);
-            }
-            else
-            {
-                OSL_ENSURE(nIndex2 + nCount <= rPoly.mpPolygon->count(), "B2DPolygon Insert outside range (!)");
-                ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
-                mpPolygon->insert(nIndex, aTempPoly);
-            }
-        }
-    }
-
     void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
     {
         if(rPoly.count())
diff --git a/basegfx/source/polygon/b3dpolygon.cxx b/basegfx/source/polygon/b3dpolygon.cxx
index 5e0ed37c3bb7..8b802b4590fb 100644
--- a/basegfx/source/polygon/b3dpolygon.cxx
+++ b/basegfx/source/polygon/b3dpolygon.cxx
@@ -1557,11 +1557,6 @@ namespace basegfx
         return *this;
     }
 
-    void B3DPolygon::makeUnique()
-    {
-        mpPolygon.make_unique();
-    }
-
     bool B3DPolygon::operator==(const B3DPolygon& rPolygon) const
     {
         if(mpPolygon.same_object(rPolygon.mpPolygon))
diff --git a/basegfx/source/polygon/b3dpolypolygon.cxx b/basegfx/source/polygon/b3dpolypolygon.cxx
index 9291c4a3e601..f4bcf80fc24c 100644
--- a/basegfx/source/polygon/b3dpolypolygon.cxx
+++ b/basegfx/source/polygon/b3dpolypolygon.cxx
@@ -186,13 +186,6 @@ public:
         }
     }
 
-    void makeUnique()
-    {
-        std::for_each( maPolygons.begin(),
-                       maPolygons.end(),
-                       std::mem_fun_ref( &::basegfx::B3DPolygon::makeUnique ));
-    }
-
     const basegfx::B3DPolygon* begin() const
     {
         if(maPolygons.empty())
@@ -385,23 +378,6 @@ namespace basegfx
         mpPolyPolygon = DefaultPolyPolygon::get();
     }
 
-    bool B3DPolyPolygon::isClosed() const
-    {
-        bool bRetval(true);
-
-        // PolyPOlygon is closed when all contained Polygons are closed or
-        // no Polygon exists.
-        for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
-        {
-            if(!(mpPolyPolygon->getB3DPolygon(a)).isClosed())
-            {
-                bRetval = false;
-            }
-        }
-
-        return bRetval;
-    }
-
     void B3DPolyPolygon::flip()
     {
         mpPolyPolygon->flip();
diff --git a/basegfx/source/range/b1drange.cxx b/basegfx/source/range/b1drange.cxx
index 402d56b123c0..0d6bd142e405 100644
--- a/basegfx/source/range/b1drange.cxx
+++ b/basegfx/source/range/b1drange.cxx
@@ -32,24 +32,6 @@
 
 namespace basegfx
 {
-    B1DRange::B1DRange( const B1IRange& rRange ) :
-        maRange()
-    {
-        if( !rRange.isEmpty() )
-        {
-            maRange = rRange.getMinimum();
-            expand(rRange.getMaximum());
-        }
-    }
-
-    B1IRange fround(const B1DRange& rRange)
-    {
-        return rRange.isEmpty() ?
-            B1IRange() :
-            B1IRange( fround( rRange.getMinimum()),
-                      fround( rRange.getMaximum()) );
-    }
-
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/range/b2drange.cxx b/basegfx/source/range/b2drange.cxx
index 2da38ce2dbc3..5884b7e564f4 100644
--- a/basegfx/source/range/b2drange.cxx
+++ b/basegfx/source/range/b2drange.cxx
@@ -60,13 +60,6 @@ namespace basegfx
         }
     }
 
-    B2IRange fround(const B2DRange& rRange)
-    {
-        return rRange.isEmpty() ?
-            B2IRange() :
-            B2IRange(fround(rRange.getMinimum()),
-                     fround(rRange.getMaximum()));
-    }
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/range/b3drange.cxx b/basegfx/source/range/b3drange.cxx
index fb29c917c19e..65643939950c 100644
--- a/basegfx/source/range/b3drange.cxx
+++ b/basegfx/source/range/b3drange.cxx
@@ -33,23 +33,6 @@
 
 namespace basegfx
 {
-    B3DRange::B3DRange(const B3IRange& rRange) :
-        maRangeX(),
-        maRangeY(),
-        maRangeZ()
-    {
-        if( !rRange.isEmpty() )
-        {
-            maRangeX = rRange.getMinX();
-            maRangeY = rRange.getMinY();
-            maRangeZ = rRange.getMinZ();
-
-            maRangeX.expand( rRange.getMaxX() );
-            maRangeY.expand( rRange.getMaxY() );
-            maRangeZ.expand( rRange.getMaxZ() );
-        }
-    }
-
     void B3DRange::transform(const B3DHomMatrix& rMatrix)
     {
         if(!isEmpty() && !rMatrix.isIdentity())
@@ -67,18 +50,6 @@ namespace basegfx
         }
     }
 
-    B3IRange fround(const B3DRange& rRange )
-    {
-        return rRange.isEmpty() ?
-            B3IRange() :
-            B3IRange(fround(rRange.getMinX()),
-                     fround(rRange.getMinY()),
-                     fround(rRange.getMinZ()),
-                     fround(rRange.getMaxX()),
-                     fround(rRange.getMaxY()),
-                     fround(rRange.getMaxZ()));
-    }
-
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/tools/canvastools.cxx b/basegfx/source/tools/canvastools.cxx
index 18e0ad342b1f..5743c306715e 100644
--- a/basegfx/source/tools/canvastools.cxx
+++ b/basegfx/source/tools/canvastools.cxx
@@ -510,45 +510,6 @@ namespace basegfx
                                         rRectangle.X2, rRectangle.Y2 );
         }
 
-        awt::Size awtSizeFromB2ISize( const ::basegfx::B2IVector& rVec )
-        {
-            return awt::Size( rVec.getX(),
-                              rVec.getY() );
-        }
-
-        awt::Point awtPointFromB2IPoint( const ::basegfx::B2IPoint& rPoint )
-        {
-            return awt::Point( rPoint.getX(),
-                               rPoint.getY() );
-        }
-
-        awt::Rectangle awtRectangleFromB2IRectangle( const ::basegfx::B2IRange& rRect )
-        {
-            OSL_ENSURE( rRect.getWidth() < ::std::numeric_limits< sal_Int32 >::max() &&
-                        rRect.getWidth() > ::std::numeric_limits< sal_Int32 >::min(),
-                        "awtRectangleFromB2IRectangle(): width overflow" );
-            OSL_ENSURE( rRect.getHeight() < ::std::numeric_limits< sal_Int32 >::max() &&
-                        rRect.getHeight() > ::std::numeric_limits< sal_Int32 >::min(),
-                        "awtRectangleFromB2IRectangle(): height overflow" );
-
-            return awt::Rectangle( rRect.getMinX(),
-                                   rRect.getMinY(),
-                                   static_cast< sal_Int32 >(rRect.getWidth()),
-                                   static_cast< sal_Int32 >(rRect.getHeight()) );
-        }
-
-        ::basegfx::B2IVector b2ISizeFromAwtSize( const awt::Size& rSize )
-        {
-            return ::basegfx::B2IVector( rSize.Width,
-                                         rSize.Height );
-        }
-
-        ::basegfx::B2IPoint b2IPointFromAwtPoint( const awt::Point& rPoint )
-        {
-            return ::basegfx::B2IPoint( rPoint.X,
-                                        rPoint.Y );
-        }
-
         ::basegfx::B2IRange b2IRectangleFromAwtRectangle( const awt::Rectangle& rRect )
         {
             return ::basegfx::B2IRange( rRect.X,
@@ -581,23 +542,6 @@ namespace basegfx
                                         ceil(rRange.getMaxY()) );
         }
 
-        // Geometry comparisons
-        // ===================================================================
-
-        bool awtSizeAreEqual( const ::com::sun::star::awt::Size& rA, const ::com::sun::star::awt::Size& rB )
-        {
-            return (rA.Width == rB.Width && rA.Height == rB.Height);
-        }
-
-        bool awtPointAreEqual( const ::com::sun::star::awt::Point& rA, const ::com::sun::star::awt::Point& rB )
-        {
-            return (rA.X == rB.X && rA.Y == rB.Y);
-        }
-
-        bool awtRectangleAreEqual( const ::com::sun::star::awt::Rectangle& rA, const ::com::sun::star::awt::Rectangle& rB )
-        {
-            return (rA.X == rB.X && rA.Y == rB.Y && rA.Width == rB.Width && rA.Height == rB.Height);
-        }
     } // namespace bgfxtools
 
 } // namespace canvas
diff --git a/basegfx/source/tools/unopolypolygon.cxx b/basegfx/source/tools/unopolypolygon.cxx
index 80203c2587bc..2ffaabd149c4 100644
--- a/basegfx/source/tools/unopolypolygon.cxx
+++ b/basegfx/source/tools/unopolypolygon.cxx
@@ -445,11 +445,6 @@ namespace unotools
         return aSubsetPoly;
     }
 
-    B2DPolyPolygon UnoPolyPolygon::getPolyPolygonUnsafe() const
-    {
-        return maPolyPoly;
-    }
-
 #define IMPLEMENTATION_NAME "gfx::internal::UnoPolyPolygon"
 #define SERVICE_NAME "com.sun.star.rendering.PolyPolygon2D"
     ::rtl::OUString SAL_CALL UnoPolyPolygon::getImplementationName() throw( uno::RuntimeException )
diff --git a/basegfx/source/tuple/b2i64tuple.cxx b/basegfx/source/tuple/b2i64tuple.cxx
index fc60871f8065..9b97c4ba98e5 100644
--- a/basegfx/source/tuple/b2i64tuple.cxx
+++ b/basegfx/source/tuple/b2i64tuple.cxx
@@ -33,11 +33,6 @@ namespace { struct EmptyTuple : public rtl::Static<basegfx::B2I64Tuple, EmptyTup
 
 namespace basegfx
 {
-    const B2I64Tuple& B2I64Tuple::getEmptyTuple()
-    {
-        return EmptyTuple::get();
-    }
-
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/tuple/b2ituple.cxx b/basegfx/source/tuple/b2ituple.cxx
index e4bd0fba77c4..f0c22caddeb5 100644
--- a/basegfx/source/tuple/b2ituple.cxx
+++ b/basegfx/source/tuple/b2ituple.cxx
@@ -34,11 +34,6 @@ namespace { struct EmptyTuple : public rtl::Static<basegfx::B2ITuple, EmptyTuple
 
 namespace basegfx
 {
-    const B2ITuple& B2ITuple::getEmptyTuple()
-    {
-            return EmptyTuple::get();
-    }
-
     // external operators
     //////////////////////////////////////////////////////////////////////////
 
diff --git a/basegfx/source/tuple/b3dtuple.cxx b/basegfx/source/tuple/b3dtuple.cxx
index b4adf02928e3..2e0d91a14cc5 100644
--- a/basegfx/source/tuple/b3dtuple.cxx
+++ b/basegfx/source/tuple/b3dtuple.cxx
@@ -39,12 +39,6 @@ namespace basegfx
         return EmptyTuple::get();
     }
 
-    B3DTuple::B3DTuple(const B3ITuple& rTup)
-    :   mfX( rTup.getX() ),
-        mfY( rTup.getY() ),
-        mfZ( rTup.getZ() )
-    {}
-
     B3ITuple fround(const B3DTuple& rTup)
     {
         return B3ITuple(fround(rTup.getX()), fround(rTup.getY()), fround(rTup.getZ()));
diff --git a/basegfx/source/tuple/b3i64tuple.cxx b/basegfx/source/tuple/b3i64tuple.cxx
index 630d85218f14..0ee8cdffa8ec 100644
--- a/basegfx/source/tuple/b3i64tuple.cxx
+++ b/basegfx/source/tuple/b3i64tuple.cxx
@@ -33,10 +33,6 @@ namespace { struct EmptyTuple : public rtl::Static<basegfx::B3I64Tuple, EmptyTup
 
 namespace basegfx
 {
-    const B3I64Tuple& B3I64Tuple::getEmptyTuple()
-    {
-        return EmptyTuple::get();
-    }
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/tuple/b3ituple.cxx b/basegfx/source/tuple/b3ituple.cxx
index ec1ecc3ea9f8..aff58e8b653e 100644
--- a/basegfx/source/tuple/b3ituple.cxx
+++ b/basegfx/source/tuple/b3ituple.cxx
@@ -33,10 +33,6 @@ namespace { struct EmptyTuple : public rtl::Static<basegfx::B3ITuple, EmptyTuple
 
 namespace basegfx
 {
-    const B3ITuple& B3ITuple::getEmptyTuple()
-    {
-        return EmptyTuple::get();
-    }
 } // end of namespace basegfx
 
 // eof
diff --git a/basegfx/source/vector/b2dvector.cxx b/basegfx/source/vector/b2dvector.cxx
index f34e8f4e13c5..296252726cad 100644
--- a/basegfx/source/vector/b2dvector.cxx
+++ b/basegfx/source/vector/b2dvector.cxx
@@ -135,14 +135,6 @@ namespace basegfx
         return *this;
     }
 
-    bool B2DVector::isNormalized() const
-    {
-        const double fOne(1.0);
-        const double fScalar(scalar(*this));
-
-        return fTools::equal(fOne, fScalar);
-    }
-
     bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB )
     {
         const double fValA(rVecA.getX() * rVecB.getY());
diff --git a/basegfx/source/vector/b2ivector.cxx b/basegfx/source/vector/b2ivector.cxx
index bb3ac61ee75b..cac7821040fe 100644
--- a/basegfx/source/vector/b2ivector.cxx
+++ b/basegfx/source/vector/b2ivector.cxx
@@ -74,12 +74,6 @@ namespace basegfx
         return *this;
     }
 
-    bool areParallel( const B2IVector& rVecA, const B2IVector& rVecB )
-    {
-        double fVal(rVecA.getX() * rVecB.getY() - rVecA.getY() * rVecB.getX());
-        return ::basegfx::fTools::equalZero(fVal);
-    }
-
     B2IVector operator*( const B2DHomMatrix& rMat, const B2IVector& rVec )
     {
         B2IVector aRes( rVec );
diff --git a/unusedcode.easy b/unusedcode.easy
index ab56dea6bd37..15364fe0bca2 100644
--- a/unusedcode.easy
+++ b/unusedcode.easy
@@ -813,23 +813,7 @@ avmedia::priv::MediaWindowBaseImpl::setRate(double)
 avmedia::priv::MediaWindowBaseImpl::setStopTime(double)
 basebmp::BitmapDevice::setDamageTracker(boost::shared_ptr<basebmp::IBitmapDeviceDamageTracker> const&)
 basebmp::debugDump(boost::shared_ptr<basebmp::BitmapDevice> const&, std::basic_ostream<char, std::char_traits<char> >&)
-basegfx::B1DRange::B1DRange(basegfx::B1IRange const&)
-basegfx::B2DPolygon::insert(unsigned int, basegfx::B2DPolygon const&, unsigned int, unsigned int)
-basegfx::B2DVector::isNormalized() const
-basegfx::B2I64Tuple::getEmptyTuple()
-basegfx::B2ITuple::getEmptyTuple()
-basegfx::B3DPolyPolygon::isClosed() const
-basegfx::B3DPolygon::makeUnique()
-basegfx::B3DRange::B3DRange(basegfx::B3IRange const&)
-basegfx::B3DTuple::B3DTuple(basegfx::B3ITuple const&)
-basegfx::B3I64Tuple::getEmptyTuple()
-basegfx::B3ITuple::getEmptyTuple()
-basegfx::areParallel(basegfx::B2IVector const&, basegfx::B2IVector const&)
 basegfx::computeSetDifference(std::__debug::vector<basegfx::B2IBox, std::allocator<basegfx::B2IBox> >&, basegfx::B2IBox const&, basegfx::B2IBox const&)
-basegfx::exportToSvg(basegfx::B2DHomMatrix const&)
-basegfx::fround(basegfx::B1DRange const&)
-basegfx::fround(basegfx::B2DRange const&)
-basegfx::fround(basegfx::B3DRange const&)
 basegfx::tools::addPointsAtCuts(basegfx::B2DPolygon const&)
 basegfx::tools::addPointsAtCutsAndTouches(basegfx::B2DPolyPolygon const&, basegfx::B2DPolygon const&)
 basegfx::tools::applyLineDashing(basegfx::B3DPolyPolygon const&, std::__debug::vector<double, std::allocator<double> > const&, basegfx::B3DPolyPolygon*, basegfx::B3DPolyPolygon*, double)
@@ -861,15 +845,6 @@ basegfx::tools::reSegmentPolyPolygonEdges(basegfx::B2DPolyPolygon const&, unsign
 basegfx::tools::rotateAroundPoint(basegfx::B2DPolyPolygon const&, basegfx::B2DPoint const&, double)
 basegfx::tools::setContinuity(basegfx::B2DPolyPolygon const&, basegfx::B2VectorContinuity)
 basegfx::tools::solveCrossovers(basegfx::B2DPolygon const&)
-basegfx::unotools::UnoPolyPolygon::getPolyPolygonUnsafe() const
-basegfx::unotools::awtPointAreEqual(com::sun::star::awt::Point const&, com::sun::star::awt::Point const&)
-basegfx::unotools::awtPointFromB2IPoint(basegfx::B2IPoint const&)
-basegfx::unotools::awtRectangleAreEqual(com::sun::star::awt::Rectangle const&, com::sun::star::awt::Rectangle const&)
-basegfx::unotools::awtRectangleFromB2IRectangle(basegfx::B2IRange const&)
-basegfx::unotools::awtSizeAreEqual(com::sun::star::awt::Size const&, com::sun::star::awt::Size const&)
-basegfx::unotools::awtSizeFromB2ISize(basegfx::B2IVector const&)
-basegfx::unotools::b2IPointFromAwtPoint(com::sun::star::awt::Point const&)
-basegfx::unotools::b2ISizeFromAwtSize(com::sun::star::awt::Size const&)
 basic::ScriptExtensionIterator::implGetScriptPackageFromPackage(com::sun::star::uno::Reference<com::sun::star::deployment::XPackage>, bool&)
 basic::vba::getCurrentDirectory(com::sun::star::uno::Reference<com::sun::star::frame::XModel> const&)
 binfilter::B3dEdgeEntryBucketMemArr::Insert(binfilter::B3dEdgeEntryBucketMemArr const*, unsigned short, unsigned short, unsigned short)