Remove unused code in basegfx, comphelper

18 files changed, 0 insertions, 479 deletions

diff --git a/basegfx/inc/basegfx/color/bcolortools.hxx b/basegfx/inc/basegfx/color/bcolortools.hxx
index 0bb065937a7f..d5cdcf38490a 100644
--- a/basegfx/inc/basegfx/color/bcolortools.hxx
+++ b/basegfx/inc/basegfx/color/bcolortools.hxx
@@ -50,8 +50,6 @@ namespace basegfx
         /// Transform from HSV to RGB
         BASEGFX_DLLPUBLIC BColor hsv2rgb(const BColor& rHSVColor);
 
-        /// Transform from CIE XYZ into Rec. 709 RGB (D65 white point)
-        BASEGFX_DLLPUBLIC BColor ciexyz2rgb( const BColor& rXYZColor );
         /// Transform from Rec. 709 RGB (D65 white point) into CIE XYZ
         BASEGFX_DLLPUBLIC BColor rgb2ciexyz( const BColor& rRGBColor );
 
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx b/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
index 8997c5476431..1d5c0ffce5af 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
@@ -49,10 +49,6 @@ namespace basegfx
         // Changed: Self intersections are searched by default, but may be switched off by 2nd parameter.
         BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true);
 
-        // look for intersections of rCandidate with all polygons from rMask and add extra points there. Do
-        // not change or add points to rMask.
-        BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolygon& rCandidate);
-
         // look for intersections of rCandidate with the edge from rStart to rEnd and add extra points there.
         // Points are only added in the range of the edge, not on the endless vector.
         BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd);
@@ -61,10 +57,6 @@ namespace basegfx
         // The mask polygon is assumed to be closed, even when it's not explicitly.
         BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPolyPolygon& rMask);
 
-        // look for self-intersections in given polygon and add extra points there. Result will have no
-        // intersections on an edge
-        BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate);
-
     } // end of namespace tools
 } // end of namespace basegfx
 
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
index 86c31f3d5f7c..3fdadbcb4aa6 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
@@ -77,18 +77,6 @@ namespace basegfx
         BASEGFX_DLLPUBLIC bool isInside(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false);
         BASEGFX_DLLPUBLIC bool isInside(const B2DPolygon& rCandidate, const B2DPolygon& rPolygon, bool bWithBorder = false);
 
-        /** Get the range of a polygon including bezier control points
-
-            For detailed discussion, see B2DPolygon::getB2DRange()
-
-            @param rCandidate
-            The B2DPolygon eventually containing bezier segments
-
-            @return
-            The outer range of the bezier curve containing bezier control points
-        */
-        BASEGFX_DLLPUBLIC B2DRange getRangeWithControlPoints(const B2DPolygon& rCandidate);
-
         /** Get the range of a polygon
 
             This method creates the outer range of the subdivided bezier curve.
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
index 007b41623a87..7bf821cb6640 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
@@ -47,11 +47,6 @@ namespace basegfx
         // contained sub-polygons in a preparing step and to explicitly correct their orientations.
         BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate);
 
-        // Version for single polygons. This is for solving self-intersections. Result will be free of
-        // crossovers. When result contains multiple polygons, it may be necessary to rearrange their
-        // orientations since holes may have been created (use correctOrientations eventually).
-        BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate);
-
         // Neutral polygons will be stripped. Neutral polygons are ones who's orientation is
         // neutral, so normally they have no volume -> just closed paths. A polygon with the same
         // positive and negative oriented volume is also neutral, so this may not be wanted. It is
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
index d36f804a0efa..54437bafd0a2 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
@@ -179,9 +179,6 @@ namespace basegfx
         // vectors on the 1/3 resp. 2/3 distances on each segment.
         BASEGFX_DLLPUBLIC B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate);
 
-        // set continuity for the whole curve. If not a curve, nothing will change. Non-curve points are not changed, too.
-        BASEGFX_DLLPUBLIC B2DPolyPolygon setContinuity(const B2DPolyPolygon& rCandidate, B2VectorContinuity eContinuity);
-
         /** Predicate whether a given poly-polygon is a rectangle.
 
             @param rPoly
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx b/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
index f34effe3c3f3..03fd0799e79f 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
@@ -62,9 +62,6 @@ namespace basegfx
         // version for Polygons
         BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
 
-        // version for Polygons
-        BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
-
         // versions for B2DRange, clips only against X,Y
         BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
 
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
index 95e00fb9b6c6..9d66ca5c117e 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
@@ -61,9 +61,6 @@ namespace basegfx
         // is none. Same for successor.
         BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
 
-        // Get orientation of Polygon
-        BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation(const B3DPolygon& rCandidate);
-
         // get size of polygon. Control vectors are included in that ranges.
         BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolygon& rCandidate);
 
@@ -120,12 +117,6 @@ namespace basegfx
          */
         BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
 
