callcatcher: Remove unused code

11 files changed, 2 insertions, 622 deletions

diff --git a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
index cd7e7d9bde9e..5931ce057dbe 100644
--- a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
+++ b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
@@ -55,7 +55,6 @@ namespace basegfx
     public:
         B2DCubicBezier();
         B2DCubicBezier(const B2DCubicBezier& rBezier);
-        B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rEnd);
         B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rControlPointA, const B2DPoint& rControlPointB, const B2DPoint& rEnd);
         ~B2DCubicBezier();
 
diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
index 71596353c829..e296a3d1d0be 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
@@ -56,9 +56,6 @@ namespace basegfx
          */
         B2DHomMatrix(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2);
 
-        /// unshare this matrix with all internally shared instances
-        void makeUnique();
-
         double get(sal_uInt16 nRow, sal_uInt16 nColumn) const;
         void set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue);
 
@@ -78,15 +75,6 @@ namespace basegfx
         bool isInvertible() const;
         bool invert();
 
-        bool isNormalized() const;
-        void normalize();
-
-        double determinant() const;
-
-        double trace() const;
-
-        void transpose();
-
         void rotate(double fRadiant);
 
         void translate(double fX, double fY);
@@ -97,7 +85,6 @@ namespace basegfx
         void shearX(double fSx);
         void shearY(double fSy);
 
-
         B2DHomMatrix& operator+=(const B2DHomMatrix& rMat);
         B2DHomMatrix& operator-=(const B2DHomMatrix& rMat);
 
diff --git a/basegfx/inc/basegfx/range/b2dpolyrange.hxx b/basegfx/inc/basegfx/range/b2dpolyrange.hxx
index 03fc7902a9c7..6cb95a49bc58 100644
--- a/basegfx/inc/basegfx/range/b2dpolyrange.hxx
+++ b/basegfx/inc/basegfx/range/b2dpolyrange.hxx
@@ -67,14 +67,9 @@ namespace basegfx
 
         /** Create a multi range with exactly one containing range
          */
-        explicit B2DPolyRange( const ElementType& rElement );
-        B2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient );
         B2DPolyRange( const B2DPolyRange& );
         B2DPolyRange& operator=( const B2DPolyRange& );
 
-        /// unshare this poly-range with all internally shared instances
-        void makeUnique();
-
         bool operator==(const B2DPolyRange&) const;
         bool operator!=(const B2DPolyRange&) const;
 
@@ -82,44 +77,15 @@ namespace basegfx
         sal_uInt32 count() const;
 
         ElementType getElement(sal_uInt32 nIndex) const;
-        void        setElement(sal_uInt32 nIndex, const ElementType& rElement );
-        void        setElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient );
 
         // insert/append a single range
-        void insertElement(sal_uInt32 nIndex, const ElementType& rElement, sal_uInt32 nCount = 1);
-        void insertElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount = 1);
-        void appendElement(const ElementType& rElement, sal_uInt32 nCount = 1);
         void appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount = 1);
 
         // insert/append multiple ranges
-        void insertPolyRange(sal_uInt32 nIndex, const B2DPolyRange&);
         void appendPolyRange(const B2DPolyRange&);
 
-        void remove(sal_uInt32 nIndex, sal_uInt32 nCount = 1);
         void clear();
 
-        // flip range orientations - converts holes to solids, and vice versa
-        void flip();
-
-        /** Get overall range
-
-            @return
-            The union range of all contained ranges
-        */
-        B2DRange getBounds() const;
-
-        /** Test whether given tuple is inside one or more of the
-            included ranges. Does *not* use overall range, but checks
-            individually.
-         */
-        bool isInside( const B2DTuple& rTuple ) const;
-
-        /** Test whether given range is inside one or more of the
-            included ranges. Does *not* use overall range, but checks
-            individually.
-         */
-        bool isInside( const B2DRange& rRange ) const;
-
         /** Test whether given range overlaps one or more of the
             included ranges. Does *not* use overall range, but checks
             individually.
@@ -130,12 +96,6 @@ namespace basegfx
          */
         B2DPolyPolygon solveCrossovers() const;
 
-        // element iterators (same iterator validity conditions as for vector)
-        const B2DRange* begin() const;
-        const B2DRange* end() const;
-        B2DRange* begin();
-        B2DRange* end();
-
     private:
         o3tl::cow_wrapper< ImplB2DPolyRange > mpImpl;
     };
diff --git a/basegfx/inc/basegfx/tools/b2dclipstate.hxx b/basegfx/inc/basegfx/tools/b2dclipstate.hxx
index 67d6705bb914..30ab4bdc5fce 100644
--- a/basegfx/inc/basegfx/tools/b2dclipstate.hxx
+++ b/basegfx/inc/basegfx/tools/b2dclipstate.hxx
@@ -69,21 +69,12 @@ namespace basegfx
             B2DClipState();
             ~B2DClipState();
             B2DClipState( const B2DClipState& );
