fdo#82577: Handle PolyPolygon

Put the TOOLS PolyPolygon class in the tools namespace. Avoids clash with the Windows
PolyPolygon typedef.

Change-Id: I811ecbb3d55ba4ce66e4555a8586f60fcd57fb66

45 files changed, 150 insertions, 148 deletions

diff --git a/include/basegfx/polygon/b2dlinegeometry.hxx b/include/basegfx/polygon/b2dlinegeometry.hxx
index 9d6ae0b53700..ca9fb18ad686 100644
--- a/include/basegfx/polygon/b2dlinegeometry.hxx
+++ b/include/basegfx/polygon/b2dlinegeometry.hxx
@@ -126,7 +126,7 @@ namespace basegfx
             to [F_PI .. 0.01 * F_PI].
 
             @return
-            The PolyPolygon containing the geometry of the extended line by
+            The tools::PolyPolygon containing the geometry of the extended line by
             it's line width. Contains bezier segments and edge roundings as
             needed and defined.
         */
diff --git a/include/basegfx/polygon/b2dpolygonclipper.hxx b/include/basegfx/polygon/b2dpolygonclipper.hxx
index 821ed5bbf795..7fb2430c1dca 100644
--- a/include/basegfx/polygon/b2dpolygonclipper.hxx
+++ b/include/basegfx/polygon/b2dpolygonclipper.hxx
@@ -33,7 +33,7 @@ namespace basegfx
 
     namespace tools
     {
-        // This method clips the given PolyPolygon against a horizontal or vertical axis (parallell to X or Y axis). The axis is
+        // This method clips the given tools::PolyPolygon against a horizontal or vertical axis (parallell to X or Y axis). The axis is
         // defined by bParallelToXAxis (true -> it's parallel to the X-Axis of the coordinate system, else to the Y-Axis) and the
         // fValueOnOtherAxis (gives the translation to the coordinate system axis). For example, when You want to define
         // a clip axis parallel to X.Axis and 100 above it, use bParallelToXAxis = true and fValueOnOtherAxis = 100.
@@ -42,16 +42,16 @@ namespace basegfx
         BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnParallelAxis(const B2DPolyPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke);
         BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnParallelAxis(const B2DPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke);
 
-        // Clip the given PolyPolygon against the given range. bInside defines if the result will contain the
+        // Clip the given tools::PolyPolygon against the given range. bInside defines if the result will contain the
         // parts which are contained in the range or vice versa.
         // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
         BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnRange(const B2DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
         BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnRange(const B2DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
 
-        // Clip given PolyPolygon against given clipping polygon.
+        // Clip given tools::PolyPolygon against given clipping polygon.
         // The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
         // With stroke polygons, You get all line snippets inside rCip.
-        // With filled polygons, You get all PolyPolygon parts which were inside rClip.
+        // With filled polygons, You get all tools::PolyPolygon parts which were inside rClip.
         // The switch bInside decides if the parts inside the clip polygon or outside shall be created.
         // The clip polygon is always assumed closed, even when it's isClosed() is false.
         BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke);
diff --git a/include/basegfx/polygon/b2dpolygoncutandtouch.hxx b/include/basegfx/polygon/b2dpolygoncutandtouch.hxx
index c5a2a0fb0cf9..89cf1012f075 100644
--- a/include/basegfx/polygon/b2dpolygoncutandtouch.hxx
+++ b/include/basegfx/polygon/b2dpolygoncutandtouch.hxx
@@ -34,7 +34,7 @@ namespace basegfx
         // extra points there. Result will have no touches or intersections on an edge, only on points
         BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCutsAndTouches(const B2DPolygon& rCandidate);
 
-        // look for polypolygon-intersections and polypolygon-touches (point of poly A on an edge of poly B) in given PolyPolygon and add
+        // look for polypolygon-intersections and polypolygon-touches (point of poly A on an edge of poly B) in given tools::PolyPolygon and add
         // extra points there. Result will have no touches or intersections between contained polygons on an edge, only on points. For
         // convenience, the correction for self-intersections for each member polygon will be used, too.
         // Changed: Self intersections are searched by default, but may be switched off by 2nd parameter.
diff --git a/include/basegfx/polygon/b2dpolygontools.hxx b/include/basegfx/polygon/b2dpolygontools.hxx
index 4e5fc5124318..0fb90cb744ee 100644
--- a/include/basegfx/polygon/b2dpolygontools.hxx
+++ b/include/basegfx/polygon/b2dpolygontools.hxx
@@ -292,7 +292,7 @@ namespace basegfx
         // third coordinate.
         BASEGFX_DLLPUBLIC B3DPolygon createB3DPolygonFromB2DPolygon(const B2DPolygon& rCandidate, double fZCoordinate = 0.0);
 
-        // create 2d PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given
+        // create 2d tools::PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given
         // matrix and the resulting x,y is used to form the new polygon.
         BASEGFX_DLLPUBLIC B2DPolygon createB2DPolygonFromB3DPolygon(const B3DPolygon& rCandidate, const B3DHomMatrix& rMat);
 
diff --git a/include/basegfx/polygon/b2dpolypolygon.hxx b/include/basegfx/polygon/b2dpolypolygon.hxx
index 203db76663a8..07bffcd6527d 100644
--- a/include/basegfx/polygon/b2dpolypolygon.hxx
+++ b/include/basegfx/polygon/b2dpolypolygon.hxx
@@ -111,7 +111,7 @@ namespace basegfx
         // flip polygon direction
         void flip();
 
-        // test if PolyPolygon has double points
+        // test if tools::PolyPolygon has double points
         bool hasDoublePoints() const;
 
         // remove double points, at the begin/end and follow-ups, too
diff --git a/include/basegfx/polygon/b2dpolypolygoncutter.hxx b/include/basegfx/polygon/b2dpolypolygoncutter.hxx
index 3171432a3e49..cfa2449cb7c5 100644
--- a/include/basegfx/polygon/b2dpolypolygoncutter.hxx
+++ b/include/basegfx/polygon/b2dpolypolygoncutter.hxx
@@ -138,7 +138,7 @@ namespace basegfx
             @param rInput
             The source PolyPolygons
 
-            @return A single PolyPolygon containing the Or-merged result
+            @return A single tools::PolyPolygon containing the Or-merged result
         */
         BASEGFX_DLLPUBLIC B2DPolyPolygon mergeToSinglePolyPolygon(const B2DPolyPolygonVector& rInput);
 
diff --git a/include/basegfx/polygon/b2dpolypolygontools.hxx b/include/basegfx/polygon/b2dpolypolygontools.hxx
index e92fe5a2f01a..11fed4743019 100644
--- a/include/basegfx/polygon/b2dpolypolygontools.hxx
+++ b/include/basegfx/polygon/b2dpolypolygontools.hxx
@@ -124,7 +124,7 @@ namespace basegfx
         };
 
         /** the PointIndexSet itself; it allows to define a 'selection'of
-            points in a PolyPolygon by giving the polygon and point index.
+            points in a tools::PolyPolygon by giving the polygon and point index.
             Adding points double makes no sense, hence the std::set
          */
         typedef std::set< PointIndex > PointIndexSet;
@@ -181,11 +181,11 @@ namespace basegfx
         // organisation, e.g. same amount of polygons
         BASEGFX_DLLPUBLIC B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t);
 
-        // create 3d PolyPolygon from given 2d PolyPolygon. The given fZCoordinate is used to expand the
+        // create 3d tools::PolyPolygon from given 2d PolyPolygon. The given fZCoordinate is used to expand the
         // third coordinate.
         BASEGFX_DLLPUBLIC B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate = 0.0);
 
-        // create 2d PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given
+        // create 2d tools::PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given
         // matrix and the resulting x,y is used to form the new polygon.
         BASEGFX_DLLPUBLIC B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat);
 
