Remove unused code

12 files changed, 0 insertions, 605 deletions

diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
index e53a598ba967..cf49df05ce85 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
@@ -56,8 +56,6 @@ namespace basegfx
             multiplications
          */
         BASEGFX_DLLPUBLIC B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY);
-        BASEGFX_DLLPUBLIC B2DHomMatrix createShearXB2DHomMatrix(double fShearX);
-        BASEGFX_DLLPUBLIC B2DHomMatrix createShearYB2DHomMatrix(double fShearY);
         BASEGFX_DLLPUBLIC B2DHomMatrix createRotateB2DHomMatrix(double fRadiant);
         BASEGFX_DLLPUBLIC B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY);
 
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
index 1bee9b38f124..86c31f3d5f7c 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
@@ -154,23 +154,6 @@ namespace basegfx
         #define CUTFLAG_ALL         (CUTFLAG_LINE|CUTFLAG_START1|CUTFLAG_START2|CUTFLAG_END1|CUTFLAG_END2)
         #define CUTFLAG_DEFAULT     (CUTFLAG_LINE|CUTFLAG_START2|CUTFLAG_END2)
 
-        // Calculate cut between the points given by the two indices. pCut1
-        // and pCut2 will contain the cut coordinate on each edge in ]0.0, 1.0]
-        // (if given) and the return value will contain a cut description.
-        BASEGFX_DLLPUBLIC CutFlagValue findCut(
-            const B2DPolygon& rCandidate,
-            sal_uInt32 nIndex1, sal_uInt32 nIndex2,
-            CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
-            double* pCut1 = 0L, double* pCut2 = 0L);
-
-        // This version is working with two indexed edges from different
-        // polygons.
-        BASEGFX_DLLPUBLIC CutFlagValue findCut(
-            const B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
-            const B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
-            CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
-            double* pCut1 = 0L, double* pCut2 = 0L);
-
         // This version works with two points and vectors to define the
         // edges for the cut test.
         BASEGFX_DLLPUBLIC CutFlagValue findCut(
@@ -245,17 +228,6 @@ namespace basegfx
             @param rRect
             The rectangle which describes the polygon size
 
-            @param fRadius
-            Radius of the edge rounding, relative to the rectangle size. 0.0 means no
-            rounding, 1.0 will lead to an ellipse
-         */
-        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadius );
-
-        /** Create a polygon from a rectangle.
-
-            @param rRect
-            The rectangle which describes the polygon size
-
             @param fRadiusX
             @param fRadiusY
             Radius of the edge rounding, relative to the rectangle size. 0.0 means no
@@ -340,11 +312,6 @@ namespace basegfx
         // matrix and the resulting x,y is used to form the new polygon.
         BASEGFX_DLLPUBLIC B2DPolygon createB2DPolygonFromB3DPolygon(const B3DPolygon& rCandidate, const B3DHomMatrix& rMat);
 
-        // create simplified version of the original polygon by
-        // replacing segments with spikes/loops and self intersections
-        // by several trivial sub-segments
-        BASEGFX_DLLPUBLIC B2DPolygon createSimplifiedPolygon(const B2DPolygon&);
-
         // calculate the smallest distance to given edge and return. The relative position on the edge is returned in Cut.
         // That position is in the range [0.0 .. 1.0] and the returned distance is adapted accordingly to the start or end
         // point of the edge
@@ -422,8 +389,6 @@ namespace basegfx
         // organisation, e.g. same amount of points
         BASEGFX_DLLPUBLIC B2DPolygon interpolate(const B2DPolygon& rOld1, const B2DPolygon& rOld2, double t);
 
-        BASEGFX_DLLPUBLIC bool isPolyPolygonEqualRectangle( const B2DPolyPolygon& rPolyPoly, const B2DRange& rRect );
-
         // #i76891# Try to remove existing curve segments if they are simply edges
         BASEGFX_DLLPUBLIC B2DPolygon simplifyCurveSegments(const B2DPolygon& rCandidate);
 
@@ -479,32 +444,9 @@ namespace basegfx
         */
         BASEGFX_DLLPUBLIC B2DPolygon createWaveline(const B2DPolygon& rCandidate, double fWaveWidth, double fWaveHeight);
 