-            explicit B2DClipState( const B2DRange& );
-            explicit B2DClipState( const B2DPolygon& );
             explicit B2DClipState( const B2DPolyPolygon& );
             B2DClipState& operator=( const B2DClipState& );
 
-            /// unshare this poly-range with all internally shared instances
-            void makeUnique();
-
             /// Set clip to 'null' - nothing is visible
             void makeNull();
-            /// returns true when clip is 'null' - nothing is visible
-            bool isNull() const;
 
-            /// Set clip 'cleared' - everything is visible
-            void makeClear();
             /// returns true when clip is 'cleared' - everything is visible
             bool isCleared() const;
 
@@ -91,24 +82,16 @@ namespace basegfx
             bool operator!=(const B2DClipState&) const;
 
             void unionRange(const B2DRange& );
-            void unionPolygon(const B2DPolygon& );
             void unionPolyPolygon(const B2DPolyPolygon& );
-            void unionClipState(const B2DClipState& );
 
             void intersectRange(const B2DRange& );
-            void intersectPolygon(const B2DPolygon& );
             void intersectPolyPolygon(const B2DPolyPolygon& );
-            void intersectClipState(const B2DClipState& );
 
             void subtractRange(const B2DRange& );
-            void subtractPolygon(const B2DPolygon& );
             void subtractPolyPolygon(const B2DPolyPolygon& );
-            void subtractClipState(const B2DClipState& );
 
             void xorRange(const B2DRange& );
-            void xorPolygon(const B2DPolygon& );
             void xorPolyPolygon(const B2DPolyPolygon& );
-            void xorClipState(const B2DClipState& );
 
             B2DPolyPolygon getClipPoly() const;
         };
diff --git a/basegfx/source/curve/b2dcubicbezier.cxx b/basegfx/source/curve/b2dcubicbezier.cxx
index aa6d5bb2efcd..dd336bc8d161 100644
--- a/basegfx/source/curve/b2dcubicbezier.cxx
+++ b/basegfx/source/curve/b2dcubicbezier.cxx
@@ -348,14 +348,6 @@ namespace basegfx
     {
     }
 
-    B2DCubicBezier::B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rEnd)
-    :   maStartPoint(rStart),
-        maEndPoint(rEnd),
-        maControlPointA(rStart),
-        maControlPointB(rEnd)
-    {
-    }
-
     B2DCubicBezier::B2DCubicBezier(const B2DPoint& rStart, const B2DPoint& rControlPointA, const B2DPoint& rControlPointB, const B2DPoint& rEnd)
     :   maStartPoint(rStart),
         maEndPoint(rEnd),
diff --git a/basegfx/source/matrix/b2dhommatrix.cxx b/basegfx/source/matrix/b2dhommatrix.cxx
index adc984340b9a..942f313eac10 100644
--- a/basegfx/source/matrix/b2dhommatrix.cxx
+++ b/basegfx/source/matrix/b2dhommatrix.cxx
@@ -76,11 +76,6 @@ namespace basegfx
         return *this;
     }
 
-    void B2DHomMatrix::makeUnique()
-    {
-        mpImpl.make_unique();
-    }
-
     double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
     {
         return mpImpl->get(nRow, nColumn);
@@ -142,32 +137,6 @@ namespace basegfx
         return false;
     }
 
-    bool B2DHomMatrix::isNormalized() const
-    {
-        return mpImpl->isNormalized();
-    }
-
-    void B2DHomMatrix::normalize()
-    {
-        if(!const_cast<const B2DHomMatrix*>(this)->mpImpl->isNormalized())
-            mpImpl->doNormalize();
-    }
-
-    double B2DHomMatrix::determinant() const
-    {
-        return mpImpl->doDeterminant();
-    }
-
-    double B2DHomMatrix::trace() const
-    {
-        return mpImpl->doTrace();
-    }
-
-    void B2DHomMatrix::transpose()
-    {
-        mpImpl->doTranspose();
-    }
-
     B2DHomMatrix& B2DHomMatrix::operator+=(const B2DHomMatrix& rMat)
     {
         mpImpl->doAddMatrix(*rMat.mpImpl);
@@ -449,7 +418,4 @@ namespace basegfx
     }
 } // end of namespace basegfx
 
-///////////////////////////////////////////////////////////////////////////////
-// eof
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basegfx/source/range/b2dpolyrange.cxx b/basegfx/source/range/b2dpolyrange.cxx
index 01b8d4fbe80a..6046f488150d 100644
--- a/basegfx/source/range/b2dpolyrange.cxx
+++ b/basegfx/source/range/b2dpolyrange.cxx
@@ -38,13 +38,6 @@
 #include <algorithm>
 #include <vector>
 