-        // test if point is inside epsilon-range around an edge defined
-        // by the two given points. Can be used for HitTesting. The epsilon-range
-        // is defined to be the cylinder centered to the given edge, using radius
-        // fDistance, and the sphere around both points with radius fDistance.
-        BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance);
-
         // isInside tests for B3DPoint. On border is not inside as long as not true is given in bWithBorder flag.
         BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
 
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
index 6ccfea1ec50b..327ef19b3968 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
@@ -51,17 +51,6 @@ namespace basegfx
         // get size of PolyPolygon. Control vectors are included in that ranges.
         BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolyPolygon& rCandidate);
 
-        /** Apply given LineDashing to given polyPolygon
-
-            For a description see applyLineDashing in b2dpolygontoos.hxx
-        */
-        BASEGFX_DLLPUBLIC void applyLineDashing(
-            const B3DPolyPolygon& rCandidate,
-            const ::std::vector<double>& rDotDashArray,
-            B3DPolyPolygon* pLineTarget,
-            B3DPolyPolygon* pGapTarget = 0,
-            double fFullDashDotLen = 0.0);
-
         /** Create a unit 3D line polyPolygon which defines a cube.
          */
         BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitCubePolyPolygon();
diff --git a/basegfx/inc/basegfx/range/b2ibox.hxx b/basegfx/inc/basegfx/range/b2ibox.hxx
index dd23b7058e2e..7c2f9ee1fd91 100644
--- a/basegfx/inc/basegfx/range/b2ibox.hxx
+++ b/basegfx/inc/basegfx/range/b2ibox.hxx
@@ -263,29 +263,6 @@ namespace basegfx
         BasicBox        maRangeY;
     };
 
-    /** Compute the set difference of the two given boxes
-
-        This method calculates the symmetric difference (aka XOR)
-        between the two given boxes, and returning the resulting
-        boxes. Thus, the result will contain all areas where one, but
-        not both boxes lie.
-
-        @param o_rResult
-        Result vector. The up to four difference boxes are returned
-        within this vector
-
-        @param rFirst
-        The first box
-
-        @param rSecond
-        The second box
-
-        @return the input vector
-     */
-     BASEGFX_DLLPUBLIC ::std::vector< B2IBox >& computeSetDifference( ::std::vector< B2IBox >& o_rResult,
-                                                                      const B2IBox&            rFirst,
-                                                                      const B2IBox&            rSecond );
-
 } // end of namespace basegfx
 
 #endif /* _BGFX_RANGE_B2IBOX_HXX */
diff --git a/basegfx/source/color/bcolortools.cxx b/basegfx/source/color/bcolortools.cxx
index f89a47574486..ef504ebacd9f 100644
--- a/basegfx/source/color/bcolortools.cxx
+++ b/basegfx/source/color/bcolortools.cxx
@@ -200,17 +200,6 @@ namespace basegfx { namespace tools
         }
     }
 