-        /** split each edge of a polygon in exactly nSubEdges equidistant edges
-
-            @param rCandidate
-            The source polygon. If too small (no edges), nSubEdges too small (<2)
-            or neither bHandleCurvedEdgesnor bHandleStraightEdges it will just be returned.
-            Else for each edge nSubEdges will be created. Closed state is preserved.
-
-            @param nSubEdges
-            How many edges shall be created as replacement for each single edge
-
-            @param bHandleCurvedEdges
-            Process curved edges or not. If to handle the curved edges will be splitted
-            into nSubEdges part curved edges of equidistant bezier distances. If not,
-            curved edges will just be copied.
-
-            @param bHandleStraightEdges
-            Process straight edges or not. If to handle the straight edges will be splitted
-            into nSubEdges part curved edges of equidistant length. If not,
-            straight edges will just be copied.
-        */
-        BASEGFX_DLLPUBLIC B2DPolygon reSegmentPolygonEdges(const B2DPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges);
-
         //////////////////////////////////////////////////////////////////////
         // comparators with tolerance for 2D Polygons
         BASEGFX_DLLPUBLIC bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB, const double& rfSmallValue);
-        BASEGFX_DLLPUBLIC bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB);
 
         /** snap some polygon coordinates to discrete coordinates
 
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
index 6962596a150e..d36f804a0efa 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
@@ -175,9 +175,6 @@ namespace basegfx
         // corresponding points.
         BASEGFX_DLLPUBLIC B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
 
-        // rotate PolyPolygon around given point with given angle.
-        BASEGFX_DLLPUBLIC B2DPolyPolygon rotateAroundPoint(const B2DPolyPolygon& rCandidate, const B2DPoint& rCenter, double fAngle);
-
         // expand all segments (which are not yet) to curve segments. This is done with setting the control
         // vectors on the 1/3 resp. 2/3 distances on each segment.
         BASEGFX_DLLPUBLIC B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate);
@@ -231,7 +228,6 @@ namespace basegfx
         //////////////////////////////////////////////////////////////////////
         // comparators with tolerance for 2D PolyPolygons
         BASEGFX_DLLPUBLIC bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB, const double& rfSmallValue);
-        BASEGFX_DLLPUBLIC bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
 
         /** snap some polygon coordinates to discrete coordinates
 
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
index defaae80a34a..95e00fb9b6c6 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
@@ -85,11 +85,6 @@ namespace basegfx
         // get length of polygon
         BASEGFX_DLLPUBLIC double getLength(const B3DPolygon& rCandidate);
 
-        // get position on polygon for absolute given distance. If
-        // length is given, it is assumed the correct polygon length, if 0.0 it is calculated
-        // using getLength(...)
-        BASEGFX_DLLPUBLIC B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
-
         /** Apply given LineDashing to given polygon
 
             For a description see applyLineDashing in b2dpolygontoos.hxx
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
index 1ff1b4b094c4..6ccfea1ec50b 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
@@ -148,7 +148,6 @@ namespace basegfx
         //////////////////////////////////////////////////////////////////////
         // comparators with tolerance for 3D PolyPolygons
         BASEGFX_DLLPUBLIC bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB, const double& rfSmallValue);
-        BASEGFX_DLLPUBLIC bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB);
 
     } // end of namespace tools
 } // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/tools/tools.hxx b/basegfx/inc/basegfx/tools/tools.hxx
index c6abc5780ad8..f4ff85d48a05 100644
--- a/basegfx/inc/basegfx/tools/tools.hxx
+++ b/basegfx/inc/basegfx/tools/tools.hxx
@@ -39,30 +39,6 @@ namespace basegfx
 
     namespace tools
     {
-        /** Liang-Barsky 2D line clipping algorithm
-
-            This function clips a line given by two points against the
-            given rectangle. The resulting line is returned in the
-            given points.
-
-            @param io_rStart
-            Start point of the line. On return, contains the clipped
-            start point.
-
-            @param io_rEnd
-            End point of the line. On return, contains the clipped
-            end point.
-
-            @param rClipRect
-            The rectangle to clip against
-
-            @return true, when at least part of the line is visible
-            after the clip, false otherwise
-         */
-        BASEGFX_DLLPUBLIC bool liangBarskyClip2D( ::basegfx::B2DPoint&      io_rStart,
-                                ::basegfx::B2DPoint&        io_rEnd,
-                                const ::basegfx::B2DRange&  rClipRect );
-
         /** Expand given parallelogram, such that it extends beyond
             bound rect in a given direction.
 
diff --git a/basegfx/source/matrix/b2dhommatrixtools.cxx b/basegfx/source/matrix/b2dhommatrixtools.cxx
index 2612d9f1e265..b36731dbb2f0 100644
--- a/basegfx/source/matrix/b2dhommatrixtools.cxx
+++ b/basegfx/source/matrix/b2dhommatrixtools.cxx
@@ -96,30 +96,6 @@ namespace basegfx
             return aRetval;
         }
 
-        B2DHomMatrix createShearXB2DHomMatrix(double fShearX)
-        {
-            B2DHomMatrix aRetval;
-
-            if(!fTools::equalZero(fShearX))
-            {
-                aRetval.set(0, 1, fShearX);
-            }
-
-            return aRetval;
-        }
-
-        B2DHomMatrix createShearYB2DHomMatrix(double fShearY)
-        {
-            B2DHomMatrix aRetval;
-
-            if(!fTools::equalZero(fShearY))
-            {
-                aRetval.set(1, 0, fShearY);
-            }
-
-            return aRetval;
-        }
-
         B2DHomMatrix createRotateB2DHomMatrix(double fRadiant)
         {
             B2DHomMatrix aRetval;
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index 2104a53c5ef6..73f920fea85c 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -979,67 +979,6 @@ namespace basegfx
         }
 
         CutFlagValue findCut(
-            const B2DPolygon& rCandidate,
-            sal_uInt32 nIndex1, sal_uInt32 nIndex2,
-            CutFlagValue aCutFlags,
-            double* pCut1, double* pCut2)
-        {
-            CutFlagValue aRetval(CUTFLAG_NONE);
-            const sal_uInt32 nPointCount(rCandidate.count());
-
-            if(nIndex1 < nPointCount && nIndex2 < nPointCount && nIndex1 != nIndex2)
-            {
-                sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate));
-                sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate));
-
-                const B2DPoint aStart1(rCandidate.getB2DPoint(nIndex1));
-                const B2DPoint aEnd1(rCandidate.getB2DPoint(nEnd1));
-                const B2DVector aVector1(aEnd1 - aStart1);
-
-                const B2DPoint aStart2(rCandidate.getB2DPoint(nIndex2));
-                const B2DPoint aEnd2(rCandidate.getB2DPoint(nEnd2));
-                const B2DVector aVector2(aEnd2 - aStart2);
-
-                aRetval = findCut(
-                    aStart1, aVector1, aStart2, aVector2,
-                    aCutFlags, pCut1, pCut2);
-            }
-
-            return aRetval;
-        }
-
-        CutFlagValue findCut(
-            const B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
-            const B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
-            CutFlagValue aCutFlags,
-            double* pCut1, double* pCut2)
-        {
-            CutFlagValue aRetval(CUTFLAG_NONE);
-            const sal_uInt32 nPointCount1(rCandidate1.count());
-            const sal_uInt32 nPointCount2(rCandidate2.count());
-
-            if(nIndex1 < nPointCount1 && nIndex2 < nPointCount2)
-            {
-                sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate1));
-                sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate2));
-
-                const B2DPoint aStart1(rCandidate1.getB2DPoint(nIndex1));
-                const B2DPoint aEnd1(rCandidate1.getB2DPoint(nEnd1));
-                const B2DVector aVector1(aEnd1 - aStart1);
-
-                const B2DPoint aStart2(rCandidate2.getB2DPoint(nIndex2));
-                const B2DPoint aEnd2(rCandidate2.getB2DPoint(nEnd2));
-                const B2DVector aVector2(aEnd2 - aStart2);
-
-                aRetval = findCut(
-                    aStart1, aVector1, aStart2, aVector2,
-                    aCutFlags, pCut1, pCut2);
-            }
-
-            return aRetval;
-        }
-
-        CutFlagValue findCut(
             const B2DPoint& rEdge1Start, const B2DVector& rEdge1Delta,
             const B2DPoint& rEdge2Start, const B2DVector& rEdge2Delta,
             CutFlagValue aCutFlags,
@@ -1663,32 +1602,6 @@ namespace basegfx
             return false;
         }
 
-        B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadius )
-        {
-            const double fZero(0.0);
-            const double fOne(1.0);
-
-            if(fTools::lessOrEqual(fRadius, fZero))
-            {
-                // no radius, use rectangle
-                return createPolygonFromRect( rRect );
-            }
-            else if(fTools::moreOrEqual(fRadius, fOne))
-            {
-                // full radius, use ellipse
-                const B2DPoint aCenter(rRect.getCenter());
-                const double fRadiusX(rRect.getWidth() / 2.0);
-                const double fRadiusY(rRect.getHeight() / 2.0);
-
-                return createPolygonFromEllipse( aCenter, fRadiusX, fRadiusY );
-            }
-            else
-            {
-                // create rectangle with two radii between ]0.0 .. 1.0[
-                return createPolygonFromRect( rRect, fRadius, fRadius );
-            }
-        }
-
         B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadiusX, double fRadiusY )
         {
             const double fZero(0.0);
@@ -2977,81 +2890,6 @@ namespace basegfx
             return aRetval;
         }
 
-        B2DPolygon reSegmentPolygonEdges(const B2DPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges)
-        {
-            const sal_uInt32 nPointCount(rCandidate.count());
-
-            if(nPointCount < 2 || nSubEdges < 2 || (!bHandleCurvedEdges && !bHandleStraightEdges))
-            {
-                // nothing to do:
-                // - less than two points -> no edge at all
-                // - less than two nSubEdges -> no resegment necessary
-                // - neither bHandleCurvedEdges nor bHandleStraightEdges -> nothing to do
-                return rCandidate;
-            }
-            else
-            {
-                B2DPolygon aRetval;
-                const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1);
-                B2DCubicBezier aCurrentEdge;
-
-                // prepare first edge and add start point to target
-                aCurrentEdge.setStartPoint(rCandidate.getB2DPoint(0));
-                aRetval.append(aCurrentEdge.getStartPoint());
-
-                for(sal_uInt32 a(0); a < nEdgeCount; a++)
-                {
-                    // fill edge
-                    const sal_uInt32 nNextIndex((a + 1) % nPointCount);
-                    aCurrentEdge.setControlPointA(rCandidate.getNextControlPoint(a));
-                    aCurrentEdge.setControlPointB(rCandidate.getPrevControlPoint(nNextIndex));
-                    aCurrentEdge.setEndPoint(rCandidate.getB2DPoint(nNextIndex));
-
-                    if(aCurrentEdge.isBezier())
-                    {
-                        if(bHandleCurvedEdges)
-                        {
-                            for(sal_uInt32 b(nSubEdges); b > 1; b--)
-                            {
-                                const double fSplitPoint(1.0 / b);
-                                B2DCubicBezier aLeftPart;
-
-                                aCurrentEdge.split(fSplitPoint, &aLeftPart, &aCurrentEdge);
-                                aRetval.appendBezierSegment(aLeftPart.getControlPointA(), aLeftPart.getControlPointB(), aLeftPart.getEndPoint());
-                            }
-                        }
-
-                        // copy remaining segment to target
-                        aRetval.appendBezierSegment(aCurrentEdge.getControlPointA(), aCurrentEdge.getControlPointB(), aCurrentEdge.getEndPoint());
-                    }
-                    else
-                    {
-                        if(bHandleStraightEdges)
-                        {
-                            for(sal_uInt32 b(nSubEdges); b > 1; b--)
-                            {
-                                const double fSplitPoint(1.0 / b);
-                                const B2DPoint aSplitPoint(interpolate(aCurrentEdge.getStartPoint(), aCurrentEdge.getEndPoint(), fSplitPoint));
-
-                                aRetval.append(aSplitPoint);
-                                aCurrentEdge.setStartPoint(aSplitPoint);
-                            }
-                        }
-
-                        // copy remaining segment to target
-                        aRetval.append(aCurrentEdge.getEndPoint());
-                    }
-
-                    // prepare next step
-                    aCurrentEdge.setStartPoint(aCurrentEdge.getEndPoint());
-                }
-
-                // copy closed flag and return
-                aRetval.setClosed(rCandidate.isClosed());
-                return aRetval;
-            }
-        }
-
         B2DPolygon interpolate(const B2DPolygon& rOld1, const B2DPolygon& rOld2, double t)
         {
             OSL_ENSURE(rOld1.count() == rOld2.count(), "B2DPolygon interpolate: Different geometry (!)");
@@ -3085,139 +2923,6 @@ namespace basegfx
             }
         }
 
-        bool isPolyPolygonEqualRectangle( const B2DPolyPolygon& rPolyPoly,
-                                          const B2DRange&      rRect )
-        {
-            // exclude some cheap cases first
-            if( rPolyPoly.count() != 1 )
-                return false;
-
-            // fill array with rectangle vertices
-            const B2DPoint aPoints[] =
-              {
-                  B2DPoint(rRect.getMinX(),rRect.getMinY()),
-                  B2DPoint(rRect.getMaxX(),rRect.getMinY()),
-                  B2DPoint(rRect.getMaxX(),rRect.getMaxY()),
-                  B2DPoint(rRect.getMinX(),rRect.getMaxY())
-              };
-
-            const B2DPolygon& rPoly( rPolyPoly.getB2DPolygon(0) );
-            const sal_uInt32 nCount( rPoly.count() );
-            const double epsilon = ::std::numeric_limits<double>::epsilon();
-
-            for(unsigned int j=0; j<4; ++j)
-            {
-                const B2DPoint &p1 = aPoints[j];
-                const B2DPoint &p2 = aPoints[(j+1)%4];
-                bool bPointOnBoundary = false;
-                for( sal_uInt32 i=0; i<nCount; ++i )
-                {
-                    const B2DPoint p(rPoly.getB2DPoint(i));
-
-                    //     1 | x0 y0 1 |
-                    // A = - | x1 y1 1 |
-                    //     2 | x2 y2 1 |
-                    double fDoubleArea = p2.getX()*p.getY() -
-                                         p2.getY()*p.getX() -
-                                         p1.getX()*p.getY() +
-                                         p1.getY()*p.getX() +
-                                         p1.getX()*p2.getY() -
-                                         p1.getY()*p2.getX();
-
-                    if(fDoubleArea < epsilon)
-                    {
-                        bPointOnBoundary=true;
-                        break;
-                    }
-                }
-                if(!(bPointOnBoundary))
-                    return false;
-            }
-
-            return true;
-        }
-
-
-        // create simplified version of the original polygon by
-        // replacing segments with spikes/loops and self intersections
-        // by several trivial sub-segments
-        B2DPolygon createSimplifiedPolygon( const B2DPolygon& rCandidate )
-        {
-            const sal_uInt32 nCount(rCandidate.count());
-
-            if(nCount && rCandidate.areControlPointsUsed())
-            {
-                const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nCount : nCount - 1);
-                B2DPolygon aRetval;
-                B2DCubicBezier aSegment;
-
-                aSegment.setStartPoint(rCandidate.getB2DPoint(0));
-                aRetval.append(aSegment.getStartPoint());
-
-                for(sal_uInt32 a(0); a < nEdgeCount; a++)
-                {
-                    // fill edge
-                    const sal_uInt32 nNextIndex((a + 1) % nCount);
-                    aSegment.setControlPointA(rCandidate.getNextControlPoint(a));
-                    aSegment.setControlPointB(rCandidate.getPrevControlPoint(nNextIndex));
-                    aSegment.setEndPoint(rCandidate.getB2DPoint(nNextIndex));
-
-                    if(aSegment.isBezier())
-                    {
-                        double fExtremumPos(0.0);
-                        sal_uInt32 nExtremumCounter(4);
-
-                        while(nExtremumCounter-- && aSegment.isBezier() && aSegment.getMinimumExtremumPosition(fExtremumPos))
-                        {
-                            // split off left, now extremum-free part and append
-                            B2DCubicBezier aLeft;
-
-                            aSegment.split(fExtremumPos, &aLeft, &aSegment);
-                            aLeft.testAndSolveTrivialBezier();
-                            aSegment.testAndSolveTrivialBezier();
-
-                            if(aLeft.isBezier())
-                            {
-                                aRetval.appendBezierSegment(aLeft.getControlPointA(), aLeft.getControlPointB(), aLeft.getEndPoint());
-                            }
-                            else
-                            {
-                                aRetval.append(aLeft.getEndPoint());
-                            }
-                        }
-
-                        // append (evtl. reduced) rest of Segment
-                        if(aSegment.isBezier())
-                        {
-                            aRetval.appendBezierSegment(aSegment.getControlPointA(), aSegment.getControlPointB(), aSegment.getEndPoint());
-                        }
-                        else
-                        {
-                            aRetval.append(aSegment.getEndPoint());
-                        }
-                    }
-                    else
-                    {
-                        // simple edge, append end point
-                        aRetval.append(aSegment.getEndPoint());
-                    }
-
-                    // prepare next edge
-                    aSegment.setStartPoint(aSegment.getEndPoint());
-                }
-
-                // copy closed flag and check for double points
-                aRetval.setClosed(rCandidate.isClosed());
-                aRetval.removeDoublePoints();
-
-                return aRetval;
-            }
-            else
-            {
-                return rCandidate;
-            }
-        }
-
         // #i76891#
         B2DPolygon simplifyCurveSegments(const B2DPolygon& rCandidate)
         {
@@ -3511,13 +3216,6 @@ namespace basegfx
             return true;
         }
 
-        bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB)
-        {
-            const double fSmallValue(fTools::getSmallValue());
-
-            return equal(rCandidateA, rCandidateB, fSmallValue);
-        }
-
         // snap points of horizontal or vertical edges to discrete values
         B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate)
         {
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index c49f6a8ab3c9..34721d20207d 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -382,21 +382,6 @@ namespace basegfx
             return aRetval;
         }
 
-        B2DPolyPolygon rotateAroundPoint(const B2DPolyPolygon& rCandidate, const B2DPoint& rCenter, double fAngle)
-        {
-            const sal_uInt32 nPolygonCount(rCandidate.count());
-            B2DPolyPolygon aRetval;
-
-            for(sal_uInt32 a(0L); a < nPolygonCount; a++)
-            {
-                const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
-
-                aRetval.append(rotateAroundPoint(aCandidate, rCenter, fAngle));
-            }
-
-            return aRetval;
-        }
-
         B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate)
         {
             const sal_uInt32 nPolygonCount(rCandidate.count());
@@ -533,13 +518,6 @@ namespace basegfx
             return true;
         }
 
-        bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB)
-        {
-            const double fSmallValue(fTools::getSmallValue());
-
-            return equal(rCandidateA, rCandidateB, fSmallValue);
-        }
-
         B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate)
         {
             B2DPolyPolygon aRetval;
diff --git a/basegfx/source/polygon/b3dpolygontools.cxx b/basegfx/source/polygon/b3dpolygontools.cxx
index b31712a04780..65a7f6b800db 100644
--- a/basegfx/source/polygon/b3dpolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolygontools.cxx
@@ -217,105 +217,6 @@ namespace basegfx
             return fRetval;
         }
 
-        B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength)
-        {
-            B3DPoint aRetval;
-            const sal_uInt32 nPointCount(rCandidate.count());
-
-            if(nPointCount > 1L)
-            {
-                sal_uInt32 nIndex(0L);
-                bool bIndexDone(false);
-                const double fZero(0.0);
-                double fEdgeLength(fZero);
-
-                // get length if not given
-                if(fTools::equalZero(fLength))
-                {
-                    fLength = getLength(rCandidate);
-                }
-
-                // handle fDistance < 0.0
-                if(fTools::less(fDistance, fZero))
-                {
-                    if(rCandidate.isClosed())
-                    {
-                        // if fDistance < 0.0 increment with multiple of fLength
-                        sal_uInt32 nCount(sal_uInt32(-fDistance / fLength));
-                        fDistance += double(nCount + 1L) * fLength;
-                    }
-                    else
-                    {
-                        // crop to polygon start
-                        fDistance = fZero;
-                        bIndexDone = true;
-                    }
-                }
-
-                // handle fDistance >= fLength
-                if(fTools::moreOrEqual(fDistance, fLength))
-                {
-                    if(rCandidate.isClosed())
-                    {
-                        // if fDistance >= fLength decrement with multiple of fLength
-                        sal_uInt32 nCount(sal_uInt32(fDistance / fLength));
-                        fDistance -= (double)(nCount) * fLength;
-                    }
-                    else
-                    {
-                        // crop to polygon end
-                        fDistance = fZero;
-                        nIndex = nPointCount - 1L;
-                        bIndexDone = true;
-                    }
-                }
-
-                // look for correct index. fDistance is now [0.0 .. fLength[
-                if(!bIndexDone)
-                {
-                    do
-                    {
-                        // get length of next edge
-                        fEdgeLength = getEdgeLength(rCandidate, nIndex);
-
-                        if(fTools::moreOrEqual(fDistance, fEdgeLength))
-                        {
-                            // go to next edge
-                            fDistance -= fEdgeLength;
-                            nIndex++;
-                        }
-                        else
-                        {
-                            // it's on this edge, stop
-                            bIndexDone = true;
-                        }
-                    } while (!bIndexDone);
-                }
-
-                // get the point using nIndex
-                aRetval = rCandidate.getB3DPoint(nIndex);
-
-                // if fDistance != 0.0, move that length on the edge. The edge
-                // length is in fEdgeLength.
-                if(!fTools::equalZero(fDistance))
-                {
-                    sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
-                    const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
-                    double fRelative(fZero);
-
-                    if(!fTools::equalZero(fEdgeLength))
-                    {
-                        fRelative = fDistance / fEdgeLength;
-                    }
-
-                    // add calculated average value to the return value
-                    aRetval += interpolate(aRetval, aNextPoint, fRelative);
-                }
-            }
-
-            return aRetval;
-        }
-
         void applyLineDashing(const B3DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, B3DPolyPolygon* pGapTarget, double fDotDashLength)
         {
             const sal_uInt32 nPointCount(rCandidate.count());
diff --git a/basegfx/source/polygon/b3dpolypolygontools.cxx b/basegfx/source/polygon/b3dpolypolygontools.cxx
index 62fd440ec0ee..928fb3132921 100644
--- a/basegfx/source/polygon/b3dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolypolygontools.cxx
@@ -540,13 +540,6 @@ namespace basegfx
             return true;
         }
 
-        bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB)
-        {
-            const double fSmallValue(fTools::getSmallValue());
-
-            return equal(rCandidateA, rCandidateB, fSmallValue);
-        }
-
     } // end of namespace tools
 } // end of namespace basegfx
 
diff --git a/basegfx/source/tools/liangbarsky.cxx b/basegfx/source/tools/liangbarsky.cxx
index be2d5e04a429..6b89e85498ce 100644
--- a/basegfx/source/tools/liangbarsky.cxx
+++ b/basegfx/source/tools/liangbarsky.cxx
@@ -69,63 +69,6 @@ namespace basegfx
                 return true;
             }
         }
-
-        // see Foley/vanDam, pp. 122 for the Liang-Barsky line
-        // clipping algorithm
-        bool liangBarskyClip2D( ::basegfx::B2DPoint&        io_rStart,
-                                ::basegfx::B2DPoint&        io_rEnd,
-                                const ::basegfx::B2DRange&  rClipRect )
-        {
-            const double nDX( io_rEnd.getX() - io_rStart.getX() );
-            const double nDY( io_rEnd.getY() - io_rStart.getY() );
-
-            if( ::basegfx::fTools::equalZero( nDX ) &&
-                ::basegfx::fTools::equalZero( nDY ) )
-            {
-                return rClipRect.isInside( io_rStart );
-            }
-            else
-            {
-                double nTE( 0.0 );
-                double nTL( 1.0 );
-                if( liangBarskyClipT(nDX, rClipRect.getMinX() - io_rStart.getX(),
-                                     nTE, nTL ) )                   // inside wrt. left edge
-                {
-                    if( liangBarskyClipT(-nDX, io_rStart.getX() - rClipRect.getMaxX(),
-                                         nTE, nTL ) )               // inside wrt. right edge
-                    {
-                        if( liangBarskyClipT(nDY, rClipRect.getMinY() - io_rStart.getY(),
-                                             nTE, nTL ) )           // inside wrt. bottom edge
-                        {
-                            if( liangBarskyClipT(-nDY, io_rStart.getY() - rClipRect.getMaxY(),
-                                                 nTE, nTL ) )       // inside wrt. top edge
-                            {
-                                // compute actual intersection points,
-                                // if nTL has changed
-                                if( nTL < 1.0 )
-                                {
-                                    io_rEnd.setX( io_rStart.getX() + nTL*nDX );
-                                    io_rEnd.setY( io_rStart.getY() + nTL*nDY );
-                                }
-
-                                // compute actual intersection points,
-                                // if nTE has changed
-                                if( nTE > 0.0 )
-                                {
-                                    io_rStart.setX( io_rStart.getX() + nTE*nDX );
-                                    io_rStart.setY( io_rStart.getY() + nTE*nDY );
-                                }
-
-                                // line is (at least partially) visible
-                                return true;
-                            }
-                        }
-                    }
-                }
-            }
-
-            return false;
-        }
     }
 }