-static basegfx::B2VectorOrientation flipOrientation(
-    basegfx::B2VectorOrientation eOrient)
-{
-    return eOrient == basegfx::ORIENTATION_POSITIVE ?
-        basegfx::ORIENTATION_NEGATIVE : basegfx::ORIENTATION_POSITIVE;
-}
-
 namespace basegfx
 {
     class ImplB2DPolyRange
@@ -68,12 +61,6 @@ namespace basegfx
             maOrient()
         {}
 
-        explicit ImplB2DPolyRange( const B2DPolyRange::ElementType& rElem ) :
-            maBounds( boost::get<0>(rElem) ),
-            maRanges( 1, boost::get<0>(rElem) ),
-            maOrient( 1, boost::get<1>(rElem) )
-        {}
-
         explicit ImplB2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient ) :
             maBounds( rRange ),
             maRanges( 1, rRange ),
@@ -96,41 +83,6 @@ namespace basegfx
                                      maOrient[nIndex]);
         }
 
-        void setElement(sal_uInt32 nIndex, const B2DPolyRange::ElementType& rElement )
-        {
-            maRanges[nIndex] = boost::get<0>(rElement);
-            maOrient[nIndex] = boost::get<1>(rElement);
-            updateBounds();
-        }
-
-        void setElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient )
-        {
-            maRanges[nIndex] = rRange;
-            maOrient[nIndex] = eOrient;
-            updateBounds();
-        }
-
-        void insertElement(sal_uInt32 nIndex, const B2DPolyRange::ElementType& rElement, sal_uInt32 nCount)
-        {
-            maRanges.insert(maRanges.begin()+nIndex, nCount, boost::get<0>(rElement));
-            maOrient.insert(maOrient.begin()+nIndex, nCount, boost::get<1>(rElement));
-            maBounds.expand(boost::get<0>(rElement));
-        }
-
-        void insertElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
-        {
-            maRanges.insert(maRanges.begin()+nIndex, nCount, rRange);
-            maOrient.insert(maOrient.begin()+nIndex, nCount, eOrient);
-            maBounds.expand(rRange);
-        }
-
-        void appendElement(const B2DPolyRange::ElementType& rElement, sal_uInt32 nCount)
-        {
-            maRanges.insert(maRanges.end(), nCount, boost::get<0>(rElement));
-            maOrient.insert(maOrient.end(), nCount, boost::get<1>(rElement));
-            maBounds.expand(boost::get<0>(rElement));
-        }
-
         void appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
         {
             maRanges.insert(maRanges.end(), nCount, rRange);
@@ -138,13 +90,6 @@ namespace basegfx
             maBounds.expand(rRange);
         }
 
-        void insertPolyRange(sal_uInt32 nIndex, const ImplB2DPolyRange& rPolyRange)
-        {
-            maRanges.insert(maRanges.begin()+nIndex, rPolyRange.maRanges.begin(), rPolyRange.maRanges.end());
-            maOrient.insert(maOrient.begin()+nIndex, rPolyRange.maOrient.begin(), rPolyRange.maOrient.end());
-            updateBounds();
-        }
-
         void appendPolyRange(const ImplB2DPolyRange& rPolyRange)
         {
             maRanges.insert(maRanges.end(),
@@ -156,13 +101,6 @@ namespace basegfx
             updateBounds();
         }
 
-        void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
-        {
-            maRanges.erase(maRanges.begin()+nIndex,maRanges.begin()+nIndex+nCount);
-            maOrient.erase(maOrient.begin()+nIndex,maOrient.begin()+nIndex+nCount);
-            updateBounds();
-        }
-
         void clear()
         {
             std::vector<B2DRange> aTmpRanges;
@@ -174,37 +112,6 @@ namespace basegfx
             maBounds.reset();
         }
 
-        void flip()
-        {
-            std::for_each(maOrient.begin(),
-                          maOrient.end(),
-                          boost::bind(
-                              &flipOrientation,
-                              _1));
-        }
-
-        B2DRange getBounds() const
-        {
-            return maBounds;
-        }
-
-        template< typename ValueType > bool isInside( const ValueType& rValue ) const
-        {
-            if( !maBounds.isInside( rValue ) )
-                return false;
-
-            // cannot use boost::bind here, since isInside is overloaded.
-            // It is currently not possible to resolve the overload
-            // by considering one of the other template arguments.
-            std::vector<B2DRange>::const_iterator       aCurr( maRanges.begin() );
-            const std::vector<B2DRange>::const_iterator aEnd ( maRanges.end() );
-            while( aCurr != aEnd )
-                if( aCurr->isInside( rValue ) )
-                    return true;
-
-            return false;
-        }
-
         bool overlaps( const B2DRange& rRange ) const
         {
             if( !maBounds.overlaps( rRange ) )
@@ -223,38 +130,6 @@ namespace basegfx
             return tools::solveCrossovers(maRanges,maOrient);
         }
 
-        const B2DRange* begin() const
-        {
-            if(maRanges.empty())
-                return 0;
-            else
-                return &maRanges.front();
-        }
-
-        const B2DRange* end() const
-        {
-            if(maRanges.empty())
-                return 0;
-            else
-                return (&maRanges.back())+1;
-        }
-
-        B2DRange* begin()
-        {
-            if(maRanges.empty())
-                return 0;
-            else
-                return &maRanges.front();
-        }
-
-        B2DRange* end()
-        {
-            if(maRanges.empty())
-                return 0;
-            else
-                return (&maRanges.back())+1;
-        }
-
     private:
         B2DRange                         maBounds;
         std::vector<B2DRange>            maRanges;
@@ -268,14 +143,6 @@ namespace basegfx
     B2DPolyRange::~B2DPolyRange()
     {}
 
-    B2DPolyRange::B2DPolyRange( const ElementType& rElem ) :
-        mpImpl( ImplB2DPolyRange( rElem ) )
-    {}
-
-    B2DPolyRange::B2DPolyRange( const B2DRange& rRange, B2VectorOrientation eOrient ) :
-        mpImpl( ImplB2DPolyRange( rRange, eOrient ) )
-    {}
-
     B2DPolyRange::B2DPolyRange( const B2DPolyRange& rRange ) :
         mpImpl( rRange.mpImpl )
     {}
@@ -286,11 +153,6 @@ namespace basegfx
         return *this;
     }
 