-    BColor ciexyz2rgb( const BColor& rXYZColor )
-    {
-        // from Poynton color faq, and SMPTE RP 177-1993, Derivation
-        // of Basic Television Color Equations
-        const double x=rXYZColor.getRed(), y=rXYZColor.getGreen(), z=rXYZColor.getBlue();
-        return BColor(
-            3.240479*x - 1.53715*y  - 0.498535*z,
-            -0.969256*x + 1.875991*y + 0.041556*z,
-            0.055648*x - 0.204043*y + 1.057311*z );
-    }
-
     BColor rgb2ciexyz( const BColor& rRGBColor )
     {
         // from Poynton color faq, and SMPTE RP 177-1993, Derivation
diff --git a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
index 385a5ac7e518..73a01be154d2 100644
--- a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
+++ b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
@@ -1008,31 +1008,6 @@ namespace basegfx
 
         ////////////////////////////////////////////////////////////////////////////////
 
-        B2DPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolygon& rCandidate)
-        {
-            if(rCandidate.count())
-            {
-                temporaryPointVector aTempPoints;
-                temporaryPointVector aTempPointsUnused;
-
-                for(sal_uInt32 a(0L); a < rMask.count(); a++)
-                {
-                    const B2DPolygon aPartMask(rMask.getB2DPolygon(a));
-
-                    findTouches(rCandidate, aPartMask, aTempPoints);
-                    findCuts(rCandidate, aPartMask, aTempPoints, aTempPointsUnused);
-                }
-
-                return mergeTemporaryPointsAndPolygon(rCandidate, aTempPoints);
-            }
-            else
-            {
-                return rCandidate;
-            }
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////
-
         B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd)
         {
             const sal_uInt32 nCount(rCandidate.count());
@@ -1163,22 +1138,6 @@ namespace basegfx
             return rCandidate;
         }
 
-        B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate)
-        {
-            if(rCandidate.count())
-            {
-                temporaryPointVector aTempPoints;
-
-                findCuts(rCandidate, aTempPoints);
-
-                return mergeTemporaryPointsAndPolygon(rCandidate, aTempPoints);
-            }
-            else
-            {
-                return rCandidate;
-            }
-        }
-
         ////////////////////////////////////////////////////////////////////////////////
 
     } // end of namespace tools
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index 73f920fea85c..f86f0c655e9b 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -476,30 +476,6 @@ namespace basegfx
             return true;
         }
 
-        B2DRange getRangeWithControlPoints(const B2DPolygon& rCandidate)
-        {
-            const sal_uInt32 nPointCount(rCandidate.count());
-            B2DRange aRetval;
-
-            if(nPointCount)
-            {
-                const bool bControlPointsUsed(rCandidate.areControlPointsUsed());
-
-                for(sal_uInt32 a(0); a < nPointCount; a++)
-                {
-                    aRetval.expand(rCandidate.getB2DPoint(a));
-
-                    if(bControlPointsUsed)
-                    {
-                        aRetval.expand(rCandidate.getNextControlPoint(a));
-                        aRetval.expand(rCandidate.getPrevControlPoint(a));
-                    }
-                }
-            }
-
-            return aRetval;
-        }
-
         B2DRange getRange(const B2DPolygon& rCandidate)
         {
             // changed to use internally buffered version at B2DPolygon
diff --git a/basegfx/source/polygon/b2dpolypolygoncutter.cxx b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
index 8675b0121261..522bc3701556 100644
--- a/basegfx/source/polygon/b2dpolypolygoncutter.cxx
+++ b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
@@ -657,14 +657,6 @@ namespace basegfx
 
         //////////////////////////////////////////////////////////////////////////////
 
-        B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate)
-        {
-            solver aSolver(rCandidate);
-            return aSolver.getB2DPolyPolygon();
-        }
-
-        //////////////////////////////////////////////////////////////////////////////
-
         B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate)
         {
             B2DPolyPolygon aRetval;
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index 34721d20207d..6434dc050075 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -397,28 +397,6 @@ namespace basegfx
             return aRetval;
         }
 