@@ -205,7 +205,7 @@ namespace basegfx
         /** Predicate whether a given poly-polygon is a rectangle.
 
             @param rPoly
-            PolyPolygon to check
+            tools::PolyPolygon to check
 
             @return true, if the poly-polygon describes a rectangle
             (contains exactly one polygon, polygon is closed, and the
diff --git a/include/basegfx/polygon/b2dtrapezoid.hxx b/include/basegfx/polygon/b2dtrapezoid.hxx
index 569f1425f83a..d56c48fbc425 100644
--- a/include/basegfx/polygon/b2dtrapezoid.hxx
+++ b/include/basegfx/polygon/b2dtrapezoid.hxx
@@ -107,7 +107,7 @@ namespace basegfx
             double fLineWidth = 1.0);
 
         // create trapezoids for all edges of the given polyPolygon. The closed state of
-        // the PolyPolygon is taken into account. If curves are contaned, the default
+        // the tools::PolyPolygon is taken into account. If curves are contaned, the default
         // AdaptiveSubdivision will be used.
         BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolyPolygon(
             B2DTrapezoidVector& ro_Result,
diff --git a/include/basegfx/polygon/b3dpolypolygon.hxx b/include/basegfx/polygon/b3dpolypolygon.hxx
index 461a325a95a7..3ca1e10740ae 100644
--- a/include/basegfx/polygon/b3dpolypolygon.hxx
+++ b/include/basegfx/polygon/b3dpolypolygon.hxx
@@ -95,7 +95,7 @@ namespace basegfx
         // flip polygon direction
         void flip();
 
-        // test if PolyPolygon has double points
+        // test if tools::PolyPolygon has double points
         bool hasDoublePoints() const;
 
         // remove double points, at the begin/end and follow-ups, too
diff --git a/include/cppcanvas/canvas.hxx b/include/cppcanvas/canvas.hxx
index 9b5ce34c3336..2104dee39a5e 100644
--- a/include/cppcanvas/canvas.hxx
+++ b/include/cppcanvas/canvas.hxx
@@ -47,7 +47,7 @@ namespace cppcanvas
     class PolyPolygon;
     class Canvas;
 
-    // forward declaration, since PolyPolygon also references Canvas
+    // forward declaration, since tools::PolyPolygon also references Canvas
     typedef ::boost::shared_ptr< PolyPolygon > PolyPolygonSharedPtr;
 
     // forward declaration, since cloneCanvas() also references Canvas
diff --git a/include/cppcanvas/canvasgraphic.hxx b/include/cppcanvas/canvasgraphic.hxx
index ca3db47be9e1..09d8018ef76f 100644
--- a/include/cppcanvas/canvasgraphic.hxx
+++ b/include/cppcanvas/canvasgraphic.hxx
@@ -37,7 +37,7 @@ namespace basegfx
 
 namespace cppcanvas
 {
-    // forward declaration, since PolyPolygon also derives from CanvasGraphic
+    // forward declaration, since tools::PolyPolygon also derives from CanvasGraphic
     typedef ::boost::shared_ptr< class PolyPolygon > PolyPolygonSharedPtr;
 
 
diff --git a/include/cppcanvas/polypolygon.hxx b/include/cppcanvas/polypolygon.hxx
index 1db71e276a74..3cb186354512 100644
--- a/include/cppcanvas/polypolygon.hxx
+++ b/include/cppcanvas/polypolygon.hxx
@@ -37,12 +37,12 @@ namespace com { namespace sun { namespace star { namespace rendering
 } } } }
 
 
-/* Definition of PolyPolygon interface */
+/* Definition of tools::PolyPolygon interface */
 
 namespace cppcanvas
 {
 
-    /** This interface defines a PolyPolygon canvas object
+    /** This interface defines a tools::PolyPolygon canvas object
 
         Consider this object part of the view, and not of the model
         data. Although the given polygon is typically copied and held
diff --git a/include/cppcanvas/vclfactory.hxx b/include/cppcanvas/vclfactory.hxx
index 9d85248f9340..a48c62416569 100644
--- a/include/cppcanvas/vclfactory.hxx
+++ b/include/cppcanvas/vclfactory.hxx
@@ -35,7 +35,7 @@ namespace vcl { class Window; }
 class Bitmap;
 class BitmapEx;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Size;
 class Graphic;
 class GDIMetaFile;
diff --git a/include/drawinglayer/primitive2d/maskprimitive2d.hxx b/include/drawinglayer/primitive2d/maskprimitive2d.hxx
index 1aae7c1a0f53..b7b2e1092850 100644
--- a/include/drawinglayer/primitive2d/maskprimitive2d.hxx
+++ b/include/drawinglayer/primitive2d/maskprimitive2d.hxx
@@ -34,16 +34,16 @@ namespace drawinglayer
         /** MaskPrimitive2D class
 
             This is the central masking primitive. It's a grouping
-            primitive and contains a PolyPolygon which defines the visible
+            primitive and contains a tools::PolyPolygon which defines the visible
             area. Only visualisation parts of the Child primitive sequence
-            inside of the mask PolyPolygon is defined to be visible.
+            inside of the mask tools::PolyPolygon is defined to be visible.
 
             This primitive should be handled by a renderer. If it is not handled,
             it decomposes to its Child content, and thus the visualisation would
             contaiun no clips.
 
             The geometrc range of this primitive is completely defined by the Mask
-            PolyPolygon since by definition nothing outside of the mask is visible.
+            tools::PolyPolygon since by definition nothing outside of the mask is visible.
          */
         class DRAWINGLAYER_DLLPUBLIC MaskPrimitive2D : public GroupPrimitive2D
         {
diff --git a/include/drawinglayer/primitive2d/patternfillprimitive2d.hxx b/include/drawinglayer/primitive2d/patternfillprimitive2d.hxx
index a22a891206a6..9776978c6fae 100644
--- a/include/drawinglayer/primitive2d/patternfillprimitive2d.hxx
+++ b/include/drawinglayer/primitive2d/patternfillprimitive2d.hxx
@@ -33,10 +33,10 @@ namespace drawinglayer
     {
         /** PatternFillPrimitive2D class
 
-            This primitive allows filling a given PolyPolygon with a pattern
+            This primitive allows filling a given tools::PolyPolygon with a pattern
             defined by a sequence of primitives which are mapped to  the unit range.
             The pattern is defined using a reference range which defines a rectangular
-            area relative to the PolyPolygon (in unit coordinates) which is virtually
+            area relative to the tools::PolyPolygon (in unit coordinates) which is virtually
             infinitely repeated.
          */
         class DRAWINGLAYER_DLLPUBLIC PatternFillPrimitive2D : public BufferedDecompositionPrimitive2D
diff --git a/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx b/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
index e65952250362..f80e5193a9ee 100644
--- a/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
+++ b/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
@@ -201,14 +201,14 @@ namespace drawinglayer
     {
         /** PolyPolygonColorPrimitive2D class
 
-            This primitive defines a PolyPolygon filled with a single color.
+            This primitive defines a tools::PolyPolygon filled with a single color.
             This is one of the non-decomposable primitives, so a renderer
             should process it.
          */
         class DRAWINGLAYER_DLLPUBLIC PolyPolygonColorPrimitive2D : public BasePrimitive2D
         {
         private:
-            /// the PolyPolygon geometry
+            /// the tools::PolyPolygon geometry
             basegfx::B2DPolyPolygon                 maPolyPolygon;
 
             /// the polygon fill color
@@ -245,14 +245,14 @@ namespace drawinglayer
     {
         /** PolyPolygonColorPrimitive2D class
 
-            This primitive defines a PolyPolygon filled with a gradient. The
+            This primitive defines a tools::PolyPolygon filled with a gradient. The
             decomosition will create a MaskPrimitive2D containing a
             FillGradientPrimitive2D.
          */
         class DRAWINGLAYER_DLLPUBLIC PolyPolygonGradientPrimitive2D : public BufferedDecompositionPrimitive2D
         {
         private:
-            /// the PolyPolygon geometry
+            /// the tools::PolyPolygon geometry
             basegfx::B2DPolyPolygon                     maPolyPolygon;
 
             /// the definition range
@@ -298,14 +298,14 @@ namespace drawinglayer
     {
         /** PolyPolygonHatchPrimitive2D class
 
-            This primitive defines a PolyPolygon filled with a hatch. The
+            This primitive defines a tools::PolyPolygon filled with a hatch. The
             decomosition will create a MaskPrimitive2D containing a
             FillHatchPrimitive2D.
          */
         class DRAWINGLAYER_DLLPUBLIC PolyPolygonHatchPrimitive2D : public BufferedDecompositionPrimitive2D
         {
         private:
-            /// the PolyPolygon geometry
+            /// the tools::PolyPolygon geometry
             basegfx::B2DPolyPolygon                     maPolyPolygon;
 
             /// the definition range
@@ -357,14 +357,14 @@ namespace drawinglayer
     {
         /** PolyPolygonGraphicPrimitive2D class
 
-            This primitive defines a PolyPolygon filled with bitmap data
+            This primitive defines a tools::PolyPolygon filled with bitmap data
             (including transparence). The decomosition will create a MaskPrimitive2D
             containing a FillGraphicPrimitive2D.
          */
         class DRAWINGLAYER_DLLPUBLIC PolyPolygonGraphicPrimitive2D : public BufferedDecompositionPrimitive2D
         {
         private:
-            /// the PolyPolygon geometry
+            /// the tools::PolyPolygon geometry
             basegfx::B2DPolyPolygon                     maPolyPolygon;
 
             /// the definition range
@@ -410,14 +410,14 @@ namespace drawinglayer
     {
         /** PolyPolygonSelectionPrimitive2D class
 
-            This primitive defines a PolyPolygon which gets filled with a defined color
+            This primitive defines a tools::PolyPolygon which gets filled with a defined color
             and a defined transparence, but also gets extended ('grown') by the given
             discrete size (thus being a view-dependent primitive)
          */
         class DRAWINGLAYER_DLLPUBLIC PolyPolygonSelectionPrimitive2D : public DiscreteMetricDependentPrimitive2D
         {
         private:
-            /// the PolyPolygon geometry
+            /// the tools::PolyPolygon geometry
             basegfx::B2DPolyPolygon                 maPolyPolygon;
 
             /// the color
diff --git a/include/drawinglayer/primitive2d/textprimitive2d.hxx b/include/drawinglayer/primitive2d/textprimitive2d.hxx
index bb8dd1a21343..311ec94e71ae 100644
--- a/include/drawinglayer/primitive2d/textprimitive2d.hxx
+++ b/include/drawinglayer/primitive2d/textprimitive2d.hxx
@@ -47,7 +47,7 @@ namespace drawinglayer
 
             This is the basic primitive for representing a text portion. It contains
             all needed information. If it is not handled by a renderer, its decomposition
-            will provide the text PolyPolygon outlines as filled polygons, correctly
+            will provide the text tools::PolyPolygon outlines as filled polygons, correctly
             transformed.
 
             To get better text quality, it is suggested to handle tis primitive directly
diff --git a/include/drawinglayer/primitive3d/polypolygonprimitive3d.hxx b/include/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
index 47ed330213c0..41337ac3a564 100644
--- a/include/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
+++ b/include/drawinglayer/primitive3d/polypolygonprimitive3d.hxx
@@ -34,7 +34,7 @@ namespace drawinglayer
     {
         /** PolyPolygonMaterialPrimitive3D class
 
-            This primitive defines a planar 3D PolyPolygon filled with a single color.
+            This primitive defines a planar 3D tools::PolyPolygon filled with a single color.
             This is one of the non-decomposable primitives, so a renderer
             should process it.
 
@@ -43,7 +43,7 @@ namespace drawinglayer
         class DRAWINGLAYER_DLLPUBLIC PolyPolygonMaterialPrimitive3D : public BasePrimitive3D
         {
         private:
-            /// the PolyPolygon geometry
+            /// the tools::PolyPolygon geometry
             basegfx::B3DPolyPolygon                     maPolyPolygon;
 
             /// the fill parameters
diff --git a/include/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx b/include/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
index 9155378f7112..030144f8e91c 100644
--- a/include/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
+++ b/include/drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx
@@ -34,7 +34,7 @@ namespace drawinglayer
         /** SdrExtrudePrimitive3D class
 
             This 3D primitive expands the SdrPrimitive3D to a 3D extrude definition.
-            The given 2D PolyPolygon geometry is imagined as lying on the XY-plane in 3D
+            The given 2D tools::PolyPolygon geometry is imagined as lying on the XY-plane in 3D
             and gets extruded in Z-Direction by Depth.
 
             Various possibilities e.g. for creating diagonals (edge roudings in 3D)
diff --git a/include/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx b/include/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
index fe030c9a6fe8..bf6dfb237a0b 100644
--- a/include/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
+++ b/include/drawinglayer/primitive3d/sdrlatheprimitive3d.hxx
@@ -34,7 +34,7 @@ namespace drawinglayer
         /** SdrLathePrimitive3D class
 
             This 3D primitive expands the SdrPrimitive3D to a 3D rotation definition.
-            The given 2D PolyPolygon geometry is imagined as lying on the XY-plane in 3D
+            The given 2D tools::PolyPolygon geometry is imagined as lying on the XY-plane in 3D
             and gets rotated around the Y-Axis.
 
             Various possibilities e.g. for creating diagonals (edge roudings in 3D)
diff --git a/include/drawinglayer/processor2d/canvasprocessor.hxx b/include/drawinglayer/processor2d/canvasprocessor.hxx
index e742e039486a..d928a84a5d35 100644
--- a/include/drawinglayer/processor2d/canvasprocessor.hxx
+++ b/include/drawinglayer/processor2d/canvasprocessor.hxx
@@ -82,7 +82,7 @@ namespace drawinglayer
             // SvtOptionsDrawinglayer incarnation to react on diverse settings
             const SvtOptionsDrawinglayer                            maDrawinglayerOpt;
 
-            // the current clipping PolyPolygon from MaskPrimitive2D, always in
+            // the current clipping tools::PolyPolygon from MaskPrimitive2D, always in
             // object coordinates
             basegfx::B2DPolyPolygon                                 maClipPolyPolygon;
 
diff --git a/include/editeng/editeng.hxx b/include/editeng/editeng.hxx
index e10b7a1b826c..882b0a4428ee 100644
--- a/include/editeng/editeng.hxx
+++ b/include/editeng/editeng.hxx
@@ -76,7 +76,7 @@ class MapMode;
 class Color;
 namespace vcl { class Font; }
 class KeyEvent;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Size;
 class Point;
 class Rectangle;
diff --git a/include/editeng/outliner.hxx b/include/editeng/outliner.hxx
index 5a020c147830..ac5f18b6ffab 100644
--- a/include/editeng/outliner.hxx
+++ b/include/editeng/outliner.hxx
@@ -56,7 +56,7 @@ class Pointer;
 class CommandEvent;
 class MapMode;
 class OutputDevice;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class SfxStyleSheetPool;
 class SfxStyleSheet;
 class SfxItemPool;
diff --git a/include/editeng/txtrange.hxx b/include/editeng/txtrange.hxx
index b18a79302f2d..8fe6b4f2bb5d 100644
--- a/include/editeng/txtrange.hxx
+++ b/include/editeng/txtrange.hxx
@@ -24,7 +24,7 @@
 #include <tools/gen.hxx>
 #include <deque>
 
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Rectangle;
 
 namespace basegfx {
@@ -43,8 +43,8 @@ class EDITENG_DLLPUBLIC TextRanger
         RangeCache(const Range& rng) : range(rng) {};
     };
     std::deque<RangeCache> mRangeCache; //!< Cached range calculations.
-    PolyPolygon *mpPolyPolygon; // Surface polygon
-    PolyPolygon *mpLinePolyPolygon; // Line polygon
+    tools::PolyPolygon *mpPolyPolygon; // Surface polygon
+    tools::PolyPolygon *mpLinePolyPolygon; // Line polygon
     Rectangle *pBound;  // Comprehensive rectangle
     sal_uInt16 nCacheSize;  // Cache-Size
     sal_uInt16 nRight;      // Distance Contour-Text
@@ -75,8 +75,8 @@ public:
     bool IsInner() const { return bInner; }
     bool IsVertical() const { return bVertical; }
     bool HasBorder() const { return nRight || nLeft; }
-    const PolyPolygon& GetPolyPolygon() const { return *mpPolyPolygon; }
-    const PolyPolygon* GetLinePolygon() const { return mpLinePolyPolygon; }
+    const tools::PolyPolygon& GetPolyPolygon() const { return *mpPolyPolygon; }
+    const tools::PolyPolygon* GetLinePolygon() const { return mpLinePolyPolygon; }
     const Rectangle& GetBoundRect()
         { return pBound ? static_cast< const Rectangle& >(*pBound) : _GetBoundRect(); }
     void SetUpper( sal_uInt16 nNew ){ nUpper = nNew; }
diff --git a/include/filter/msfilter/escherex.hxx b/include/filter/msfilter/escherex.hxx
index 29de8abcfec6..82c84e3fc074 100644
--- a/include/filter/msfilter/escherex.hxx
+++ b/include/filter/msfilter/escherex.hxx
@@ -1327,10 +1327,10 @@ public:
     bool        IsFontWork() const;
 
     // helper functions which are also used by the escher import
-    static PolyPolygon  GetPolyPolygon(
+    static tools::PolyPolygon  GetPolyPolygon(
                             const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > & rXShape
                         );
-    static PolyPolygon  GetPolyPolygon( const ::com::sun::star::uno::Any& rSource );
+    static tools::PolyPolygon  GetPolyPolygon( const ::com::sun::star::uno::Any& rSource );
     static MSO_SPT      GetCustomShapeType(
                             const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > & rXShape,
                             sal_uInt32& nMirrorFlags
diff --git a/include/filter/msfilter/msdffimp.hxx b/include/filter/msfilter/msdffimp.hxx
index 5f2d1c9a2132..33cbc41fd221 100644
--- a/include/filter/msfilter/msdffimp.hxx
+++ b/include/filter/msfilter/msdffimp.hxx
@@ -54,7 +54,7 @@ class SvStream;
 class SdrObject;
 class SdrOle2Obj;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class FmFormModel;
 class SdrModel;
 class SwFlyFrmFmt;
diff --git a/include/filter/msfilter/svdfppt.hxx b/include/filter/msfilter/svdfppt.hxx
index 74c044233cb1..594cb54391e0 100644
--- a/include/filter/msfilter/svdfppt.hxx
+++ b/include/filter/msfilter/svdfppt.hxx
@@ -45,7 +45,7 @@ class SdrPage;
 class SdrObject;
 class SvStream;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class SfxItemSet;
 class Outliner;
 class Graphic;
diff --git a/include/oox/export/drawingml.hxx b/include/oox/export/drawingml.hxx
index f68c5e6428c7..4bfaf3a6e572 100644
--- a/include/oox/export/drawingml.hxx
+++ b/include/oox/export/drawingml.hxx
@@ -176,7 +176,7 @@ public:
 
     void WritePresetShape( const char* pShape );
     void WritePresetShape( const char* pShape, MSO_SPT eShapeType, bool bPredefinedHandlesUsed, sal_Int32 nAdjustmentsWhichNeedsToBeConverted, const ::com::sun::star::beans::PropertyValue& rProp );
-    void WritePolyPolygon( const PolyPolygon& rPolyPolygon );
+    void WritePolyPolygon( const tools::PolyPolygon& rPolyPolygon );
     void WriteFill( ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropSet );
     void WriteShapeStyle( ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > rXPropSet );
     void WriteShapeEffects( ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > rXPropSet );
diff --git a/include/postwin.h b/include/postwin.h
index 37bf579c7a42..8f9be8959c25 100644
--- a/include/postwin.h
+++ b/include/postwin.h
@@ -19,7 +19,6 @@
 
 /* not protected, do only include once! */
 
-#undef PolyPolygon
 #undef Polygon
 #undef Rectangle
 #undef DELETE
diff --git a/include/prewin.h b/include/prewin.h
index b60372f89d1f..3ec0312aa222 100644
--- a/include/prewin.h
+++ b/include/prewin.h
@@ -23,7 +23,6 @@
 
 #define Rectangle    BLA_Rectangle
 #define Polygon      BLA_Polygon
-#define PolyPolygon  BLA_PolyPolygon
 #define Folder       WIN_Folder
 #define GradientStyle_RECT  WIN_GradientStyle_RECT
 
diff --git a/include/svtools/grfmgr.hxx b/include/svtools/grfmgr.hxx
index bca790be0472..30ac6345a489 100644
--- a/include/svtools/grfmgr.hxx
+++ b/include/svtools/grfmgr.hxx
@@ -201,7 +201,7 @@ private:
                                 Point& rPt,
                                 Size& rSz,
                                 const GraphicAttr* pAttr,
-                                PolyPolygon& rClipPolyPoly,
+                                tools::PolyPolygon& rClipPolyPoly,
                                 bool& bRectClipRegion
                             ) const;
 
diff --git a/include/svx/contdlg.hxx b/include/svx/contdlg.hxx
index 75954e0f2b2c..f1192de2a0f8 100644
--- a/include/svx/contdlg.hxx
+++ b/include/svx/contdlg.hxx
@@ -80,14 +80,14 @@ public:
     const Graphic&      GetGraphic() const;
     bool                IsGraphicChanged() const;
 
-    PolyPolygon         GetPolyPolygon();
+    tools::PolyPolygon         GetPolyPolygon();
 
     const void*         GetEditingObject() const;
 
     void                Update( const Graphic& rGraphic, bool bGraphicLinked,
-                                const PolyPolygon* pPolyPoly = NULL, void* pEditingObj = NULL );
+                                const tools::PolyPolygon* pPolyPoly = NULL, void* pEditingObj = NULL );
 
-    static PolyPolygon  CreateAutoContour(  const Graphic& rGraphic,
+    static tools::PolyPolygon  CreateAutoContour(  const Graphic& rGraphic,
                                             const Rectangle* pRect = NULL,
                                             const sal_uIntPtr nFlags = 0L );
 };
diff --git a/include/svx/svdobj.hxx b/include/svx/svdobj.hxx
index 3eac84f5efa5..81b176a668f5 100644
--- a/include/svx/svdobj.hxx
+++ b/include/svx/svdobj.hxx
@@ -69,7 +69,7 @@ class SfxUndoAction;
 class XFillAttrSetItem;
 class XLineAttrSetItem;
 class SfxItemPool;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class SfxPoolItem;
 class SdrVirtObj;
 class SdrDragView;
@@ -591,7 +591,7 @@ public:
     virtual OUString TakeObjNamePlural() const;
 
     // Das Xor-Polygon wird von der View zu Draggen des Objektes benoetigt.
-    // Alle Polygone innerhalb des PolyPolygon werden als PolyLine interpretiert.
+    // Alle Polygone innerhalb des tools::PolyPolygon werden als PolyLine interpretiert.
     // Moechte man ein geschlossenes Polygon, so muss man es explizit schliessen.
     virtual basegfx::B2DPolyPolygon TakeXorPoly() const;
 
@@ -868,7 +868,7 @@ public:
     // In this case it would have to:
     // - set SOLID_BRUSH with the color of the given pen,
     // - set NULL_PEN, and
-    // - generate PolyPolygon with two polygons with four supporting points each.
+    // - generate tools::PolyPolygon with two polygons with four supporting points each.
     // In each case the return value is a SdrObject*, because it is also
     // allowed to return group objects (e.g. for SdrTextObj).
     // In the case of the conversion from TextObj to PathObj,
diff --git a/include/svx/svdtrans.hxx b/include/svx/svdtrans.hxx
index fa6319f7ef9e..b287c23816f3 100644
--- a/include/svx/svdtrans.hxx
+++ b/include/svx/svdtrans.hxx
@@ -52,7 +52,7 @@ inline long Round(double a) { return a>0.0 ? (long)(a+0.5) : -(long)((-a)+0.5);
 inline void MoveRect(Rectangle& rRect, const Size& S)    { rRect.Move(S.Width(),S.Height()); }
 inline void MovePoint(Point& rPnt, const Size& S)        { rPnt.X()+=S.Width(); rPnt.Y()+=S.Height(); }
 inline void MovePoly(Polygon& rPoly, const Size& S)      { rPoly.Move(S.Width(),S.Height()); }
-inline void MovePoly(PolyPolygon& rPoly, const Size& S)  { rPoly.Move(S.Width(),S.Height()); }
+inline void MovePoly(tools::PolyPolygon& rPoly, const Size& S)  { rPoly.Move(S.Width(),S.Height()); }
 void MoveXPoly(XPolygon& rPoly, const Size& S);
 
 SVX_DLLPUBLIC void ResizeRect(Rectangle& rRect, const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bNoJustify = false);
diff --git a/include/svx/xpoly.hxx b/include/svx/xpoly.hxx
index 57c9432262fe..52de1f120f33 100644
--- a/include/svx/xpoly.hxx
+++ b/include/svx/xpoly.hxx
@@ -26,7 +26,7 @@ class Point;
 class Rectangle;
 class SvStream;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class OutputDevice;
 
 #define XPOLYPOLY_APPEND     0xFFFF
diff --git a/include/tools/poly.hxx b/include/tools/poly.hxx
index dbfb94da729a..4d38ce08ff37 100644
--- a/include/tools/poly.hxx
+++ b/include/tools/poly.hxx
@@ -73,7 +73,7 @@ public:
 class SvStream;
 class ImplPolygon;
 class ImplPolyPolygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 
 namespace basegfx
 {
@@ -195,19 +195,21 @@ public:
     explicit Polygon(const ::basegfx::B2DPolygon& rPolygon);
 };
 
+namespace tools {
+
 class TOOLS_DLLPUBLIC SAL_WARN_UNUSED PolyPolygon
 {
 private:
     ImplPolyPolygon*    mpImplPolyPolygon;
 
-    TOOLS_DLLPRIVATE void  ImplDoOperation( const PolyPolygon& rPolyPoly, PolyPolygon& rResult, sal_uIntPtr nOperation ) const;
+    TOOLS_DLLPRIVATE void  ImplDoOperation( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult, sal_uIntPtr nOperation ) const;
     TOOLS_DLLPRIVATE void *ImplCreateArtVpath() const;
     TOOLS_DLLPRIVATE void  ImplSetFromArtVpath( void *pVpath );
 
 public:
                         PolyPolygon( sal_uInt16 nInitSize = 16, sal_uInt16 nResize = 16 );
                         PolyPolygon( const Polygon& rPoly );
-                        PolyPolygon( const PolyPolygon& rPolyPoly );
+                        PolyPolygon( const tools::PolyPolygon& rPolyPoly );
                         ~PolyPolygon();
 
     void                Insert( const Polygon& rPoly, sal_uInt16 nPos = POLYPOLY_APPEND );
@@ -242,11 +244,11 @@ public:
         the original polygon is guaranteed to be smaller than one
         pixel.
      */
-    void                AdaptiveSubdivide( PolyPolygon& rResult, const double d = 1.0 ) const;
-    static PolyPolygon  SubdivideBezier( const PolyPolygon& rPolyPoly );
+    void                AdaptiveSubdivide( tools::PolyPolygon& rResult, const double d = 1.0 ) const;
+    static tools::PolyPolygon  SubdivideBezier( const tools::PolyPolygon& rPolyPoly );
 
-    void                GetIntersection( const PolyPolygon& rPolyPoly, PolyPolygon& rResult ) const;
-    void                GetUnion( const PolyPolygon& rPolyPoly, PolyPolygon& rResult ) const;
+    void                GetIntersection( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult ) const;
+    void                GetUnion( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult ) const;
 
     void                Move( long nHorzMove, long nVertMove );
     void                Translate( const Point& rTrans );
@@ -257,15 +259,15 @@ public:
     const Polygon&      operator[]( sal_uInt16 nPos ) const { return GetObject( nPos ); }
     Polygon&            operator[]( sal_uInt16 nPos );
 
-    PolyPolygon&        operator=( const PolyPolygon& rPolyPoly );
-    bool                operator==( const PolyPolygon& rPolyPoly ) const;
-    bool                operator!=( const PolyPolygon& rPolyPoly ) const
+    tools::PolyPolygon&        operator=( const tools::PolyPolygon& rPolyPoly );
+    bool                operator==( const tools::PolyPolygon& rPolyPoly ) const;
+    bool                operator!=( const tools::PolyPolygon& rPolyPoly ) const
                             { return !(PolyPolygon::operator==( rPolyPoly )); }
 
-    bool                IsEqual( const PolyPolygon& rPolyPoly ) const;
+    bool                IsEqual( const tools::PolyPolygon& rPolyPoly ) const;
 
-    TOOLS_DLLPUBLIC friend SvStream&    ReadPolyPolygon( SvStream& rIStream, PolyPolygon& rPolyPoly );
-    TOOLS_DLLPUBLIC friend SvStream&    WritePolyPolygon( SvStream& rOStream, const PolyPolygon& rPolyPoly );
+    TOOLS_DLLPUBLIC friend SvStream&    ReadPolyPolygon( SvStream& rIStream, tools::PolyPolygon& rPolyPoly );
+    TOOLS_DLLPUBLIC friend SvStream&    WritePolyPolygon( SvStream& rOStream, const tools::PolyPolygon& rPolyPoly );
 
     void                Read( SvStream& rIStream );
     void                Write( SvStream& rOStream ) const;
@@ -278,12 +280,14 @@ public:
      explicit PolyPolygon(const ::basegfx::B2DPolyPolygon& rPolyPolygon);
 };
 
-typedef std::vector< PolyPolygon > PolyPolyVector;
+} /* namespace tools */
+
+typedef std::vector< tools::PolyPolygon > PolyPolyVector;
 
 
 template<typename charT, typename traits>
 inline std::basic_ostream<charT, traits> & operator <<(
-    std::basic_ostream<charT, traits> & stream, const PolyPolygon& rPolyPoly)
+    std::basic_ostream<charT, traits> & stream, const tools::PolyPolygon& rPolyPoly)
 {
     if (!rPolyPoly.Count())
         stream << "EMPTY";
diff --git a/include/vcl/bitmap.hxx b/include/vcl/bitmap.hxx
index 516e4072f05b..accb763c5faa 100644
--- a/include/vcl/bitmap.hxx
+++ b/include/vcl/bitmap.hxx
@@ -694,7 +694,7 @@ public:
         @return true, if the operation was completed successfully.
      */
     bool                    Vectorize(
-                                PolyPolygon& rPolyPoly,
+                                tools::PolyPolygon& rPolyPoly,
                                 sal_uLong nFlags = BMP_VECTORIZE_OUTER,
                                 const Link* pProgress = NULL );
 
diff --git a/include/vcl/canvastools.hxx b/include/vcl/canvastools.hxx
index 774f09ff50e0..08b5b6dba648 100644
--- a/include/vcl/canvastools.hxx
+++ b/include/vcl/canvastools.hxx
@@ -31,7 +31,7 @@ class Point;
 class Size;
 class Rectangle;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Bitmap;
 class BitmapEx;
 class Color;
diff --git a/include/vcl/gdimtf.hxx b/include/vcl/gdimtf.hxx
index 414f4306ac8f..5a80213a7550 100644
--- a/include/vcl/gdimtf.hxx
+++ b/include/vcl/gdimtf.hxx
@@ -34,7 +34,7 @@ class SvStream;
 class Color;
 class BitmapEx;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Gradient;
 
 
@@ -106,11 +106,11 @@ private:
                                                         const Size& rOffset, double fSin, double fCos );
     SAL_DLLPRIVATE Polygon         ImplGetRotatedPolygon( const Polygon& rPoly, const Point& rRotatePt,
                                                           const Size& rOffset, double fSin, double fCos );
-    SAL_DLLPRIVATE PolyPolygon     ImplGetRotatedPolyPolygon( const PolyPolygon& rPoly, const Point& rRotatePt,
+    SAL_DLLPRIVATE tools::PolyPolygon     ImplGetRotatedPolyPolygon( const tools::PolyPolygon& rPoly, const Point& rRotatePt,
                                                               const Size& rOffset, double fSin, double fCos );
     SAL_DLLPRIVATE void            ImplAddGradientEx( GDIMetaFile&          rMtf,
                                                       const OutputDevice&   rMapDev,
-                                                      const PolyPolygon&    rPolyPoly,
+                                                      const tools::PolyPolygon&    rPolyPoly,
                                                       const Gradient&       rGrad       );
     SAL_DLLPRIVATE bool          ImplPlayWithRenderer( OutputDevice* pOut, const Point& rPos, Size rLogicDestSize );
     SAL_DLLPRIVATE void          ImplDelegate2PluggableRenderer( const MetaCommentAction* pAct, OutputDevice* pOut );
diff --git a/include/vcl/graphictools.hxx b/include/vcl/graphictools.hxx
index a96ac40d2427..ace82ffa545b 100644
--- a/include/vcl/graphictools.hxx
+++ b/include/vcl/graphictools.hxx
@@ -83,8 +83,8 @@ public:
         See accessor method descriptions for argument description
      */
     SvtGraphicStroke( const Polygon&        rPath,
-                      const PolyPolygon&    rStartArrow,
-                      const PolyPolygon&    rEndArrow,
+                      const tools::PolyPolygon&    rStartArrow,
+                      const tools::PolyPolygon&    rEndArrow,
                       double                fTransparency,
                       double                fStrokeWidth,
                       CapType               aCap,
@@ -108,7 +108,7 @@ public:
         width, it has to fit every stroke with every stroke width
         exactly.
      */
-    void            getStartArrow       ( PolyPolygon& ) const;
+    void            getStartArrow       ( tools::PolyPolygon& ) const;
     /** Get the polygon that is put at the end of the line
 
         The polygon is in a special normalized position, and already
@@ -122,7 +122,7 @@ public:
         arrow does have this width, it has to fit every stroke with
         every stroke width exactly.
      */
-    void            getEndArrow         ( PolyPolygon& ) const;
+    void            getEndArrow         ( tools::PolyPolygon& ) const;
     /** Get stroke transparency
 
         @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
@@ -155,7 +155,7 @@ public:
         arrow does have this width, it will fit every stroke with
         every stroke width exactly.
      */
-    void    setStartArrow       ( const PolyPolygon& );
+    void    setStartArrow       ( const tools::PolyPolygon& );
     /** Set the polygon that is put at the end of the line
 
         The polygon has to be in a special normalized position, and
@@ -169,7 +169,7 @@ public:
         arrow does have this width, it will fit every stroke with
         every stroke width exactly.
      */
-    void    setEndArrow         ( const PolyPolygon& );
+    void    setEndArrow         ( const tools::PolyPolygon& );
     /// Affine scaling in both X and Y dimensions
     void    scale               ( double fScaleX, double fScaleY );
 
@@ -179,8 +179,8 @@ private:
     VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicStroke( SvStream& rIStm, SvtGraphicStroke& rClass );
 
     Polygon         maPath;
-    PolyPolygon     maStartArrow;
-    PolyPolygon     maEndArrow;
+    tools::PolyPolygon     maStartArrow;
+    tools::PolyPolygon     maEndArrow;
     double          mfTransparency;
     double          mfStrokeWidth;
     CapType         maCapType;
@@ -281,7 +281,7 @@ public:
 
         See accessor method descriptions for argument description
      */
-    SvtGraphicFill( const PolyPolygon&  rPath,
+    SvtGraphicFill( const tools::PolyPolygon&  rPath,
                     Color               aFillColor,
                     double              fTransparency,
                     FillRule            aFillRule,
@@ -298,7 +298,7 @@ public:
 
     // accessors
     /// Query path to fill
-    void            getPath             ( PolyPolygon& ) const;
+    void            getPath             ( tools::PolyPolygon& ) const;
     /// Get color used for solid fills
     const Color&    getFillColor        () const { return maFillColor;}
     /** Get stroke transparency
@@ -348,14 +348,14 @@ public:
 
     // mutators
     /// Set path to fill
-    void    setPath             ( const PolyPolygon& rPath );
+    void    setPath             ( const tools::PolyPolygon& rPath );
 
 private:
     // friends
     VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicFill( SvStream& rOStm, const SvtGraphicFill& rClass );
     VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicFill( SvStream& rIStm, SvtGraphicFill& rClass );
 
-    PolyPolygon     maPath;
+    tools::PolyPolygon     maPath;
     Color           maFillColor;
     double          mfTransparency;
     FillRule        maFillRule;
diff --git a/include/vcl/metaact.hxx b/include/vcl/metaact.hxx
index d98d9ef87e57..1aea53f3a0a4 100644
--- a/include/vcl/metaact.hxx
+++ b/include/vcl/metaact.hxx
@@ -413,7 +413,7 @@ class VCL_DLLPUBLIC MetaPolyPolygonAction : public MetaAction
 {
 private:
 
-    PolyPolygon         maPolyPoly;
+    tools::PolyPolygon  maPolyPoly;
 
     virtual bool    Compare( const MetaAction& ) const SAL_OVERRIDE;
 
@@ -427,12 +427,12 @@ public:
     virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) SAL_OVERRIDE;
     virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) SAL_OVERRIDE;
 
-    explicit            MetaPolyPolygonAction( const PolyPolygon& );
+    explicit            MetaPolyPolygonAction( const tools::PolyPolygon& );
 
     virtual void        Move( long nHorzMove, long nVertMove ) SAL_OVERRIDE;
     virtual void        Scale( double fScaleX, double fScaleY ) SAL_OVERRIDE;
 
-    const PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
 };
 
 class VCL_DLLPUBLIC MetaTextAction : public MetaAction
@@ -937,7 +937,7 @@ class VCL_DLLPUBLIC MetaGradientExAction : public MetaAction
 {
 private:
 
-    PolyPolygon         maPolyPoly;
+    tools::PolyPolygon  maPolyPoly;
     Gradient            maGradient;
 
     virtual bool    Compare( const MetaAction& ) const SAL_OVERRIDE;
@@ -952,12 +952,12 @@ public:
     virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) SAL_OVERRIDE;
     virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) SAL_OVERRIDE;
 
-                        MetaGradientExAction( const PolyPolygon& rPolyPoly, const Gradient& rGradient );
+                        MetaGradientExAction( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
 
     virtual void        Move( long nHorzMove, long nVertMove ) SAL_OVERRIDE;
     virtual void        Scale( double fScaleX, double fScaleY ) SAL_OVERRIDE;
 
-    const PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
     const Gradient&     GetGradient() const { return maGradient; }
 };
 
@@ -965,7 +965,7 @@ class VCL_DLLPUBLIC MetaHatchAction : public MetaAction
 {
 private:
 
-    PolyPolygon         maPolyPoly;
+    tools::PolyPolygon  maPolyPoly;
     Hatch               maHatch;
 
     virtual bool    Compare( const MetaAction& ) const SAL_OVERRIDE;
@@ -980,12 +980,12 @@ public:
     virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) SAL_OVERRIDE;
     virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) SAL_OVERRIDE;
 
-                        MetaHatchAction( const PolyPolygon& rPolyPoly, const Hatch& rHatch );
+                        MetaHatchAction( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch );
 
     virtual void        Move( long nHorzMove, long nVertMove ) SAL_OVERRIDE;
     virtual void        Scale( double fScaleX, double fScaleY ) SAL_OVERRIDE;
 
-    const PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
     const Hatch&        GetHatch() const { return maHatch; }
 };
 
@@ -1410,7 +1410,7 @@ class VCL_DLLPUBLIC MetaTransparentAction : public MetaAction
 {
 private:
 
-    PolyPolygon         maPolyPoly;
+    tools::PolyPolygon      maPolyPoly;
     sal_uInt16              mnTransPercent;
 
     virtual bool    Compare( const MetaAction& ) const SAL_OVERRIDE;
@@ -1425,12 +1425,12 @@ public:
     virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) SAL_OVERRIDE;
     virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) SAL_OVERRIDE;
 
-                        MetaTransparentAction( const PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent );
+                        MetaTransparentAction( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent );
 
     virtual void        Move( long nHorzMove, long nVertMove ) SAL_OVERRIDE;
     virtual void        Scale( double fScaleX, double fScaleY ) SAL_OVERRIDE;
 
-    const PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
     sal_uInt16              GetTransparence() const { return mnTransPercent; }
 };
 
diff --git a/include/vcl/outdev.hxx b/include/vcl/outdev.hxx
index 6dc4f076cba7..fd04d9814d7a 100644
--- a/include/vcl/outdev.hxx
+++ b/include/vcl/outdev.hxx
@@ -781,14 +781,14 @@ public:
 
         @see DrawPolyLine
      */
-    void                        DrawPolyPolygon( const PolyPolygon& rPolyPoly );
+    void                        DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly );
     void                        DrawPolyPolygon( const basegfx::B2DPolyPolygon& );
 
 private:
 
-    SAL_DLLPRIVATE void         ImplDrawPolygon( const Polygon& rPoly, const PolyPolygon* pClipPolyPoly = NULL );
-    SAL_DLLPRIVATE void         ImplDrawPolyPolygon( const PolyPolygon& rPolyPoly, const PolyPolygon* pClipPolyPoly = NULL );
-    SAL_DLLPRIVATE void         ImplDrawPolyPolygon( sal_uInt16 nPoly, const PolyPolygon& rPolyPoly );
+    SAL_DLLPRIVATE void         ImplDrawPolygon( const Polygon& rPoly, const tools::PolyPolygon* pClipPolyPoly = NULL );
+    SAL_DLLPRIVATE void         ImplDrawPolyPolygon( const tools::PolyPolygon& rPolyPoly, const tools::PolyPolygon* pClipPolyPoly = NULL );
+    SAL_DLLPRIVATE void         ImplDrawPolyPolygon( sal_uInt16 nPoly, const tools::PolyPolygon& rPolyPoly );
     // #i101491#
     // Helper who implements the DrawPolyPolygon functionality for basegfx::B2DPolyPolygon
     // without MetaFile processing
@@ -825,7 +825,7 @@ public:
 
 public:
     void                        DrawGradient( const Rectangle& rRect, const Gradient& rGradient );
-    void                        DrawGradient( const PolyPolygon& rPolyPoly, const Gradient& rGradient );
+    void                        DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
 
     void                        AddGradientActions(
                                     const Rectangle& rRect,
@@ -840,8 +840,8 @@ protected:
 
 private:
 
-    SAL_DLLPRIVATE void         DrawLinearGradient( const Rectangle& rRect, const Gradient& rGradient, bool bMtf, const PolyPolygon* pClipPolyPoly );
-    SAL_DLLPRIVATE void         DrawComplexGradient( const Rectangle& rRect, const Gradient& rGradient, bool bMtf, const PolyPolygon* pClipPolyPoly );
+    SAL_DLLPRIVATE void         DrawLinearGradient( const Rectangle& rRect, const Gradient& rGradient, bool bMtf, const tools::PolyPolygon* pClipPolyPoly );
+    SAL_DLLPRIVATE void         DrawComplexGradient( const Rectangle& rRect, const Gradient& rGradient, bool bMtf, const tools::PolyPolygon* pClipPolyPoly );
 
     SAL_DLLPRIVATE long         GetGradientSteps( const Gradient& rGradient, const Rectangle& rRect, bool bMtf, bool bComplex=false );
 
@@ -857,23 +857,23 @@ private:
 public:
 
 #ifdef _MSC_VER
-    void                        DrawHatch( const PolyPolygon& rPolyPoly, const ::Hatch& rHatch );
-    void                        AddHatchActions( const PolyPolygon& rPolyPoly,
+    void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const ::Hatch& rHatch );
+    void                        AddHatchActions( const tools::PolyPolygon& rPolyPoly,
                                                  const ::Hatch& rHatch,
                                                  GDIMetaFile& rMtf );
 #else
-    void                        DrawHatch( const PolyPolygon& rPolyPoly, const Hatch& rHatch );
-    void                        AddHatchActions( const PolyPolygon& rPolyPoly,
+    void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch );
+    void                        AddHatchActions( const tools::PolyPolygon& rPolyPoly,
                                                  const Hatch& rHatch,
                                                  GDIMetaFile& rMtf );
 #endif
 
-    void                        DrawHatch( const PolyPolygon& rPolyPoly, const Hatch& rHatch, bool bMtf );
+    void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch, bool bMtf );
 
 private:
 
     SAL_DLLPRIVATE void         CalcHatchValues( const Rectangle& rRect, long nDist, sal_uInt16 nAngle10, Point& rPt1, Point& rPt2, Size& rInc, Point& rEndPt1 );
-    SAL_DLLPRIVATE void         DrawHatchLine( const Line& rLine, const PolyPolygon& rPolyPoly, Point* pPtBuffer, bool bMtf );
+    SAL_DLLPRIVATE void         DrawHatchLine( const Line& rLine, const tools::PolyPolygon& rPolyPoly, Point* pPtBuffer, bool bMtf );
     ///@}
 
 
@@ -1001,7 +1001,7 @@ public:
 
     Rectangle                   ImplGetTextBoundRect( const SalLayout& );
 
-    bool                        GetTextOutline( PolyPolygon&,
+    bool                        GetTextOutline( tools::PolyPolygon&,
                                                 const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0,
                                                 sal_Int32 nLen = -1, bool bOptimize = true,
                                                 sal_uLong nLayoutWidth = 0, const long* pDXArray = NULL ) const;
@@ -1156,7 +1156,7 @@ public:
      */
     SystemFontData              GetSysFontData( int nFallbacklevel ) const;
 
-    SAL_DLLPRIVATE void         ImplGetEmphasisMark( PolyPolygon& rPolyPoly, bool& rPolyLine, Rectangle& rRect1, Rectangle& rRect2,
+    SAL_DLLPRIVATE void         ImplGetEmphasisMark( tools::PolyPolygon& rPolyPoly, bool& rPolyLine, Rectangle& rRect1, Rectangle& rRect2,
                                                      long& rYOff, long& rWidth, FontEmphasisMark eEmphasis, long nHeight, short nOrient );
     SAL_DLLPRIVATE static FontEmphasisMark
                                 ImplGetEmphasisMarkStyle( const vcl::Font& rFont );
@@ -1216,7 +1216,7 @@ private:
     SAL_DLLPRIVATE OUString     ImplGetEllipsisString( const OutputDevice& rTargetDevice, const OUString& rStr,
                                                        long nMaxWidth, sal_uInt16 nStyle, const ::vcl::ITextLayout& _rLayout );
 
-    SAL_DLLPRIVATE void         ImplDrawEmphasisMark( long nBaseX, long nX, long nY, const PolyPolygon& rPolyPoly, bool bPolyLine, const Rectangle& rRect1, const Rectangle& rRect2 );
+    SAL_DLLPRIVATE void         ImplDrawEmphasisMark( long nBaseX, long nX, long nY, const tools::PolyPolygon& rPolyPoly, bool bPolyLine, const Rectangle& rRect1, const Rectangle& rRect2 );
     SAL_DLLPRIVATE void         ImplDrawEmphasisMarks( SalLayout& );
     ///@}
 
@@ -1512,7 +1512,7 @@ public:
     virtual sal_uInt16          GetAlphaBitCount() const;
 
 
-    void                        DrawTransparent( const PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
+    void                        DrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
     void                        DrawTransparent( const basegfx::B2DPolyPolygon& rB2DPolyPoly, double fTransparency);
     void                        DrawTransparent(
                                         const GDIMetaFile& rMtf, const Point& rPos, const Size& rSize,
@@ -1520,12 +1520,12 @@ public:
 
 protected:
 
-    virtual void                EmulateDrawTransparent( const PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
-    void                        DrawInvisiblePolygon( const PolyPolygon& rPolyPoly );
+    virtual void                EmulateDrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
+    void                        DrawInvisiblePolygon( const tools::PolyPolygon& rPolyPoly );
 
 private:
 
-    SAL_DLLPRIVATE bool         DrawTransparentNatively( const PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
+    SAL_DLLPRIVATE bool         DrawTransparentNatively( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
     ///@}
 
 
@@ -1614,7 +1614,7 @@ public:
     Size                        LogicToPixel( const Size& rLogicSize ) const;
     Rectangle                   LogicToPixel( const Rectangle& rLogicRect ) const;
     Polygon                     LogicToPixel( const Polygon& rLogicPoly ) const;
-    PolyPolygon                 LogicToPixel( const PolyPolygon& rLogicPolyPoly ) const;
+    tools::PolyPolygon          LogicToPixel( const tools::PolyPolygon& rLogicPolyPoly ) const;
     basegfx::B2DPolyPolygon     LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly ) const;
     vcl::Region                      LogicToPixel( const vcl::Region& rLogicRegion )const;
     Point                       LogicToPixel( const Point& rLogicPt,
@@ -1627,7 +1627,7 @@ public:
                                               const MapMode& rMapMode ) const;
     basegfx::B2DPolygon         LogicToPixel( const basegfx::B2DPolygon& rLogicPoly,
                                               const MapMode& rMapMode ) const;
-    PolyPolygon                 LogicToPixel( const PolyPolygon& rLogicPolyPoly,
+    tools::PolyPolygon          LogicToPixel( const tools::PolyPolygon& rLogicPolyPoly,
                                               const MapMode& rMapMode ) const;
     basegfx::B2DPolyPolygon     LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly,
                                               const MapMode& rMapMode ) const;
@@ -1639,7 +1639,7 @@ public:
     Size                        PixelToLogic( const Size& rDeviceSize ) const;
     Rectangle                   PixelToLogic( const Rectangle& rDeviceRect ) const;
     Polygon                     PixelToLogic( const Polygon& rDevicePoly ) const;
-    PolyPolygon                 PixelToLogic( const PolyPolygon& rDevicePolyPoly ) const;
+    tools::PolyPolygon          PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly ) const;
     basegfx::B2DPolyPolygon     PixelToLogic( const basegfx::B2DPolyPolygon& rDevicePolyPoly ) const;
     vcl::Region                      PixelToLogic( const vcl::Region& rDeviceRegion ) const;
     Point                       PixelToLogic( const Point& rDevicePt,
@@ -1652,7 +1652,7 @@ public:
                                               const MapMode& rMapMode ) const;
     basegfx::B2DPolygon         PixelToLogic( const basegfx::B2DPolygon& rDevicePoly,
                                               const MapMode& rMapMode ) const;
-    PolyPolygon                 PixelToLogic( const PolyPolygon& rDevicePolyPoly,
+    tools::PolyPolygon          PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly,
                                               const MapMode& rMapMode ) const;
     basegfx::B2DPolyPolygon     PixelToLogic( const basegfx::B2DPolyPolygon& rDevicePolyPoly,
                                               const MapMode& rMapMode ) const;
@@ -1842,7 +1842,7 @@ private:
 
      @returns Polypolygon based on physical device pixel coordinates and units.
      */
-    SAL_DLLPRIVATE PolyPolygon  ImplLogicToDevicePixel( const PolyPolygon& rLogicPolyPoly ) const;
+    SAL_DLLPRIVATE tools::PolyPolygon  ImplLogicToDevicePixel( const tools::PolyPolygon& rLogicPolyPoly ) const;
 
     /** Convert a line in logical units to a line in physical device pixel units.
 
diff --git a/include/vcl/pdfwriter.hxx b/include/vcl/pdfwriter.hxx
index 56ce18c40052..03211f42aa80 100644
--- a/include/vcl/pdfwriter.hxx
+++ b/include/vcl/pdfwriter.hxx
@@ -48,7 +48,7 @@ class GDIMetaFile;
 class MapMode;
 class Polygon;
 class LineInfo;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Bitmap;
 class BitmapEx;
 class Image;
@@ -791,7 +791,7 @@ The following structure describes the permissions used in PDF security
                                       const LineInfo& rLineInfo );
     void                DrawPolyLine( const Polygon& rPoly, const ExtLineInfo& rInfo );
     void                DrawPolygon( const Polygon& rPoly );
-    void                DrawPolyPolygon( const PolyPolygon& rPolyPoly );
+    void                DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly );
     void                DrawRect( const Rectangle& rRect );
     void                DrawRect( const Rectangle& rRect,
                                   sal_uLong nHorzRount, sal_uLong nVertRound );
@@ -810,12 +810,12 @@ The following structure describes the permissions used in PDF security
                                       const BitmapEx& rBitmapEx );
 
     void                DrawGradient( const Rectangle& rRect, const Gradient& rGradient );
-    void                DrawGradient( const PolyPolygon& rPolyPoly, const Gradient& rGradient );
+    void                DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
 
-    void                DrawHatch( const PolyPolygon& rPolyPoly, const Hatch& rHatch );
+    void                DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch );
 
     void                DrawWallpaper( const Rectangle& rRect, const Wallpaper& rWallpaper );
-    void                DrawTransparent( const PolyPolygon& rPolyPoly,
+    void                DrawTransparent( const tools::PolyPolygon& rPolyPoly,
                                          sal_uInt16 nTransparencePercent );
 
     /** Start a transparency group
diff --git a/include/vcl/print.hxx b/include/vcl/print.hxx
index 6de196c8a6c8..99d781e60f30 100644
--- a/include/vcl/print.hxx
+++ b/include/vcl/print.hxx
@@ -288,7 +288,7 @@ protected:
                                     const Point& rSrcPtPixel, const Size& rSrcSizePixel,
                                     BitmapEx& rBitmapEx ) SAL_OVERRIDE;
 
-    virtual void                EmulateDrawTransparent( const PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent ) SAL_OVERRIDE;
+    virtual void                EmulateDrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent ) SAL_OVERRIDE;
 
     virtual void                InitFont() const SAL_OVERRIDE;
     virtual void                SetFontOrientation( ImplFontEntry* const pFontEntry ) const SAL_OVERRIDE;
diff --git a/include/vcl/region.hxx b/include/vcl/region.hxx
index f4d2dd31644a..362fa45ee35e 100644
--- a/include/vcl/region.hxx
+++ b/include/vcl/region.hxx
@@ -29,13 +29,13 @@
 class ImplRegionBand;
 class RegionBand;
 class Polygon;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 namespace vcl { class Window; }
 class OutputDevice;
 class Bitmap;
 
 typedef boost::shared_ptr< RegionBand > RegionBandPtr;
-typedef boost::shared_ptr< PolyPolygon > PolyPolygonPtr;
+typedef boost::shared_ptr< tools::PolyPolygon > PolyPolygonPtr;
 typedef boost::shared_ptr< basegfx::B2DPolyPolygon > B2DPolyPolygonPtr;
 typedef std::vector< Rectangle > RectangleVector;
 
@@ -57,10 +57,10 @@ private:
     bool                        mbIsNull : 1;
 
     // helpers
-    SAL_DLLPRIVATE void ImplCreatePolyPolyRegion( const PolyPolygon& rPolyPoly );
+    SAL_DLLPRIVATE void ImplCreatePolyPolyRegion( const tools::PolyPolygon& rPolyPoly );
     SAL_DLLPRIVATE void ImplCreatePolyPolyRegion( const basegfx::B2DPolyPolygon& rPolyPoly );
 
-    SAL_DLLPRIVATE PolyPolygon ImplCreatePolyPolygonFromRegionBand() const;
+    SAL_DLLPRIVATE tools::PolyPolygon ImplCreatePolyPolygonFromRegionBand() const;
     SAL_DLLPRIVATE basegfx::B2DPolyPolygon ImplCreateB2DPolyPolygonFromRegionBand() const;
 
 public:
@@ -68,19 +68,19 @@ public:
     explicit Region(bool bIsNull = false); // default creates empty region, with true a null region is created
     explicit Region(const Rectangle& rRect);
     explicit Region(const Polygon& rPolygon);
-    explicit Region(const PolyPolygon& rPolyPoly);
+    explicit Region(const tools::PolyPolygon& rPolyPoly);
     explicit Region(const basegfx::B2DPolyPolygon&);
     Region(const vcl::Region& rRegion);
     ~Region();
 
     // direct access to contents
     const basegfx::B2DPolyPolygon* getB2DPolyPolygon() const { return mpB2DPolyPolygon.get(); }
-    const PolyPolygon* getPolyPolygon() const { return mpPolyPolygon.get(); }
+    const tools::PolyPolygon* getPolyPolygon() const { return mpPolyPolygon.get(); }
     const RegionBand* getRegionBand() const { return mpRegionBand.get(); }
 
     // access with converters, the asked data will be created from the most
     // valuable data, buffered and returned
-    const PolyPolygon GetAsPolyPolygon() const;
+    const tools::PolyPolygon GetAsPolyPolygon() const;
     const basegfx::B2DPolyPolygon GetAsB2DPolyPolygon() const;
     const RegionBand* GetAsRegionBand() const;
 
@@ -124,11 +124,11 @@ public:
      * rectangles, then the returned vcl::Region will be constructed by
      * XOr'ing the contained Polygons together; in the case of
      * only Rectangles this can be up to eight times faster than
-     * Region( const PolyPolygon& ).
+     * Region( const tools::PolyPolygon& ).
      * Caution: this is only useful if the vcl::Region is known to be
      * changed to rectangles; e.g. if being set as clip region
      */
-    static vcl::Region GetRegionFromPolyPolygon( const PolyPolygon& rPolyPoly );
+    static vcl::Region GetRegionFromPolyPolygon( const tools::PolyPolygon& rPolyPoly );
 };
 
 } /* namespace vcl */