-    void B2DPolyRange::makeUnique()
-    {
-        mpImpl.make_unique();
-    }
-
     bool B2DPolyRange::operator==(const B2DPolyRange& rRange) const
     {
         if(mpImpl.same_object(rRange.mpImpl))
@@ -314,76 +176,21 @@ namespace basegfx
         return mpImpl->getElement(nIndex);
     }
 
-    void B2DPolyRange::setElement(sal_uInt32 nIndex, const ElementType& rElement )
-    {
-        mpImpl->setElement(nIndex, rElement);
-    }
-
-    void B2DPolyRange::setElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient )
-    {
-        mpImpl->setElement(nIndex, rRange, eOrient );
-    }
-
-    void B2DPolyRange::insertElement(sal_uInt32 nIndex, const ElementType& rElement, sal_uInt32 nCount)
-    {
-        mpImpl->insertElement(nIndex, rElement, nCount );
-    }
-
-    void B2DPolyRange::insertElement(sal_uInt32 nIndex, const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
-    {
-        mpImpl->insertElement(nIndex, rRange, eOrient, nCount );
-    }
-
-    void B2DPolyRange::appendElement(const ElementType& rElement, sal_uInt32 nCount)
-    {
-        mpImpl->appendElement(rElement, nCount);
-    }
-
     void B2DPolyRange::appendElement(const B2DRange& rRange, B2VectorOrientation eOrient, sal_uInt32 nCount)
     {
         mpImpl->appendElement(rRange, eOrient, nCount );
     }
 
-    void B2DPolyRange::insertPolyRange(sal_uInt32 nIndex, const B2DPolyRange& rRange)
-    {
-        mpImpl->insertPolyRange(nIndex, *rRange.mpImpl);
-    }
-
     void B2DPolyRange::appendPolyRange(const B2DPolyRange& rRange)
     {
         mpImpl->appendPolyRange(*rRange.mpImpl);
     }
 
-    void B2DPolyRange::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
-    {
-        mpImpl->remove(nIndex, nCount);
-    }
-
     void B2DPolyRange::clear()
     {
         mpImpl->clear();
     }
 
-    void B2DPolyRange::flip()
-    {
-        mpImpl->flip();
-    }
-
-    B2DRange B2DPolyRange::getBounds() const
-    {
-        return mpImpl->getBounds();
-    }
-
-    bool B2DPolyRange::isInside( const B2DTuple& rTuple ) const
-    {
-        return mpImpl->isInside(rTuple);
-    }
-
-    bool B2DPolyRange::isInside( const B2DRange& rRange ) const
-    {
-        return mpImpl->isInside(rRange);
-    }
-
     bool B2DPolyRange::overlaps( const B2DRange& rRange ) const
     {
         return mpImpl->overlaps(rRange);
@@ -393,29 +200,6 @@ namespace basegfx
     {
         return mpImpl->solveCrossovers();
     }
-
-    const B2DRange* B2DPolyRange::begin() const
-    {
-        return mpImpl->begin();
-    }
-
-    const B2DRange* B2DPolyRange::end() const
-    {
-        return mpImpl->end();
-    }
-
-    B2DRange* B2DPolyRange::begin()
-    {
-        return mpImpl->begin();
-    }
-
-    B2DRange* B2DPolyRange::end()
-    {
-        return mpImpl->end();
-    }
-
 } // end of namespace basegfx
 
-// eof
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basegfx/source/tools/b2dclipstate.cxx b/basegfx/source/tools/b2dclipstate.cxx
index da55a4de1ae5..963dd39f6785 100644
--- a/basegfx/source/tools/b2dclipstate.cxx
+++ b/basegfx/source/tools/b2dclipstate.cxx
@@ -53,21 +53,6 @@ namespace tools
             mePendingOps(UNION)
         {}
 
-        explicit ImplB2DClipState( const B2DRange& rRange ) :
-            maPendingPolygons(),
-            maPendingRanges(),
-            maClipPoly(
-                tools::createPolygonFromRect(rRange)),
-            mePendingOps(UNION)
-        {}
-
-        explicit ImplB2DClipState( const B2DPolygon& rPoly ) :
-            maPendingPolygons(),
-            maPendingRanges(),
-            maClipPoly(rPoly),
-            mePendingOps(UNION)
-        {}
-
         explicit ImplB2DClipState( const B2DPolyPolygon& rPoly ) :
             maPendingPolygons(),
             maPendingRanges(),
@@ -82,14 +67,6 @@ namespace tools
                 && !maPendingRanges.count();
         }
 