-        B2DPolyPolygon setContinuity(const B2DPolyPolygon& rCandidate, B2VectorContinuity eContinuity)
-        {
-            if(rCandidate.areControlPointsUsed())
-            {
-                const sal_uInt32 nPolygonCount(rCandidate.count());
-                B2DPolyPolygon aRetval;
-
-                for(sal_uInt32 a(0L); a < nPolygonCount; a++)
-                {
-                    const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
-
-                    aRetval.append(setContinuity(aCandidate, eContinuity));
-                }
-
-                return aRetval;
-            }
-            else
-            {
-                return rCandidate;
-            }
-        }
-
         B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue)
         {
             if(0.0 != fValue)
diff --git a/basegfx/source/polygon/b3dpolygonclipper.cxx b/basegfx/source/polygon/b3dpolygonclipper.cxx
index d1c9043f185b..6db49e23beb6 100644
--- a/basegfx/source/polygon/b3dpolygonclipper.cxx
+++ b/basegfx/source/polygon/b3dpolygonclipper.cxx
@@ -306,162 +306,6 @@ namespace basegfx
             return aRetval;
         }
 
-        B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke)
-        {
-            B3DPolyPolygon aRetval;
-
-            if(rRange.isEmpty())
-            {
-                // clipping against an empty range. Nothing is inside an empty range, so the polygon
-                // is outside the range. So only return if not inside is wanted
-                if(!bInside && rCandidate.count())
-                {
-                    aRetval.append(rCandidate);
-                }
-            }
-            else if(rCandidate.count())
-            {
-                const B3DRange aCandidateRange3D(getRange(rCandidate));
-                const B2DRange aCandidateRange(
-                    aCandidateRange3D.getMinX(), aCandidateRange3D.getMinY(),
-                    aCandidateRange3D.getMaxX(), aCandidateRange3D.getMaxY());
-
-                if(rRange.isInside(aCandidateRange))
-                {
-                    // candidate is completely inside given range, nothing to do. Is also true with curves.
-                    if(bInside)
-                    {
-                        aRetval.append(rCandidate);
-                    }
-                }
-                else if(!rRange.overlaps(aCandidateRange))
-                {
-                    // candidate is completely outside given range, nothing to do. Is also true with curves.
-                    if(!bInside)
-                    {
-                        aRetval.append(rCandidate);
-                    }
-                }
-                else
-                {
-                    // clip against the six planes of the range
-                    // against lower X
-                    aRetval = clipPolygonOnOrthogonalPlane(rCandidate, tools::B3DORIENTATION_X, bInside, rRange.getMinX(), bStroke);
-
-                    if(aRetval.count())
-                    {
-                        // against lower Y
-                        if(1L == aRetval.count())
-                        {
-                            aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Y, bInside, rRange.getMinY(), bStroke);
-                        }
-                        else
-                        {
-                            aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Y, bInside, rRange.getMinY(), bStroke);
-                        }
-
-                        if(aRetval.count())
-                        {
-                            // against higher X
-                            if(1L == aRetval.count())
-                            {
-                                aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_X, !bInside, rRange.getMaxX(), bStroke);
-                            }
-                            else
-                            {
-                                aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_X, !bInside, rRange.getMaxX(), bStroke);
-                            }
-
-                            if(aRetval.count())
-                            {
-                                // against higher Y
-                                if(1L == aRetval.count())
-                                {
-                                    aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Y, !bInside, rRange.getMaxY(), bStroke);
-                                }
-                                else
-                                {
-                                    aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Y, !bInside, rRange.getMaxY(), bStroke);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            return aRetval;
-        }
-
-        B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke)
-        {
-            B3DPolyPolygon aRetval;
-
-            if(rRange.isEmpty())
-            {
-                // clipping against an empty range. Nothing is inside an empty range, so the polygon
-                // is outside the range. So only return if not inside is wanted
-                if(!bInside && rCandidate.count())
-                {
-                    aRetval.append(rCandidate);
-                }
-            }
-            else if(rCandidate.count())
-            {
-                const B3DRange aCandidateRange(getRange(rCandidate));
-
-                if(rRange.isInside(aCandidateRange))
-                {
-                    // candidate is completely inside given range, nothing to do. Is also true with curves.
-                    if(bInside)
-                    {
-                        aRetval.append(rCandidate);
-                    }
-                }
-                else if(!rRange.overlaps(aCandidateRange))
-                {
-                    // candidate is completely outside given range, nothing to do. Is also true with curves.
-                    if(!bInside)
-                    {
-                        aRetval.append(rCandidate);
-                    }
-                }
-                else
-                {
-                    // clip against X,Y first and see if there's something left
-                    const B2DRange aCandidateRange2D(rRange.getMinX(), rRange.getMinY(), rRange.getMaxX(), rRange.getMaxY());
-                    aRetval = clipPolygonOnRange(rCandidate, aCandidateRange2D, bInside, bStroke);
-
-                    if(aRetval.count())
-                    {
-                        // against lower Z
-                        if(1L == aRetval.count())
-                        {
-                            aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Z, bInside, rRange.getMinZ(), bStroke);
-                        }
-                        else
-                        {
-                            aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Z, bInside, rRange.getMinZ(), bStroke);
-                        }
-
-                        if(aRetval.count())
-                        {
-                            // against higher Z
-                            if(1L == aRetval.count())
-                            {
-                                aRetval = clipPolygonOnOrthogonalPlane(aRetval.getB3DPolygon(0L), tools::B3DORIENTATION_Z, !bInside, rRange.getMaxZ(), bStroke);
-                            }
-                            else
-                            {
-                                aRetval = clipPolyPolygonOnOrthogonalPlane(aRetval, tools::B3DORIENTATION_Z, !bInside, rRange.getMaxZ(), bStroke);
-                            }
-                        }
-                    }
-                }
-            }
-
-            return aRetval;
-        }
-
     } // end of namespace tools
 } // end of namespace basegfx
 
