Rename the basegfx::tools namespace to basegfx::utils

Reduce potential confusion with the global tools namespace. Will
hopefully make it possible to remove the annoying initial :: when
referring to the global tools namespace. Unless we have even more
tools subnamespaces somewhere.

Thorsten said it was OK.

Change-Id: Id088dfe8f4244cb79df9aa988995b31a1758c996
Reviewed-on: https://gerrit.libreoffice.org/42644
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Tor Lillqvist <tml@collabora.com>

14 files changed, 70 insertions, 70 deletions

diff --git a/drawinglayer/source/primitive3d/baseprimitive3d.cxx b/drawinglayer/source/primitive3d/baseprimitive3d.cxx
index d9d5804c69ff..cfac964e1a3a 100644
--- a/drawinglayer/source/primitive3d/baseprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/baseprimitive3d.cxx
@@ -19,7 +19,7 @@
 
 #include <drawinglayer/primitive3d/baseprimitive3d.hxx>
 #include <drawinglayer/geometry/viewinformation3d.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <comphelper/sequence.hxx>
 
 
diff --git a/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx b/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx
index d8348b2689f4..4400dd827d66 100644
--- a/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/hatchtextureprimitive3d.cxx
@@ -132,7 +132,7 @@ namespace drawinglayer
                                         {
                                             // found two linearly independent 2D vectors
                                             // get 2d range of texture coordinates
-                                            const basegfx::B2DRange aOutlineRange(basegfx::tools::getRange(aTexPolyPolygon));
+                                            const basegfx::B2DRange aOutlineRange(basegfx::utils::getRange(aTexPolyPolygon));
                                             const basegfx::BColor aHatchColor(getHatch().getColor());
                                             const double fAngle(getHatch().getAngle());
                                             std::vector< basegfx::B2DHomMatrix > aMatrices;
@@ -195,7 +195,7 @@ namespace drawinglayer
                                             if(a2DHatchLines.count())
                                             {
                                                 // clip against texture polygon
-                                                a2DHatchLines = basegfx::tools::clipPolyPolygonOnPolyPolygon(a2DHatchLines, aTexPolyPolygon, true, true);
+                                                a2DHatchLines = basegfx::utils::clipPolyPolygonOnPolyPolygon(a2DHatchLines, aTexPolyPolygon, true, true);
                                             }
 
                                             if(a2DHatchLines.count())
@@ -216,7 +216,7 @@ namespace drawinglayer
                                                 a2DHatchLines.transform(a2D);
 
                                                 // expand back-transformed geometry to 3D
-                                                basegfx::B3DPolyPolygon a3DHatchLines(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(a2DHatchLines, 0.0));
+                                                basegfx::B3DPolyPolygon a3DHatchLines(basegfx::utils::createB3DPolyPolygonFromB2DPolyPolygon(a2DHatchLines, 0.0));
 
                                                 // create 3d matrix with 3d vectors as column vectors (0,0,1 as Z) and 3d point as offset, this represents
                                                 // a coordinate system transformation from unit coordinates to the object's 3d coordinate system
diff --git a/drawinglayer/source/primitive3d/polygonprimitive3d.cxx b/drawinglayer/source/primitive3d/polygonprimitive3d.cxx
index 20de70b7610a..a1956d9786e6 100644
--- a/drawinglayer/source/primitive3d/polygonprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/polygonprimitive3d.cxx
@@ -19,7 +19,7 @@
 
 #include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
 #include <basegfx/polygon/b3dpolygontools.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <basegfx/polygon/b3dpolypolygontools.hxx>
 #include <drawinglayer/primitive3d/polygontubeprimitive3d.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
@@ -56,7 +56,7 @@ namespace drawinglayer
 
         basegfx::B3DRange PolygonHairlinePrimitive3D::getB3DRange(const geometry::ViewInformation3D& /*rViewInformation*/) const
         {
-            return basegfx::tools::getRange(getB3DPolygon());
+            return basegfx::utils::getRange(getB3DPolygon());
         }
 
         // provide unique ID
@@ -85,7 +85,7 @@ namespace drawinglayer
                 else
                 {
                     // apply LineStyle
-                    basegfx::tools::applyLineDashing(getB3DPolygon(), getStrokeAttribute().getDotDashArray(), &aHairLinePolyPolygon, nullptr, getStrokeAttribute().getFullDotDashLen());
+                    basegfx::utils::applyLineDashing(getB3DPolygon(), getStrokeAttribute().getDotDashArray(), &aHairLinePolyPolygon, nullptr, getStrokeAttribute().getFullDotDashLen());
                 }
 
                 // prepare result
diff --git a/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx b/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx
index 5657307dd5f3..fb6555fd4e05 100644
--- a/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/polygontubeprimitive3d.cxx
@@ -239,7 +239,7 @@ namespace drawinglayer
 
                         // create half-sphere; upper half of unit sphere
                         basegfx::B3DPolyPolygon aSphere(
-                            basegfx::tools::createUnitSphereFillPolyPolygon(
+                            basegfx::utils::createUnitSphereFillPolyPolygon(
                                 nSegments,
                                 nVerSeg,
                                 true,
@@ -314,7 +314,7 @@ namespace drawinglayer
                         if(nHorSeg)
                         {
                             // create half-sphere
-                            const basegfx::B3DPolyPolygon aSphere(basegfx::tools::createUnitSphereFillPolyPolygon(nHorSeg, nVerSeg, true, F_PI2, -F_PI2, 0.0, fAngle));
+                            const basegfx::B3DPolyPolygon aSphere(basegfx::utils::createUnitSphereFillPolyPolygon(nHorSeg, nVerSeg, true, F_PI2, -F_PI2, 0.0, fAngle));
 
                             for(sal_uInt32 a(0); a < aSphere.count(); a++)
                             {
diff --git a/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx b/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx
index 3a77955da71a..38acc8c123f9 100644
--- a/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/polypolygonprimitive3d.cxx
@@ -19,7 +19,7 @@
 
 #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
 #include <basegfx/polygon/b3dpolypolygontools.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
 
 
@@ -57,7 +57,7 @@ namespace drawinglayer
 
         basegfx::B3DRange PolyPolygonMaterialPrimitive3D::getB3DRange(const geometry::ViewInformation3D& /*rViewInformation*/) const
         {
-            return basegfx::tools::getRange(getB3DPolyPolygon());
+            return basegfx::utils::getRange(getB3DPolyPolygon());
         }
 
         // provide unique ID
diff --git a/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx
index 9b6d650e0303..864d3e41e98b 100644
--- a/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrcubeprimitive3d.cxx
@@ -22,7 +22,7 @@
 #include <basegfx/polygon/b3dpolygon.hxx>
 #include <basegfx/matrix/b2dhommatrix.hxx>
 #include <drawinglayer/primitive3d/sdrdecompositiontools3d.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
 #include <drawinglayer/attribute/sdrfillattribute.hxx>
 #include <drawinglayer/attribute/sdrlineattribute.hxx>
@@ -40,7 +40,7 @@ namespace drawinglayer
         {
             const basegfx::B3DRange aUnitRange(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
             Primitive3DContainer aRetval;
-            basegfx::B3DPolyPolygon aFill(basegfx::tools::createCubeFillPolyPolygonFromB3DRange(aUnitRange));
+            basegfx::B3DPolyPolygon aFill(basegfx::utils::createCubeFillPolyPolygonFromB3DRange(aUnitRange));
 
             // normal creation
             if(!getSdrLFSAttribute().getFill().isDefault())
@@ -49,14 +49,14 @@ namespace drawinglayer
                     || css::drawing::NormalsKind_SPHERE == getSdr3DObjectAttribute().getNormalsKind())
                 {
                     // create sphere normals
-                    const basegfx::B3DPoint aCenter(basegfx::tools::getRange(aFill).getCenter());
-                    aFill = basegfx::tools::applyDefaultNormalsSphere(aFill, aCenter);
+                    const basegfx::B3DPoint aCenter(basegfx::utils::getRange(aFill).getCenter());
+                    aFill = basegfx::utils::applyDefaultNormalsSphere(aFill, aCenter);
                 }
 
                 if(getSdr3DObjectAttribute().getNormalsInvert())
                 {
                     // invert normals
-                    aFill = basegfx::tools::invertNormals(aFill);
+                    aFill = basegfx::utils::invertNormals(aFill);
                 }
             }
 
@@ -76,16 +76,16 @@ namespace drawinglayer
                 if(bParallelX || bParallelY)
                 {
                     // apply parallel texture coordinates in X and/or Y
-                    const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
-                    aFill = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
+                    const basegfx::B3DRange aRange(basegfx::utils::getRange(aFill));
+                    aFill = basegfx::utils::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
                 }
 
                 if(bSphereX || bSphereY)
                 {
                     // apply spherical texture coordinates in X and/or Y
-                    const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
+                    const basegfx::B3DRange aRange(basegfx::utils::getRange(aFill));
                     const basegfx::B3DPoint aCenter(aRange.getCenter());
-                    aFill = basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill, aCenter, bSphereX, bSphereY);
+                    aFill = basegfx::utils::applyDefaultTextureCoordinatesSphere(aFill, aCenter, bSphereX, bSphereY);
                 }
 
                 if(bObjectSpecificX || bObjectSpecificY)
@@ -157,7 +157,7 @@ namespace drawinglayer
             // add line
             if(!getSdrLFSAttribute().getLine().isDefault())
             {
-                basegfx::B3DPolyPolygon aLine(basegfx::tools::createCubePolyPolygonFromB3DRange(aUnitRange));
+                basegfx::B3DPolyPolygon aLine(basegfx::utils::createCubePolyPolygonFromB3DRange(aUnitRange));
                 const Primitive3DContainer aLines(create3DPolyPolygonLinePrimitives(
                     aLine, getTransform(), getSdrLFSAttribute().getLine()));
                 aRetval.append(aLines);
diff --git a/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx b/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx
index 8f8f80303e9d..dcea2f877543 100644
--- a/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrdecompositiontools3d.cxx
@@ -51,7 +51,7 @@ namespace drawinglayer
 
             for(basegfx::B3DPolyPolygon & a : rFill)
             {
-                aRetval.expand(basegfx::tools::getRange(a));
+                aRetval.expand(basegfx::utils::getRange(a));
             }
 
             return aRetval;
@@ -64,7 +64,7 @@ namespace drawinglayer
 
             for(basegfx::B3DPolyPolygon & a : rFill)
             {
-                a = basegfx::tools::applyDefaultNormalsSphere(a, aCenter);
+                a = basegfx::utils::applyDefaultNormalsSphere(a, aCenter);
             }
         }
 
@@ -81,7 +81,7 @@ namespace drawinglayer
             // invert normals
             for(basegfx::B3DPolyPolygon & a : rFill)
             {
-                a = basegfx::tools::invertNormals(a);
+                a = basegfx::utils::invertNormals(a);
             }
         }
 
@@ -105,7 +105,7 @@ namespace drawinglayer
                 // apply parallel texture coordinates in X and/or Y
                 for(auto & a: rFill)
                 {
-                    a = basegfx::tools::applyDefaultTextureCoordinatesParallel(a, rRange, bParallelX, bParallelY);
+                    a = basegfx::utils::applyDefaultTextureCoordinatesParallel(a, rRange, bParallelX, bParallelY);
                 }
             }
 
@@ -116,7 +116,7 @@ namespace drawinglayer
 
                 for(auto & a: rFill)
                 {
-                    a = basegfx::tools::applyDefaultTextureCoordinatesSphere(a, aCenter, bSphereX, bSphereY);
+                    a = basegfx::utils::applyDefaultTextureCoordinatesSphere(a, aCenter, bSphereX, bSphereY);
                 }
             }
 
diff --git a/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx b/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx
index deac45e862c9..be8fc6d91368 100644
--- a/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx
@@ -50,7 +50,7 @@ namespace
 
         if(!basegfx::fTools::equalZero(fScale))
         {
-            const basegfx::B2DRange aRange(basegfx::tools::getRange(rSource));
+            const basegfx::B2DRange aRange(basegfx::utils::getRange(rSource));
             const basegfx::B2DPoint aCenter(aRange.getCenter());
             basegfx::B2DHomMatrix aTrans;
 
@@ -78,9 +78,9 @@ namespace
                 // grow the outside polygon and scale all polygons to original size. This is done
                 // to avoid a shrink which potentially would lead to self-intersections, but changes
                 // the original polygon -> not a precision step, so e.g. not usable for charts
-                const basegfx::B2DRange aRange(basegfx::tools::getRange(rPolygon));
-                rPolygon = basegfx::tools::growInNormalDirection(rPolygon, fOffset);
-                const basegfx::B2DRange aGrownRange(basegfx::tools::getRange(rPolygon));
+                const basegfx::B2DRange aRange(basegfx::utils::getRange(rPolygon));
+                rPolygon = basegfx::utils::growInNormalDirection(rPolygon, fOffset);
+                const basegfx::B2DRange aGrownRange(basegfx::utils::getRange(rPolygon));
                 const double fScaleX(basegfx::fTools::equalZero(aGrownRange.getWidth()) ? 1.0 : aRange.getWidth() / aGrownRange.getWidth());
                 const double fScaleY(basegfx::fTools::equalZero(aGrownRange.getHeight())? 1.0 : aRange.getHeight() / aGrownRange.getHeight());
                 basegfx::B2DHomMatrix aScaleTrans;
@@ -95,8 +95,8 @@ namespace
             {
                 // use more precision, shrink the outer polygons. Since this may lead to self-intersections,
                 // some kind of correction should be applied here after that step
-                rOuterPolyPolygon = basegfx::tools::growInNormalDirection(rPolygon, -fOffset);
-                // basegfx::tools::correctGrowShrinkPolygonPair(rPolygon, rOuterPolyPolygon);
+                rOuterPolyPolygon = basegfx::utils::growInNormalDirection(rPolygon, -fOffset);
+                // basegfx::utils::correctGrowShrinkPolygonPair(rPolygon, rOuterPolyPolygon);
             }
         }
     }
@@ -128,10 +128,10 @@ namespace
 
                 if(bCreateTextureCoordinates)
                 {
-                    const double fPolygonLengthA(basegfx::tools::getLength(aSubA));
+                    const double fPolygonLengthA(basegfx::utils::getLength(aSubA));
                     fTexHorMultiplicatorA = basegfx::fTools::equalZero(fPolygonLengthA) ? 1.0 : 1.0 / fPolygonLengthA;
 
-                    const double fPolygonLengthB(basegfx::tools::getLength(aSubB));
+                    const double fPolygonLengthB(basegfx::utils::getLength(aSubB));
                     fTexHorMultiplicatorB = basegfx::fTools::equalZero(fPolygonLengthB) ? 1.0 : 1.0 / fPolygonLengthB;
                 }
 
@@ -330,7 +330,7 @@ namespace
                 const basegfx::B2DPoint aNext(rPoly.getB2DPoint(nNextIndex));
                 const basegfx::B2DVector aEdgeVector(aNext - aCurrent);
 
-                if(basegfx::tools::findCut(
+                if(basegfx::utils::findCut(
                     rStart, aVector,
                     aCurrent, aEdgeVector) != CutFlagValue::NONE)
                 {
@@ -394,7 +394,7 @@ namespace drawinglayer
 
                 if(bCloseFront || bCloseBack)
                 {
-                    const basegfx::B2DRange aBaseRange(basegfx::tools::getRange(aFront));
+                    const basegfx::B2DRange aBaseRange(basegfx::utils::getRange(aFront));
                     const double fOuterLength(aBaseRange.getMaxX() * fRotation);
                     const double fInnerLength(aBaseRange.getMinX() * fRotation);
                     const double fAverageLength((fOuterLength + fInnerLength) * 0.5);
@@ -430,7 +430,7 @@ namespace drawinglayer
                 for(sal_uInt32 a(0); a < nSteps; a++)
                 {
                     const double fStep((double)(a + 1) * fStepSize);
-                    basegfx::B2DPolyPolygon aNewPoly(bBackScale ? basegfx::tools::interpolate(aFront, aBack, fStep) : aFront);
+                    basegfx::B2DPolyPolygon aNewPoly(bBackScale ? basegfx::utils::interpolate(aFront, aBack, fStep) : aFront);
                     basegfx::B3DHomMatrix aNewMat;
                     aNewMat.rotate(0.0, fRotation * fStep, 0.0);
                     rSliceVector.emplace_back(aNewPoly, aNewMat);
@@ -601,8 +601,8 @@ namespace drawinglayer
 
                 if(bCreateTextureCoordinates)
                 {
-                    aTexRangeFront = basegfx::tools::getRange(rSliceVector[0].getB3DPolyPolygon());
-                    aTexRangeBack = basegfx::tools::getRange(rSliceVector[nNumSlices - 1].getB3DPolyPolygon());
+                    aTexRangeFront = basegfx::utils::getRange(rSliceVector[0].getB3DPolyPolygon());
+                    aTexRangeBack = basegfx::utils::getRange(rSliceVector[nNumSlices - 1].getB3DPolyPolygon());
 
                     if(aTexRangeBack.getDepth() > aTexRangeBack.getWidth())
                     {
@@ -614,11 +614,11 @@ namespace drawinglayer
                             aTexRangeBack.getMaxZ(), aTexRangeBack.getMaxY(), aTexRangeBack.getMaxX());
                     }
 
-                    basegfx::B3DPoint aCenter(basegfx::tools::getRange(rSliceVector[0].getB3DPolyPolygon()).getCenter());
+                    basegfx::B3DPoint aCenter(basegfx::utils::getRange(rSliceVector[0].getB3DPolyPolygon()).getCenter());
 
                     for(a = 0; a < nLoopCount; a++)
                     {
-                        const basegfx::B3DPoint aNextCenter(basegfx::tools::getRange(rSliceVector[(a + 1) % nNumSlices].getB3DPolyPolygon()).getCenter());
+                        const basegfx::B3DPoint aNextCenter(basegfx::utils::getRange(rSliceVector[(a + 1) % nNumSlices].getB3DPolyPolygon()).getCenter());
                         const double fLength(basegfx::B3DVector(aNextCenter - aCenter).getLength());
                         aTexHeightArray.push_back(fLength);
                         aCenter = aNextCenter;
@@ -663,7 +663,7 @@ namespace drawinglayer
 
                                     if(bCreateTextureCoordinates)
                                     {
-                                        aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
+                                        aFront = basegfx::utils::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
                                     }
 
                                     if(bCreateNormals)
@@ -761,7 +761,7 @@ namespace drawinglayer
 
                                     if(bCreateTextureCoordinates)
                                     {
-                                        aBack = basegfx::tools::applyDefaultTextureCoordinatesParallel(aBack, aTexRangeBack);
+                                        aBack = basegfx::utils::applyDefaultTextureCoordinatesParallel(aBack, aTexRangeBack);
                                     }
 
                                     if(bCreateNormals)
@@ -865,7 +865,7 @@ namespace drawinglayer
 
                     if(bCreateTextureCoordinates)
                     {
-                        aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
+                        aFront = basegfx::utils::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
                     }
 
                     if(bCreateNormals)
@@ -911,8 +911,8 @@ namespace drawinglayer
                 if(nPointCount && nPointCount == rLoopB.count())
                 {
                     const basegfx::B3DHomMatrix aObjectTransform(rViewInformation.getObjectToView() * rObjectTransform);
-                    const basegfx::B2DPolygon a2DLoopA(basegfx::tools::createB2DPolygonFromB3DPolygon(rLoopA, aObjectTransform));
-                    const basegfx::B2DPolygon a2DLoopB(basegfx::tools::createB2DPolygonFromB3DPolygon(rLoopB, aObjectTransform));
+                    const basegfx::B2DPolygon a2DLoopA(basegfx::utils::createB2DPolygonFromB3DPolygon(rLoopA, aObjectTransform));
+                    const basegfx::B2DPolygon a2DLoopB(basegfx::utils::createB2DPolygonFromB3DPolygon(rLoopB, aObjectTransform));
                     const basegfx::B2DPoint a2DCenterA(a2DLoopA.getB2DRange().getCenter());
                     const basegfx::B2DPoint a2DCenterB(a2DLoopB.getB2DRange().getCenter());
 
@@ -933,9 +933,9 @@ namespace drawinglayer
                             const basegfx::B2DPoint aEnd(a2DLoopB.getB2DPoint(a));
                             const basegfx::B2DPoint aMiddle(basegfx::average(aStart, aEnd));
 
-                            if(!basegfx::tools::isInside(a2DLoopA, aMiddle))
+                            if(!basegfx::utils::isInside(a2DLoopA, aMiddle))
                             {
-                                if(!basegfx::tools::isInside(a2DLoopB, aMiddle))
+                                if(!basegfx::utils::isInside(a2DLoopB, aMiddle))
                                 {
                                     if(!impHasCutWith(a2DLoopA, aStart, aEnd))
                                     {
diff --git a/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx
index 06a6eb3f2050..246894d0eab1 100644
--- a/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrextrudeprimitive3d.cxx
@@ -22,7 +22,7 @@
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <basegfx/polygon/b3dpolypolygontools.hxx>
 #include <drawinglayer/primitive3d/sdrdecompositiontools3d.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
 #include <drawinglayer/geometry/viewinformation3d.hxx>
 #include <drawinglayer/attribute/sdrfillattribute.hxx>
@@ -58,8 +58,8 @@ namespace drawinglayer
                 if(!getSdrLFSAttribute().getFill().isDefault() && (bCreateTextureCoordinatesX || bCreateTextureCoordinatesY))
                 {
                     const basegfx::B2DPolygon aFirstPolygon(maCorrectedPolyPolygon.getB2DPolygon(0));
-                    const double fFrontLength(basegfx::tools::getLength(aFirstPolygon));
-                    const double fFrontArea(basegfx::tools::getArea(aFirstPolygon));
+                    const double fFrontLength(basegfx::utils::getLength(aFirstPolygon));
+                    const double fFrontArea(basegfx::utils::getArea(aFirstPolygon));
                     const double fSqrtFrontArea(sqrt(fFrontArea));
                     double fRelativeTextureWidth = basegfx::fTools::equalZero(fSqrtFrontArea) ? 1.0 : fFrontLength / fSqrtFrontArea;
                     fRelativeTextureWidth = (double)((sal_uInt32)(fRelativeTextureWidth - 0.5));
@@ -360,10 +360,10 @@ namespace drawinglayer
             // prepare the polygon. No double points, correct orientations and a correct
             // outmost polygon are needed
             // Also important: subdivide here to ensure equal point count for all slices (!)
-            maCorrectedPolyPolygon = basegfx::tools::adaptiveSubdivideByAngle(getPolyPolygon());
+            maCorrectedPolyPolygon = basegfx::utils::adaptiveSubdivideByAngle(getPolyPolygon());
             maCorrectedPolyPolygon.removeDoublePoints();
-            maCorrectedPolyPolygon = basegfx::tools::correctOrientations(maCorrectedPolyPolygon);
-            maCorrectedPolyPolygon = basegfx::tools::correctOutmostPolygon(maCorrectedPolyPolygon);
+            maCorrectedPolyPolygon = basegfx::utils::correctOrientations(maCorrectedPolyPolygon);
+            maCorrectedPolyPolygon = basegfx::utils::correctOutmostPolygon(maCorrectedPolyPolygon);
 
             // prepare slices as geometry
             createExtrudeSlices(maSlices, maCorrectedPolyPolygon, getBackScale(), getDiagonal(), getDepth(), getCharacterMode(), getCloseFront(), getCloseBack());
diff --git a/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx
index f453d03578d9..a63a7886e4b3 100644
--- a/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrlatheprimitive3d.cxx
@@ -22,7 +22,7 @@
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <basegfx/polygon/b3dpolypolygontools.hxx>
 #include <drawinglayer/primitive3d/sdrdecompositiontools3d.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
 #include <drawinglayer/geometry/viewinformation3d.hxx>
 #include <drawinglayer/attribute/sdrfillattribute.hxx>
@@ -205,10 +205,10 @@ namespace drawinglayer
             // prepare the polygon. No double points, correct orientations and a correct
             // outmost polygon are needed
             // Also important: subdivide here to ensure equal point count for all slices (!)
-            maCorrectedPolyPolygon = basegfx::tools::adaptiveSubdivideByAngle(getPolyPolygon());
+            maCorrectedPolyPolygon = basegfx::utils::adaptiveSubdivideByAngle(getPolyPolygon());
             maCorrectedPolyPolygon.removeDoublePoints();
-            maCorrectedPolyPolygon = basegfx::tools::correctOrientations(maCorrectedPolyPolygon);
-            maCorrectedPolyPolygon = basegfx::tools::correctOutmostPolygon(maCorrectedPolyPolygon);
+            maCorrectedPolyPolygon = basegfx::utils::correctOrientations(maCorrectedPolyPolygon);
+            maCorrectedPolyPolygon = basegfx::utils::correctOutmostPolygon(maCorrectedPolyPolygon);
 
             // check edge count of first sub-polygon. If different, reSegment polyPolygon. This ensures
             // that for polyPolygons, the subPolys 1..n only get reSegmented when polygon 0 is different
@@ -218,7 +218,7 @@ namespace drawinglayer
 
             if(nSubEdgeCount != getVerticalSegments())
             {
-                maCorrectedPolyPolygon = basegfx::tools::reSegmentPolyPolygon(maCorrectedPolyPolygon, getVerticalSegments());
+                maCorrectedPolyPolygon = basegfx::utils::reSegmentPolyPolygon(maCorrectedPolyPolygon, getVerticalSegments());
             }
 
             // prepare slices as geometry
diff --git a/drawinglayer/source/primitive3d/sdrpolypolygonprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrpolypolygonprimitive3d.cxx
index 76c2ac5d24eb..d94ff20bfebf 100644
--- a/drawinglayer/source/primitive3d/sdrpolypolygonprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrpolypolygonprimitive3d.cxx
@@ -153,7 +153,7 @@ namespace drawinglayer
 
             if(getPolyPolygon3D().count())
             {
-                aRetval = basegfx::tools::getRange(getPolyPolygon3D());
+                aRetval = basegfx::utils::getRange(getPolyPolygon3D());
                 aRetval.transform(getTransform());
 
                 if(!getSdrLFSAttribute().getLine().isDefault())
diff --git a/drawinglayer/source/primitive3d/sdrprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrprimitive3d.cxx
index 298b58410041..8547da5a89bf 100644
--- a/drawinglayer/source/primitive3d/sdrprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrprimitive3d.cxx
@@ -57,7 +57,7 @@ namespace drawinglayer
             {
                 for(const auto & rSlice : rSlices)
                 {
-                    aRetval.expand(basegfx::tools::getRange(rSlice.getB3DPolyPolygon()));
+                    aRetval.expand(basegfx::utils::getRange(rSlice.getB3DPolyPolygon()));
                 }
 
                 aRetval.transform(getTransform());
diff --git a/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx b/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx
index e09476df2c19..396cf22c0e7f 100644
--- a/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/sdrsphereprimitive3d.cxx
@@ -22,7 +22,7 @@
 #include <basegfx/matrix/b2dhommatrix.hxx>
 #include <basegfx/polygon/b3dpolygon.hxx>
 #include <drawinglayer/primitive3d/sdrdecompositiontools3d.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
 #include <drawinglayer/attribute/sdrfillattribute.hxx>
 #include <drawinglayer/attribute/sdrlineattribute.hxx>
@@ -44,7 +44,7 @@ namespace drawinglayer
                 || css::drawing::NormalsKind_SPHERE == getSdr3DObjectAttribute().getNormalsKind());
 
             // create unit geometry
-            basegfx::B3DPolyPolygon aFill(basegfx::tools::createSphereFillPolyPolygonFromB3DRange(aUnitRange,
+            basegfx::B3DPolyPolygon aFill(basegfx::utils::createSphereFillPolyPolygonFromB3DRange(aUnitRange,
                 getHorizontalSegments(), getVerticalSegments(), bCreateNormals));
 
             // normal inversion
@@ -54,7 +54,7 @@ namespace drawinglayer
                 && aFill.areNormalsUsed())
             {
                 // invert normals
-                aFill = basegfx::tools::invertNormals(aFill);
+                aFill = basegfx::utils::invertNormals(aFill);
             }
 
             // texture coordinates
@@ -73,8 +73,8 @@ namespace drawinglayer
                 if(bParallelX || bParallelY)
                 {
                     // apply parallel texture coordinates in X and/or Y
-                    const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
-                    aFill = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
+                    const basegfx::B3DRange aRange(basegfx::utils::getRange(aFill));
+                    aFill = basegfx::utils::applyDefaultTextureCoordinatesParallel(aFill, aRange, bParallelX, bParallelY);
                 }
 
                 if(bSphereX || bObjectSpecificX || bSphereY || bObjectSpecificY)
@@ -94,9 +94,9 @@ namespace drawinglayer
                     }
 
                     // apply spherical texture coordinates in X and/or Y
-                    const basegfx::B3DRange aRange(basegfx::tools::getRange(aFill));
+                    const basegfx::B3DRange aRange(basegfx::utils::getRange(aFill));
                     const basegfx::B3DPoint aCenter(aRange.getCenter());
-                    aFill = basegfx::tools::applyDefaultTextureCoordinatesSphere(aFill, aCenter,
+                    aFill = basegfx::utils::applyDefaultTextureCoordinatesSphere(aFill, aCenter,
                         bSphereX || bObjectSpecificX, bSphereY || bObjectSpecificY);
 
                     if(bObjectSpecificX)
@@ -146,7 +146,7 @@ namespace drawinglayer
             // add line
             if(!getSdrLFSAttribute().getLine().isDefault())
             {
-                basegfx::B3DPolyPolygon aSphere(basegfx::tools::createSpherePolyPolygonFromB3DRange(aUnitRange, getHorizontalSegments(), getVerticalSegments()));
+                basegfx::B3DPolyPolygon aSphere(basegfx::utils::createSpherePolyPolygonFromB3DRange(aUnitRange, getHorizontalSegments(), getVerticalSegments()));
                 const Primitive3DContainer aLines(create3DPolyPolygonLinePrimitives(
                     aSphere, getTransform(), getSdrLFSAttribute().getLine()));
                 aRetval.append(aLines);
diff --git a/drawinglayer/source/primitive3d/transformprimitive3d.cxx b/drawinglayer/source/primitive3d/transformprimitive3d.cxx
index 7af03029fc43..0090d0ec08fa 100644
--- a/drawinglayer/source/primitive3d/transformprimitive3d.cxx
+++ b/drawinglayer/source/primitive3d/transformprimitive3d.cxx
@@ -18,7 +18,7 @@
  */
 
 #include <drawinglayer/primitive3d/transformprimitive3d.hxx>
-#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/utils/canvastools.hxx>
 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>