-        void makeClear()
-        {
-            maPendingPolygons.clear();
-            maPendingRanges.clear();
-            maClipPoly.clear();
-            mePendingOps = UNION;
-        }
-
         bool isNullClipPoly() const
         {
             return maClipPoly.count() == 1
@@ -183,14 +160,6 @@ namespace tools
             addRange(rRange,UNION);
         }
 
-        void unionPolygon(const B2DPolygon& rPoly)
-        {
-            if( isCleared() )
-                return;
-
-            addPolygon(rPoly,UNION);
-        }
-
         void unionPolyPolygon(const B2DPolyPolygon& rPolyPoly)
         {
             if( isCleared() )
@@ -199,14 +168,6 @@ namespace tools
             addPolyPolygon(rPolyPoly,UNION);
         }
 
-        void unionClipState(const ImplB2DClipState& rOther)
-        {
-            if( isCleared() )
-                return;
-
-            addClipState(rOther, UNION);
-        }
-
         void intersectRange(const B2DRange& rRange)
         {
             if( isNull() )
@@ -215,14 +176,6 @@ namespace tools
             addRange(rRange,INTERSECT);
         }
 
-        void intersectPolygon(const B2DPolygon& rPoly)
-        {
-            if( isNull() )
-                return;
-
-            addPolygon(rPoly,INTERSECT);
-        }
-
         void intersectPolyPolygon(const B2DPolyPolygon& rPolyPoly)
         {
             if( isNull() )
@@ -231,14 +184,6 @@ namespace tools
             addPolyPolygon(rPolyPoly,INTERSECT);
         }
 
-        void intersectClipState(const ImplB2DClipState& rOther)
-        {
-            if( isNull() )
-                return;
-
-            addClipState(rOther, INTERSECT);
-        }
-
         void subtractRange(const B2DRange& rRange )
         {
             if( isNull() )
@@ -247,14 +192,6 @@ namespace tools
             addRange(rRange,SUBTRACT);
         }
 
-        void subtractPolygon(const B2DPolygon& rPoly)
-        {
-            if( isNull() )
-                return;
-
-            addPolygon(rPoly,SUBTRACT);
-        }
-
         void subtractPolyPolygon(const B2DPolyPolygon& rPolyPoly)
         {
             if( isNull() )
@@ -263,34 +200,16 @@ namespace tools
             addPolyPolygon(rPolyPoly,SUBTRACT);
         }
 
-        void subtractClipState(const ImplB2DClipState& rOther)
-        {
-            if( isNull() )
-                return;
-
-            addClipState(rOther, SUBTRACT);
-        }
-
         void xorRange(const B2DRange& rRange)
         {
             addRange(rRange,XOR);
         }
 
-        void xorPolygon(const B2DPolygon& rPoly)
-        {
-            addPolygon(rPoly,XOR);
-        }
-
         void xorPolyPolygon(const B2DPolyPolygon& rPolyPoly)
         {
             addPolyPolygon(rPolyPoly,XOR);
         }
 