diff --git a/basegfx/source/polygon/b3dpolygontools.cxx b/basegfx/source/polygon/b3dpolygontools.cxx
index 65a7f6b800db..306f97b5c621 100644
--- a/basegfx/source/polygon/b3dpolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolygontools.cxx
@@ -88,27 +88,6 @@ namespace basegfx
             return rCandidate.getNormal();
         }
 
-        B2VectorOrientation getOrientation(const B3DPolygon& rCandidate)
-        {
-            B2VectorOrientation eRetval(ORIENTATION_NEUTRAL);
-
-            if(rCandidate.count() > 2L)
-            {
-                const double fSignedArea(getSignedArea(rCandidate));
-
-                if(fSignedArea > 0.0)
-                {
-                    eRetval = ORIENTATION_POSITIVE;
-                }
-                else if(fSignedArea < 0.0)
-                {
-                    eRetval = ORIENTATION_NEGATIVE;
-                }
-            }
-
-            return eRetval;
-        }
-
         double getSignedArea(const B3DPolygon& rCandidate)
         {
             double fRetval(0.0);
@@ -586,81 +565,6 @@ namespace basegfx
             return aRetval;
         }
 
-        bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance)
-        {
-            // build edge vector
-            const B3DVector aEdge(rEdgeEnd - rEdgeStart);
-            bool bDoDistanceTestStart(false);
-            bool bDoDistanceTestEnd(false);
-
-            if(aEdge.equalZero())
-            {
-                // no edge, just a point. Do one of the distance tests.
-                bDoDistanceTestStart = true;
-            }
-            else
-            {
-                // calculate fCut in aEdge
-                const B3DVector aTestEdge(rTestPosition - rEdgeStart);
-                const double fScalarTestEdge(aEdge.scalar(aTestEdge));
-                const double fScalarStartEdge(aEdge.scalar(rEdgeStart));
-                const double fScalarEdge(aEdge.scalar(aEdge));
-                const double fCut((fScalarTestEdge - fScalarStartEdge) / fScalarEdge);
-                const double fZero(0.0);
-                const double fOne(1.0);
-
-                if(fTools::less(fCut, fZero))
-                {
-                    // left of rEdgeStart
-                    bDoDistanceTestStart = true;
-                }
-                else if(fTools::more(fCut, fOne))
-                {
-                    // right of rEdgeEnd
-                    bDoDistanceTestEnd = true;
-                }
-                else
-                {
-                    // inside line [0.0 .. 1.0]
-                    const B3DPoint aCutPoint(interpolate(rEdgeStart, rEdgeEnd, fCut));
-                    const B3DVector aDelta(rTestPosition - aCutPoint);
-                    const double fDistanceSquare(aDelta.scalar(aDelta));
-
-                    if(fDistanceSquare <= fDistance * fDistance * fDistance)
-                    {
-                        return true;
-                    }
-                    else
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            if(bDoDistanceTestStart)
-            {
-                const B3DVector aDelta(rTestPosition - rEdgeStart);
-                const double fDistanceSquare(aDelta.scalar(aDelta));
-
-                if(fDistanceSquare <= fDistance * fDistance * fDistance)
-                {
-                    return true;
-                }
-            }
-            else if(bDoDistanceTestEnd)
-            {
-                const B3DVector aDelta(rTestPosition - rEdgeEnd);
-                const double fDistanceSquare(aDelta.scalar(aDelta));
-
-                if(fDistanceSquare <= fDistance * fDistance * fDistance)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
         bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder)
         {
             if(bWithBorder && isPointOnPolygon(rCandidate, rPoint, true))
diff --git a/basegfx/source/polygon/b3dpolypolygontools.cxx b/basegfx/source/polygon/b3dpolypolygontools.cxx
index 928fb3132921..b229eaeecc45 100644
--- a/basegfx/source/polygon/b3dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolypolygontools.cxx
@@ -57,42 +57,6 @@ namespace basegfx
             return aRetval;
         }
 
-        void applyLineDashing(const B3DPolyPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, B3DPolyPolygon* pGapTarget, double fFullDashDotLen)
-        {
-            if(0.0 == fFullDashDotLen && rDotDashArray.size())
-            {
-                // calculate fFullDashDotLen from rDotDashArray
-                fFullDashDotLen = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
-            }
-
-            if(rCandidate.count() && fFullDashDotLen > 0.0)
-            {
-                B3DPolyPolygon aLineTarget, aGapTarget;
-
-                for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
-                {
-                    const B3DPolygon aCandidate(rCandidate.getB3DPolygon(a));
-
-                    applyLineDashing(
-                        aCandidate,
-                        rDotDashArray,
-                        pLineTarget ? &aLineTarget : 0,
-                        pGapTarget ? &aGapTarget : 0,
-                        fFullDashDotLen);
-
-                    if(pLineTarget)
-                    {
-                        pLineTarget->append(aLineTarget);
-                    }
-
-                    if(pGapTarget)
-                    {
-                        pGapTarget->append(aGapTarget);
-                    }
-                }
-            }
-        }
-
         B3DPolyPolygon createUnitCubePolyPolygon()
         {
             static B3DPolyPolygon aRetval;
diff --git a/basegfx/source/range/b2xrange.cxx b/basegfx/source/range/b2xrange.cxx
index 9c6b4252cadd..8b8f81136296 100644
--- a/basegfx/source/range/b2xrange.cxx
+++ b/basegfx/source/range/b2xrange.cxx
@@ -126,15 +126,6 @@ namespace basegfx
         return o_rResult;
     }
 
-    ::std::vector< B2IBox >& computeSetDifference( ::std::vector< B2IBox >& o_rResult,
-                                                   const B2IBox&            rFirst,
-                                                   const B2IBox&            rSecond )
-    {
-        doComputeSetDifference( o_rResult, rFirst, rSecond );
-
-        return o_rResult;
-    }
-
 } // end of namespace basegfx
 
 // eof