-        void xorClipState(const ImplB2DClipState& rOther)
-        {
-            addClipState(rOther, XOR);
-        }
-
         B2DPolyPolygon getClipPoly() const
         {
             commitPendingRanges();
@@ -511,14 +430,6 @@ namespace tools
         mpImpl(rOrig.mpImpl)
     {}
 
-    B2DClipState::B2DClipState( const B2DRange& rRange ) :
-        mpImpl( ImplB2DClipState(rRange) )
-    {}
-
-    B2DClipState::B2DClipState( const B2DPolygon& rPoly ) :
-        mpImpl( ImplB2DClipState(rPoly) )
-    {}
-
     B2DClipState::B2DClipState( const B2DPolyPolygon& rPolyPoly ) :
         mpImpl( ImplB2DClipState(rPolyPoly) )
     {}
@@ -529,26 +440,11 @@ namespace tools
         return *this;
     }
 
-    void B2DClipState::makeUnique()
-    {
-        mpImpl.make_unique();
-    }
-
     void B2DClipState::makeNull()
     {
         mpImpl->makeNull();
     }
 
-    bool B2DClipState::isNull() const
-    {
-        return mpImpl->isNull();
-    }
-
-    void B2DClipState::makeClear()
-    {
-        mpImpl->makeClear();
-    }
-
     bool B2DClipState::isCleared() const
     {
         return mpImpl->isCleared();
@@ -572,81 +468,41 @@ namespace tools
         mpImpl->unionRange(rRange);
     }
 
-    void B2DClipState::unionPolygon(const B2DPolygon& rPoly)
-    {
-        mpImpl->unionPolygon(rPoly);
-    }
-
     void B2DClipState::unionPolyPolygon(const B2DPolyPolygon& rPolyPoly)
     {
         mpImpl->unionPolyPolygon(rPolyPoly);
     }
 
-    void B2DClipState::unionClipState(const B2DClipState& rState)
-    {
-        mpImpl->unionClipState(*rState.mpImpl);
-    }
-
     void B2DClipState::intersectRange(const B2DRange& rRange)
     {
         mpImpl->intersectRange(rRange);
     }
 
-    void B2DClipState::intersectPolygon(const B2DPolygon& rPoly)
-    {
-        mpImpl->intersectPolygon(rPoly);
-    }
-
     void B2DClipState::intersectPolyPolygon(const B2DPolyPolygon& rPolyPoly)
     {
         mpImpl->intersectPolyPolygon(rPolyPoly);
     }
 
-    void B2DClipState::intersectClipState(const B2DClipState& rState)
-    {
-        mpImpl->intersectClipState(*rState.mpImpl);
-    }
-
     void B2DClipState::subtractRange(const B2DRange& rRange)
     {
         mpImpl->subtractRange(rRange);
     }
 
-    void B2DClipState::subtractPolygon(const B2DPolygon& rPoly)
-    {
-        mpImpl->subtractPolygon(rPoly);
-    }
-
     void B2DClipState::subtractPolyPolygon(const B2DPolyPolygon& rPolyPoly)
     {
         mpImpl->subtractPolyPolygon(rPolyPoly);
     }
 
-    void B2DClipState::subtractClipState(const B2DClipState& rState)
-    {
-        mpImpl->subtractClipState(*rState.mpImpl);
-    }
-
     void B2DClipState::xorRange(const B2DRange& rRange)
     {
         mpImpl->xorRange(rRange);
     }
 
-    void B2DClipState::xorPolygon(const B2DPolygon& rPoly)
-    {
-        mpImpl->xorPolygon(rPoly);
-    }
-
     void B2DClipState::xorPolyPolygon(const B2DPolyPolygon& rPolyPoly)
     {
         mpImpl->xorPolyPolygon(rPolyPoly);
     }
 
-    void B2DClipState::xorClipState(const B2DClipState& rState)
-    {
-        mpImpl->xorClipState(*rState.mpImpl);
-    }
-
     B2DPolyPolygon B2DClipState::getClipPoly() const
     {
         return mpImpl->getClipPoly();
@@ -655,6 +511,4 @@ namespace tools
 } // end of namespace tools
 } // end of namespace basegfx
 
-// eof
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/filter/source/svg/b2dellipse.cxx b/filter/source/svg/b2dellipse.cxx
index 802b2f4aac4c..b50f91133a9b 100644
--- a/filter/source/svg/b2dellipse.cxx
+++ b/filter/source/svg/b2dellipse.cxx
@@ -26,82 +26,11 @@
  */
 #include "b2dellipse.hxx"
 
-#include <osl/diagnose.h>
-
 #include <basegfx/point/b2dpoint.hxx>
-
 #include <basegfx/matrix/b2dhommatrix.hxx>
 
-#include <rtl/instance.hxx>
-
-#include <boost/scoped_ptr.hpp>
-#include <vector>
-#include <algorithm>
-
-class ImplB2DEllipse
-{
-     basegfx::B2DPoint maCenter;
-     basegfx::B2DTuple maRadius;
-
-public:
-    ImplB2DEllipse()
-    :   maCenter(0.0f, 0.0f),
-        maRadius(0.0f, 0.0f)
-    {}
-
-    ImplB2DEllipse(const ImplB2DEllipse& rToBeCopied)
-    :   maCenter(rToBeCopied.maCenter),
-        maRadius(rToBeCopied.maRadius)
-    {}
-
-    ImplB2DEllipse& operator=( const ImplB2DEllipse& rToBeCopied )
-    {
-        maCenter = rToBeCopied.maCenter;
-        maRadius = rToBeCopied.maRadius;
-
-        return *this;
-    }
-
-    bool isEqual(const ImplB2DEllipse& rCandidate) const
-    {
-        return (maCenter == rCandidate.maCenter)
-            && (maRadius == rCandidate.maRadius);
-    }
-
-    basegfx::B2DPoint getCenter() const
-    {
-        return maCenter;
-    }
-
-    void setCenter(const basegfx::B2DPoint& rCenter)
-    {
-        maCenter = rCenter;
-    }
-
-    basegfx::B2DTuple getRadius() const
-    {
-        return maRadius;
-    }
-
-    void setRadius(const basegfx::B2DTuple& rRadius)
-    {
-        maRadius = rRadius;
-    }
-
-
-    void transform(const basegfx::B2DHomMatrix& /* rMatrix */)
-    {
-    }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
 namespace basegfx
 {
-
-    B2DEllipse::B2DEllipse()
-    {}
-
     B2DEllipse::B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius)
     :   maCenter(rCenter), maRadius(rRadius)
     {
@@ -126,27 +55,10 @@ namespace basegfx
         return maCenter;
     }
 
-    void B2DEllipse::setB2DEllipseCenter(const basegfx::B2DPoint& rCenter)
-    {
-        maCenter = rCenter;
-    }
-
     basegfx::B2DTuple B2DEllipse::getB2DEllipseRadius() const
     {
         return maRadius;
     }
-
-    void B2DEllipse::setB2DEllipseRadius(const basegfx::B2DTuple& rRadius)
-    {
-        maRadius = rRadius;
-    }
-
-    void B2DEllipse::transform(const basegfx::B2DHomMatrix& /* rMatrix */)
-    {
-    }
 } // end of namespace basegfx
 
-//////////////////////////////////////////////////////////////////////////////
-// eof
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/filter/source/svg/b2dellipse.hxx b/filter/source/svg/b2dellipse.hxx
index dda447d30fc8..0efde7150c9f 100644
--- a/filter/source/svg/b2dellipse.hxx
+++ b/filter/source/svg/b2dellipse.hxx
@@ -37,10 +37,6 @@
 
 #include <basegfx/vector/b2enums.hxx>
 
-//////////////////////////////////////////////////////////////////////////////
-// predeclarations
-class ImplB2DEllipse;
-
 namespace basegfx
 {
     class B2DPoint;
@@ -48,18 +44,15 @@ namespace basegfx
     class B2DHomMatrix;
 } // end of namespace basegfx
 
-//////////////////////////////////////////////////////////////////////////////
-
 namespace basegfx
 {
     class B2DEllipse
     {
     private:
-     basegfx::B2DPoint maCenter;
-     basegfx::B2DTuple maRadius;
+        const basegfx::B2DPoint maCenter;
+        const basegfx::B2DTuple maRadius;
 
     public:
-        B2DEllipse();
         B2DEllipse(const B2DEllipse& rEllipse);
         B2DEllipse(const basegfx::B2DPoint& rCenter, const basegfx::B2DTuple& rRadius);
         ~B2DEllipse();
@@ -73,18 +66,10 @@ namespace basegfx
 
         // Coordinate interface
         basegfx::B2DPoint getB2DEllipseCenter() const;
-        void setB2DEllipseCenter(const basegfx::B2DPoint& rCenter);
-
         basegfx::B2DTuple getB2DEllipseRadius() const;
-        void setB2DEllipseRadius(const basegfx::B2DTuple& rRadius);
-
-        // apply transformation given in matrix form to the Ellipse
-        void transform(const basegfx::B2DHomMatrix& rMatrix);
     };
 } // end of namespace basegfx
 
-//////////////////////////////////////////////////////////////////////////////
-
 #endif /* _BASEGFX_B2DELLIPSE_HXX */
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/unusedcode.easy b/unusedcode.easy
index e30ab2ed5a1f..d583b25e600b 100644
--- a/unusedcode.easy
+++ b/unusedcode.easy
@@ -1037,38 +1037,9 @@ 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::B2DCubicBezier::B2DCubicBezier(basegfx::B2DPoint const&, basegfx::B2DPoint const&)
-basegfx::B2DEllipse::B2DEllipse()
-basegfx::B2DEllipse::setB2DEllipseCenter(basegfx::B2DPoint const&)
-basegfx::B2DEllipse::setB2DEllipseRadius(basegfx::B2DTuple const&)
-basegfx::B2DEllipse::transform(basegfx::B2DHomMatrix const&)
-basegfx::B2DHomMatrix::determinant() const
-basegfx::B2DHomMatrix::isNormalized() const
-basegfx::B2DHomMatrix::makeUnique()
-basegfx::B2DHomMatrix::normalize()
-basegfx::B2DHomMatrix::trace() const
-basegfx::B2DHomMatrix::transpose()
 basegfx::B2DHomPoint::getB2DPoint() const
 basegfx::B2DHomPoint::setX(double)
 basegfx::B2DHomPoint::setY(double)
-basegfx::B2DPolyRange::B2DPolyRange(basegfx::B2DRange const&, basegfx::B2VectorOrientation)
-basegfx::B2DPolyRange::B2DPolyRange(boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&)
-basegfx::B2DPolyRange::appendElement(boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&, unsigned int)
-basegfx::B2DPolyRange::begin()
-basegfx::B2DPolyRange::begin() const
-basegfx::B2DPolyRange::end()
-basegfx::B2DPolyRange::end() const
-basegfx::B2DPolyRange::flip()
-basegfx::B2DPolyRange::getBounds() const
-basegfx::B2DPolyRange::insertElement(unsigned int, basegfx::B2DRange const&, basegfx::B2VectorOrientation, unsigned int)
-basegfx::B2DPolyRange::insertElement(unsigned int, boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&, unsigned int)
-basegfx::B2DPolyRange::insertPolyRange(unsigned int, basegfx::B2DPolyRange const&)
-basegfx::B2DPolyRange::isInside(basegfx::B2DRange const&) const
-basegfx::B2DPolyRange::isInside(basegfx::B2DTuple const&) const
-basegfx::B2DPolyRange::makeUnique()
-basegfx::B2DPolyRange::remove(unsigned int, unsigned int)
-basegfx::B2DPolyRange::setElement(unsigned int, basegfx::B2DRange const&, basegfx::B2VectorOrientation)
-basegfx::B2DPolyRange::setElement(unsigned int, boost::tuples::tuple<basegfx::B2DRange, basegfx::B2VectorOrientation, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type> const&)
 basegfx::B2DPolygon::insert(unsigned int, basegfx::B2DPolygon const&, unsigned int, unsigned int)
 basegfx::B2DPolygon::isBezierSegment(unsigned int) const
 basegfx::B2DPolygon::resetControlPoints(unsigned int)
@@ -1110,19 +1081,6 @@ basegfx::maximum(basegfx::B2DHomPoint const&, basegfx::B2DHomPoint const&)
 basegfx::maximum(basegfx::B2ITuple const&, basegfx::B2ITuple const&)
 basegfx::minimum(basegfx::B2DHomPoint const&, basegfx::B2DHomPoint const&)
 basegfx::minimum(basegfx::B2ITuple const&, basegfx::B2ITuple const&)
-basegfx::tools::B2DClipState::B2DClipState(basegfx::B2DPolygon const&)
-basegfx::tools::B2DClipState::B2DClipState(basegfx::B2DRange const&)
-basegfx::tools::B2DClipState::intersectClipState(basegfx::tools::B2DClipState const&)
-basegfx::tools::B2DClipState::intersectPolygon(basegfx::B2DPolygon const&)
-basegfx::tools::B2DClipState::isNull() const
-basegfx::tools::B2DClipState::makeClear()
-basegfx::tools::B2DClipState::makeUnique()
-basegfx::tools::B2DClipState::subtractClipState(basegfx::tools::B2DClipState const&)
-basegfx::tools::B2DClipState::subtractPolygon(basegfx::B2DPolygon const&)
-basegfx::tools::B2DClipState::unionClipState(basegfx::tools::B2DClipState const&)
-basegfx::tools::B2DClipState::unionPolygon(basegfx::B2DPolygon const&)
-basegfx::tools::B2DClipState::xorClipState(basegfx::tools::B2DClipState const&)
-basegfx::tools::B2DClipState::xorPolygon(basegfx::B2DPolygon const&)
 basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, basegfx::B2DPoint const&, basegfx::B2DPoint const&)
 basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, basegfx::B2DPolyPolygon const&)
 basegfx::tools::addPointsAtCuts(basegfx::B2DPolyPolygon const&, bool)