fdo#82577: Handle PolyPolygon

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

Change-Id: I811ecbb3d55ba4ce66e4555a8586f60fcd57fb66

17 files changed, 106 insertions, 106 deletions

diff --git a/filter/source/flash/swfwriter.cxx b/filter/source/flash/swfwriter.cxx
index de866c4dac6d..ded932b424ac 100644
--- a/filter/source/flash/swfwriter.cxx
+++ b/filter/source/flash/swfwriter.cxx
@@ -334,13 +334,13 @@ sal_uInt16 Writer::defineShape( const GDIMetaFile& rMtf, sal_Int16 x, sal_Int16
 
 sal_uInt16 Writer::defineShape( const Polygon& rPoly, const FillStyle& rFillStyle )
 {
-    const PolyPolygon aPolyPoly( rPoly );
+    const tools::PolyPolygon aPolyPoly( rPoly );
     return defineShape( aPolyPoly, rFillStyle );
 }
 
 
 
-sal_uInt16 Writer::defineShape( const PolyPolygon& rPolyPoly, const FillStyle& rFillStyle )
+sal_uInt16 Writer::defineShape( const tools::PolyPolygon& rPolyPoly, const FillStyle& rFillStyle )
 {
     sal_uInt16 nShapeId = createID();
 
@@ -384,7 +384,7 @@ sal_uInt16 Writer::defineShape( const PolyPolygon& rPolyPoly, const FillStyle& r
 
 
 
-sal_uInt16 Writer::defineShape( const PolyPolygon& rPolyPoly, sal_uInt16 nLineWidth, const Color& rLineColor )
+sal_uInt16 Writer::defineShape( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nLineWidth, const Color& rLineColor )
 {
     sal_uInt16 nShapeId = createID();
 
diff --git a/filter/source/flash/swfwriter.hxx b/filter/source/flash/swfwriter.hxx
index 9e63078ecc85..efa22470216b 100644
--- a/filter/source/flash/swfwriter.hxx
+++ b/filter/source/flash/swfwriter.hxx
@@ -41,7 +41,7 @@
 
 class GDIMetaFile;
 class BitmapEx;
-class PolyPolygon;
+namespace tools { class PolyPolygon; }
 class Gradient;
 class SvtGraphicFill;
 class SvtGraphicStroke;
@@ -273,7 +273,7 @@ public:
     void storeTo( com::sun::star::uno::Reference< com::sun::star::io::XOutputStream > &xOutStream );
 
     // geometry
-    void setClipping( const PolyPolygon* pClipPolyPolygon );
+    void setClipping( const tools::PolyPolygon* pClipPolyPolygon );
 
     /** defines a flash shape from a filled polygon.
         The coordinates must be in twips */
@@ -281,11 +281,11 @@ public:
 
     /** defines a flash shape from a filled polypolygon.
         The coordinates must be in twips */
-    sal_uInt16 defineShape( const PolyPolygon& rPolyPoly, const FillStyle& rFillStyle );
+    sal_uInt16 defineShape( const tools::PolyPolygon& rPolyPoly, const FillStyle& rFillStyle );
 
     /** defines a flash shape from a outlined polypolygon.
         The coordinates must be in twips */
-    sal_uInt16 defineShape( const PolyPolygon& rPolyPoly, sal_uInt16 nLineWidth, const Color& rLineColor );
+    sal_uInt16 defineShape( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nLineWidth, const Color& rLineColor );
 
     /** defines a flash shape from a vcl metafile.
         The mapmode of the metafile is used to map all coordinates to twips.
@@ -329,7 +329,7 @@ public:
 private:
     Point                   map( const Point& rPoint ) const;
     Size                    map( const Size& rSize ) const;
-    void                    map( PolyPolygon& rPolyPolygon ) const;
+    void                    map( tools::PolyPolygon& rPolyPolygon ) const;
     sal_Int32               mapRelative( sal_Int32 n100thMM ) const;
 
     void startTag( sal_uInt8 nTagId );
@@ -343,11 +343,11 @@ private:
     void Impl_writeActions( const GDIMetaFile& rMtf );
     void Impl_writePolygon( const Polygon& rPoly, bool bFilled );
     void Impl_writePolygon( const Polygon& rPoly, bool bFilled, const Color& rFillColor, const Color& rLineColor );
-    void Impl_writePolyPolygon( const PolyPolygon& rPolyPoly, bool bFilled, sal_uInt8 nTransparence = 0);
-    void Impl_writePolyPolygon( const PolyPolygon& rPolyPoly, bool bFilled, const Color& rFillColor, const Color& rLineColor );
+    void Impl_writePolyPolygon( const tools::PolyPolygon& rPolyPoly, bool bFilled, sal_uInt8 nTransparence = 0);
+    void Impl_writePolyPolygon( const tools::PolyPolygon& rPolyPoly, bool bFilled, const Color& rFillColor, const Color& rLineColor );
     void Impl_writeText( const Point& rPos, const OUString& rText, const long* pDXArray, long nWidth );
     void Impl_writeText( const Point& rPos, const OUString& rText, const long* pDXArray, long nWidth, Color aTextColor );
-    void Impl_writeGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient );
+    void Impl_writeGradientEx( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
     void Impl_writeLine( const Point& rPt1, const Point& rPt2, const Color* pLineColor = NULL );
     void Impl_writeRect( const Rectangle& rRect, long nRadX, long nRadY );
     void Impl_writeEllipse( const Point& rCenter, long nRadX, long nRadY );
@@ -397,7 +397,7 @@ private:
 
     VirtualDevice*  mpVDev;
 
-    const PolyPolygon* mpClipPolyPolygon;
+    const tools::PolyPolygon* mpClipPolyPolygon;
 
     /** holds the information of the objects defined in the movie stream
         while executing defineShape
diff --git a/filter/source/flash/swfwriter1.cxx b/filter/source/flash/swfwriter1.cxx
index 89c0c22cc2f4..f2cf9e65b6b5 100644
--- a/filter/source/flash/swfwriter1.cxx
+++ b/filter/source/flash/swfwriter1.cxx
@@ -84,7 +84,7 @@ Size Writer::map( const Size& rSize ) const
 
 
 
-void Writer::map( PolyPolygon& rPolyPolygon ) const
+void Writer::map( tools::PolyPolygon& rPolyPolygon ) const
 {
     const sal_uInt16 nPolyCount = rPolyPolygon.Count();
     if( nPolyCount )
@@ -262,7 +262,7 @@ void Writer::Impl_addEndShapeRecord( BitStream& rBits )
 
 void Writer::Impl_writePolygon( const Polygon& rPoly, bool bFilled )
 {
-    PolyPolygon aPolyPoly( rPoly );
+    tools::PolyPolygon aPolyPoly( rPoly );
     Impl_writePolyPolygon( aPolyPoly, bFilled );
 }
 
@@ -270,13 +270,13 @@ void Writer::Impl_writePolygon( const Polygon& rPoly, bool bFilled )
 
 void Writer::Impl_writePolygon( const Polygon& rPoly, bool bFilled, const Color& rFillColor, const Color& rLineColor )
 {
-    PolyPolygon aPolyPoly( rPoly );
+    tools::PolyPolygon aPolyPoly( rPoly );
     Impl_writePolyPolygon( aPolyPoly, bFilled, rFillColor, rLineColor );
 }
 
 
 
-void Writer::Impl_writePolyPolygon( const PolyPolygon& rPolyPoly, bool bFilled, sal_uInt8 nTransparence /* = 0 */ )
+void Writer::Impl_writePolyPolygon( const tools::PolyPolygon& rPolyPoly, bool bFilled, sal_uInt8 nTransparence /* = 0 */ )
 {
     Color aLineColor( mpVDev->GetLineColor() );
     if( 0 == aLineColor.GetTransparency() )
@@ -289,9 +289,9 @@ void Writer::Impl_writePolyPolygon( const PolyPolygon& rPolyPoly, bool bFilled,
 
 
 
-void Writer::Impl_writePolyPolygon( const PolyPolygon& rPolyPoly, bool bFilled, const Color& rFillColor, const Color& rLineColor )
+void Writer::Impl_writePolyPolygon( const tools::PolyPolygon& rPolyPoly, bool bFilled, const Color& rFillColor, const Color& rLineColor )
 {
-    PolyPolygon aPolyPoly( rPolyPoly );
+    tools::PolyPolygon aPolyPoly( rPolyPoly );
 
     if( aPolyPoly.Count() )
     {
@@ -325,11 +325,11 @@ void Writer::Impl_writePolyPolygon( const PolyPolygon& rPolyPoly, bool bFilled,
 
 
 /** A gradient is a transition from one color to another, rendered inside a given polypolygon */
-void Writer::Impl_writeGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient )
+void Writer::Impl_writeGradientEx( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient )
 {
     if( rPolyPoly.Count() )
     {
-        PolyPolygon aPolyPolygon( rPolyPoly );
+        tools::PolyPolygon aPolyPolygon( rPolyPoly );
         map( aPolyPolygon );
 
         if( (rGradient.GetStyle() == GradientStyle_LINEAR && rGradient.GetAngle() == 900) || (rGradient.GetStyle() == GradientStyle_RADIAL)  )
@@ -359,7 +359,7 @@ void Writer::Impl_writeGradientEx( const PolyPolygon& rPolyPoly, const Gradient&
 
 
 
-void Writer::setClipping( const PolyPolygon* pClipPolyPolygon )
+void Writer::setClipping( const tools::PolyPolygon* pClipPolyPolygon )
 {
     mpClipPolyPolygon = pClipPolyPolygon;
 }
@@ -516,7 +516,7 @@ void Writer::Impl_writeText( const Point& rPos, const OUString& rText, const lon
     if( bRTL || (nScriptType != ScriptType::LATIN) )
     {
         // todo: optimize me as this will generate a huge amount of duplicate polygons
-        PolyPolygon aPolyPoygon;
+        tools::PolyPolygon aPolyPoygon;
         mpVDev->GetTextOutline( aPolyPoygon, rText, 0, 0, (sal_uInt16)nLen, true, nWidth, pDXArray );
         aPolyPoygon.Translate( rPos );
         Impl_writePolyPolygon( aPolyPoygon, true, aTextColor, aTextColor );
@@ -1173,7 +1173,7 @@ bool Writer::Impl_writeStroke( SvtGraphicStroke& rStroke )
 {
     Polygon aPolygon;
     rStroke.getPath( aPolygon );
-    PolyPolygon aPolyPolygon( aPolygon );
+    tools::PolyPolygon aPolyPolygon( aPolygon );
 
     map( aPolyPolygon );
 
@@ -1183,12 +1183,12 @@ bool Writer::Impl_writeStroke( SvtGraphicStroke& rStroke )
     if(SvtGraphicStroke::joinRound != rStroke.getJoinType())
         return false;
 
-    PolyPolygon aStartArrow;
+    tools::PolyPolygon aStartArrow;
     rStroke.getStartArrow( aStartArrow );
     if( 0 != aStartArrow.Count() )
         return false;       // todo: Implement line ends
 
-    PolyPolygon aEndArrow;
+    tools::PolyPolygon aEndArrow;
     rStroke.getEndArrow( aEndArrow );
     if( 0 != aEndArrow.Count() )
         return false;       // todo: Implement line ends
@@ -1215,7 +1215,7 @@ bool Writer::Impl_writeStroke( SvtGraphicStroke& rStroke )
 */
 bool Writer::Impl_writeFilling( SvtGraphicFill& rFilling )
 {
-    PolyPolygon aPolyPolygon;
+    tools::PolyPolygon aPolyPolygon;
     rFilling.getPath( aPolyPolygon );
 
     Rectangle aOldRect( aPolyPolygon.GetBoundRect() );
@@ -1365,7 +1365,7 @@ void Writer::Impl_handleLineInfoPolyPolygons(const LineInfo& rInfo, const basegf
             for(sal_uInt32 a(0); a < aFillPolyPolygon.count(); a++)
             {
                 const Polygon aPolygon(aFillPolyPolygon.getB2DPolygon(a));
-                Impl_writePolyPolygon(PolyPolygon(Polygon(aPolygon)), true );
+                Impl_writePolyPolygon(tools::PolyPolygon(Polygon(aPolygon)), true );
             }
 
             mpVDev->SetLineColor(aOldLineColor);
@@ -1510,7 +1510,7 @@ void Writer::Impl_writeActions( const GDIMetaFile& rMtf )
             case( META_POLYPOLYGON_ACTION ):
             {
                 const MetaPolyPolygonAction*    pA = (const MetaPolyPolygonAction*) pAction;
-                const PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
+                const tools::PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
 
                 if( rPolyPoly.Count() )
                     Impl_writePolyPolygon( rPolyPoly, true );
@@ -1546,7 +1546,7 @@ void Writer::Impl_writeActions( const GDIMetaFile& rMtf )
             case( META_TRANSPARENT_ACTION ):
             {
                 const MetaTransparentAction*    pA = (const MetaTransparentAction*) pAction;
-                const PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
+                const tools::PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
 
                 if( rPolyPoly.Count() )
                 {
diff --git a/filter/source/flash/swfwriter2.cxx b/filter/source/flash/swfwriter2.cxx
index 0e6110c96a60..b1fe002071a3 100644
--- a/filter/source/flash/swfwriter2.cxx
+++ b/filter/source/flash/swfwriter2.cxx
@@ -459,7 +459,7 @@ sal_uInt16 FlashFont::getGlyph( sal_uInt16 nChar, VirtualDevice* pVDev )
     aOldFont.SetOrientation(0);
 
     // let the virtual device convert the character to polygons
-    PolyPolygon aPolyPoly;
+    tools::PolyPolygon aPolyPoly;
     pVDev->GetTextOutline( aPolyPoly, OUString(nChar) );
 
     maGlyphOffsets.push_back( _uInt16( maGlyphData.getOffset() ) );
diff --git a/filter/source/graphicfilter/eos2met/eos2met.cxx b/filter/source/graphicfilter/eos2met/eos2met.cxx
index e6b7fc371c63..8aaa5b2c8b74 100644
--- a/filter/source/graphicfilter/eos2met/eos2met.cxx
+++ b/filter/source/graphicfilter/eos2met/eos2met.cxx
@@ -208,7 +208,7 @@ private:
     void METMove(Point aPt);
     void METLine(Point aPt1, Point aPt2);
     void METLine(const Polygon & rPolygon);
-    void METLine(const PolyPolygon & rPolyPolygon);
+    void METLine(const tools::PolyPolygon & rPolyPolygon);
     void METLineAtCurPos(Point aPt);
     void METBox(bool bFill, bool bBoundary,
                 Rectangle aRect, sal_uInt32 nHAxis, sal_uInt32 nVAxis);
@@ -1314,7 +1314,7 @@ void METWriter::METLine(const Polygon & rPolygon)
 }
 
 
-void METWriter::METLine(const PolyPolygon & rPolyPolygon)
+void METWriter::METLine(const tools::PolyPolygon & rPolyPolygon)
 {
     sal_uInt16 i,nCount;
     nCount=rPolyPolygon.Count();
@@ -1818,7 +1818,7 @@ void METWriter::WriteOrders( const GDIMetaFile* pMTF )
             {
                 const MetaPolyPolygonAction* pA = (const MetaPolyPolygonAction*) pMA;
 
-                PolyPolygon aSimplePolyPoly( pA->GetPolyPolygon() );
+                tools::PolyPolygon aSimplePolyPoly( pA->GetPolyPolygon() );
                 sal_uInt16 i, nCount = aSimplePolyPoly.Count();
                 for ( i = 0; i < nCount; i++ )
                 {
diff --git a/filter/source/graphicfilter/epict/epict.cxx b/filter/source/graphicfilter/epict/epict.cxx
index 1d574aa55880..e5fee90e9bdd 100644
--- a/filter/source/graphicfilter/epict/epict.cxx
+++ b/filter/source/graphicfilter/epict/epict.cxx
@@ -110,7 +110,7 @@ private:
         // counts the bitmaps and actions (nNumberOfActions and nNumberOfBitmaps
         // have to be set to 0 at the beginning, since this method is recursive)
 
-    Polygon PolyPolygonToPolygon(const PolyPolygon & rPoly);
+    Polygon PolyPolygonToPolygon(const tools::PolyPolygon & rPoly);
         // generates a relatively sane polygon on the basis of a PolyPolygon
 
     Rectangle MapRectangle( const Rectangle& rRect );
@@ -219,7 +219,7 @@ void PictWriter::CountActionsAndBitmaps(const GDIMetaFile & rMTF)
 }
 
 
-Polygon PictWriter::PolyPolygonToPolygon(const PolyPolygon & rPolyPoly)
+Polygon PictWriter::PolyPolygonToPolygon(const tools::PolyPolygon & rPolyPoly)
 {
     sal_uInt16 nCount,nSize1,nSize2,np,i1,i2,i3,nBestIdx1,nBestIdx2;
     long nDistSqr,nBestDistSqr, nCountdownTests;
@@ -1667,9 +1667,9 @@ void PictWriter::WriteOpcodes( const GDIMetaFile & rMTF )
             {
                 const MetaPolyPolygonAction* pA = (const MetaPolyPolygonAction*) pMA;
 
-                const PolyPolygon& rPolyPoly = pA->GetPolyPolygon();
+                const tools::PolyPolygon& rPolyPoly = pA->GetPolyPolygon();
                 sal_uInt16 nPolyCount = rPolyPoly.Count();
-                PolyPolygon aSimplePolyPoly( rPolyPoly );
+                tools::PolyPolygon aSimplePolyPoly( rPolyPoly );
                 for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
                 {
                     if ( aSimplePolyPoly[ i ].HasFlags() )
@@ -2074,7 +2074,7 @@ void PictWriter::WriteOpcodes( const GDIMetaFile & rMTF )
 
             case META_TRANSPARENT_ACTION:
             {
-                const PolyPolygon& rPolyPoly = ( (const MetaTransparentAction*) pMA )->GetPolyPolygon();
+                const tools::PolyPolygon& rPolyPoly = ( (const MetaTransparentAction*) pMA )->GetPolyPolygon();
 
                 if (aFillColor!=Color( COL_TRANSPARENT ))
                 {
diff --git a/filter/source/graphicfilter/eps/eps.cxx b/filter/source/graphicfilter/eps/eps.cxx
index 7cf09e88b0af..c9b8dd5beea5 100644
--- a/filter/source/graphicfilter/eps/eps.cxx
+++ b/filter/source/graphicfilter/eps/eps.cxx
@@ -202,9 +202,9 @@ private:
     void                ImplWriteLineInfo( const LineInfo& rLineInfo );
     void                ImplRect( const Rectangle & rRectangle );
     void                ImplRectFill ( const Rectangle & rRectangle );
-    void                ImplWriteGradient( const PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev );
-    void                ImplIntersect( const PolyPolygon& rPolyPoly );
-    void                ImplPolyPoly( const PolyPolygon & rPolyPolygon, bool bTextOutline = false );
+    void                ImplWriteGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev );
+    void                ImplIntersect( const tools::PolyPolygon& rPolyPoly );
+    void                ImplPolyPoly( const tools::PolyPolygon & rPolyPolygon, bool bTextOutline = false );
     void                ImplPolyLine( const Polygon & rPolygon );
 
     void                ImplSetClipRegion( vcl::Region& rRegion );
@@ -654,7 +654,7 @@ void PSWriter::ImplWriteEpilog()
 
 void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
 {
-    PolyPolygon aFillPath;
+    tools::PolyPolygon aFillPath;
 
     for( size_t nCurAction = 0, nCount = rMtf.GetActionSize(); nCurAction < nCount; nCurAction++ )
     {
@@ -715,7 +715,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
                 Rectangle   aRect = ( ( (const MetaEllipseAction*) pMA )->GetRect() );
                 Point       aCenter = aRect.Center();
                 Polygon     aPoly( aCenter, aRect.GetWidth() / 2, aRect.GetHeight() / 2 );
-                PolyPolygon aPolyPoly( aPoly );
+                tools::PolyPolygon aPolyPoly( aPoly );
                 ImplPolyPoly( aPolyPoly );
             }
             break;
@@ -724,7 +724,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
             {
                 Polygon aPoly( ( (const MetaArcAction*)pMA )->GetRect(), ( (const MetaArcAction*)pMA )->GetStartPoint(),
                     ( (const MetaArcAction*)pMA )->GetEndPoint(), POLY_ARC );
-                PolyPolygon aPolyPoly( aPoly );
+                tools::PolyPolygon aPolyPoly( aPoly );
                 ImplPolyPoly( aPolyPoly );
             }
             break;
@@ -733,7 +733,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
             {
                 Polygon aPoly( ( (const MetaPieAction*)pMA )->GetRect(), ( (const MetaPieAction*)pMA )->GetStartPoint(),
                     ( (const MetaPieAction*)pMA )->GetEndPoint(), POLY_PIE );
-                PolyPolygon aPolyPoly( aPoly );
+                tools::PolyPolygon aPolyPoly( aPoly );
                 ImplPolyPoly( aPolyPoly );
             }
             break;
@@ -742,7 +742,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
             {
                 Polygon aPoly( ( (const MetaChordAction*)pMA )->GetRect(), ( (const MetaChordAction*)pMA )->GetStartPoint(),
                     ( (const MetaChordAction*)pMA )->GetEndPoint(), POLY_CHORD );
-                PolyPolygon aPolyPoly( aPoly );
+                tools::PolyPolygon aPolyPoly( aPoly );
                 ImplPolyPoly( aPolyPoly );
             }
             break;
@@ -791,7 +791,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
 
             case META_POLYGON_ACTION :
             {
-                PolyPolygon aPolyPoly( ( (const MetaPolygonAction*) pMA )->GetPolygon() );
+                tools::PolyPolygon aPolyPoly( ( (const MetaPolygonAction*) pMA )->GetPolygon() );
                 ImplPolyPoly( aPolyPoly );
             }
             break;
@@ -926,14 +926,14 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
 
             case META_GRADIENT_ACTION :
             {
-                PolyPolygon aPolyPoly( ( (const MetaGradientAction*)pMA)->GetRect() );
+                tools::PolyPolygon aPolyPoly( ( (const MetaGradientAction*)pMA)->GetRect() );
                 ImplWriteGradient( aPolyPoly, ( (const MetaGradientAction*) pMA )->GetGradient(), rVDev );
             }
             break;
 
             case META_GRADIENTEX_ACTION :
             {
-                PolyPolygon aPolyPoly( ( (const MetaGradientExAction*)pMA)->GetPolyPolygon() );
+                tools::PolyPolygon aPolyPoly( ( (const MetaGradientExAction*)pMA)->GetPolyPolygon() );
                 ImplWriteGradient( aPolyPoly, ( (const MetaGradientExAction*) pMA )->GetGradient(), rVDev );
             }
             break;
@@ -1282,7 +1282,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
                 {
                     if ( aFillPath.Count() )
                     {
-                        aFillPath = PolyPolygon();
+                        aFillPath = tools::PolyPolygon();
                         ImplWriteLine( "gr" );
                     }
                 }
@@ -1304,8 +1304,8 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
                             Polygon aPath;
                             aStroke.getPath( aPath );
 
-                            PolyPolygon aStartArrow;
-                            PolyPolygon aEndArrow;
+                            tools::PolyPolygon aStartArrow;
+                            tools::PolyPolygon aEndArrow;
 //                          double fTransparency( aStroke.getTransparency() );
                             double fStrokeWidth( aStroke.getStrokeWidth() );
                             SvtGraphicStroke::JoinType eJT( aStroke.getJoinType() );
@@ -1341,7 +1341,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
                                 case SvtGraphicFill::fillSolid :
                                 {
                                     bSkipSequence = true;
-                                    PolyPolygon aPolyPoly;
+                                    tools::PolyPolygon aPolyPoly;
                                     aFill.getPath( aPolyPoly );
                                     sal_uInt16 i, nPolyCount = aPolyPoly.Count();
                                     if ( nPolyCount )
@@ -1416,7 +1416,7 @@ void PSWriter::ImplWriteActions( const GDIMetaFile& rMtf, VirtualDevice& rVDev )
                                         aTempMtf.AddAction( rMtf.GetAction( nBitmapAction )->Clone() );
                                         ImplWriteActions( aTempMtf, rVDev );
                                         ImplWriteLine( "gr" );
-                                        aFillPath = PolyPolygon();
+                                        aFillPath = tools::PolyPolygon();
                                     }
                                     else
                                         nCurAction = nCommentStartAction + 1;
@@ -1588,7 +1588,7 @@ void PSWriter::ImplAddPath( const Polygon & rPolygon )
 
 
 
-void PSWriter::ImplIntersect( const PolyPolygon& rPolyPoly )
+void PSWriter::ImplIntersect( const tools::PolyPolygon& rPolyPoly )
 {
     sal_uInt16 i, nPolyCount = rPolyPoly.Count();
     for ( i = 0; i < nPolyCount; )
@@ -1606,7 +1606,7 @@ void PSWriter::ImplIntersect( const PolyPolygon& rPolyPoly )
 
 
 
-void PSWriter::ImplWriteGradient( const PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev )
+void PSWriter::ImplWriteGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient, VirtualDevice& rVDev )
 {
     VirtualDevice   l_aVDev;
     GDIMetaFile     aTmpMtf;
@@ -1617,7 +1617,7 @@ void PSWriter::ImplWriteGradient( const PolyPolygon& rPolyPoly, const Gradient&
 
 
 
-void PSWriter::ImplPolyPoly( const PolyPolygon & rPolyPoly, bool bTextOutline )
+void PSWriter::ImplPolyPoly( const tools::PolyPolygon & rPolyPoly, bool bTextOutline )
 {
     sal_uInt16 i, nPolyCount = rPolyPoly.Count();
     if ( nPolyCount )
@@ -2158,7 +2158,7 @@ void PSWriter::ImplText( const OUString& rUniString, const Point& rPos, const lo
         }
         bool bOldLineColor = bLineColor;
         bLineColor = false;
-        std::vector<PolyPolygon> aPolyPolyVec;
+        std::vector<tools::PolyPolygon> aPolyPolyVec;
         if ( aVirDev.GetTextOutlines( aPolyPolyVec, rUniString, 0, 0, -1, true, nWidth, pDXArry ) )
         {
             // always adjust text position to match baseline alignment
@@ -2171,7 +2171,7 @@ void PSWriter::ImplText( const OUString& rUniString, const Point& rPos, const lo
                 ImplWriteF( nRotation, 1 );
                 mpPS->WriteCharPtr( "r " );
             }
-            std::vector<PolyPolygon>::iterator aIter( aPolyPolyVec.begin() );
+            std::vector<tools::PolyPolygon>::iterator aIter( aPolyPolyVec.begin() );
             while ( aIter != aPolyPolyVec.end() )
                 ImplPolyPoly( *aIter++, true );
             ImplWriteLine( "pom" );
diff --git a/filter/source/graphicfilter/icgm/actimpr.cxx b/filter/source/graphicfilter/icgm/actimpr.cxx
index 80f2d9c3054b..ad03946f9545 100644
--- a/filter/source/graphicfilter/icgm/actimpr.cxx
+++ b/filter/source/graphicfilter/icgm/actimpr.cxx
@@ -717,7 +717,7 @@ void CGMImpressOutAct::DrawPolybezier( Polygon& rPolygon )
 
 
 
-void CGMImpressOutAct::DrawPolyPolygon( PolyPolygon& rPolyPolygon )
+void CGMImpressOutAct::DrawPolyPolygon( tools::PolyPolygon& rPolyPolygon )
 {
     sal_uInt32 nNumPolys = rPolyPolygon.Count();
     if ( nNumPolys && ImplCreateShape( "com.sun.star.drawing.ClosedBezierShape" ) )
diff --git a/filter/source/graphicfilter/icgm/class4.cxx b/filter/source/graphicfilter/icgm/class4.cxx
index 64086a1a0949..f10cb18d3033 100644
--- a/filter/source/graphicfilter/icgm/class4.cxx
+++ b/filter/source/graphicfilter/icgm/class4.cxx
@@ -273,7 +273,7 @@ void CGM::ImplDoClass4()
                 sal_uInt16      nPoints = 0;
                 boost::scoped_array<Point> pPoints(new Point[ 0x4000 ]);
 
-                PolyPolygon aPolyPolygon;
+                tools::PolyPolygon aPolyPolygon;
                 FloatPoint  aFloatPoint;
                 sal_uInt32      nEdgeFlag;
                 while ( mnParaSize < mnElementSize )
diff --git a/filter/source/graphicfilter/icgm/outact.hxx b/filter/source/graphicfilter/icgm/outact.hxx
index 7e5fd3a1c4c0..49712e1f44ff 100644
--- a/filter/source/graphicfilter/icgm/outact.hxx
+++ b/filter/source/graphicfilter/icgm/outact.hxx
@@ -55,7 +55,7 @@ class CGMOutAct
         sal_uInt16                  mnIndex;                // figure
         sal_uInt8*                  mpFlags;
         Point*                  mpPoints;
-        PolyPolygon             maPolyPolygon;
+        tools::PolyPolygon             maPolyPolygon;
         ::com::sun::star::awt::Gradient*            mpGradient;
 
         CGM*                    mpCGM;
@@ -85,7 +85,7 @@ class CGMOutAct
     virtual void                DrawPolygon( Polygon& ) {} ;
     virtual void                DrawPolyLine( Polygon& ) {} ;
     virtual void                DrawPolybezier( Polygon& ) {} ;
-    virtual void                DrawPolyPolygon( PolyPolygon& ) {} ;
+    virtual void                DrawPolyPolygon( tools::PolyPolygon& ) {} ;
     virtual void                DrawText( ::com::sun::star::awt::Point&, ::com::sun::star::awt::Size&, char*, sal_uInt32, FinalFlag ) {} ;
     virtual void                AppendText( char*, sal_uInt32, FinalFlag ) {} ;
     virtual sal_uInt32              DrawText( TextEntry*, NodeFrameSet&, sal_uInt32 ) { return 0; } ;
@@ -126,7 +126,7 @@ public:
     virtual void                DrawPolygon( Polygon& ) SAL_OVERRIDE ;
     virtual void                DrawPolyLine( Polygon& ) SAL_OVERRIDE ;
     virtual void                DrawPolybezier( Polygon& ) SAL_OVERRIDE ;
-    virtual void                DrawPolyPolygon( PolyPolygon& ) SAL_OVERRIDE ;
+    virtual void                DrawPolyPolygon( tools::PolyPolygon& ) SAL_OVERRIDE ;
     virtual void                DrawText( ::com::sun::star::awt::Point& TextRectPos, ::com::sun::star::awt::Size& TextRectSize, char* String, sal_uInt32 StringSize, FinalFlag ) SAL_OVERRIDE ;
     virtual void                AppendText( char* String, sal_uInt32 StringSize, FinalFlag ) SAL_OVERRIDE ;
     virtual sal_uInt32              DrawText( TextEntry*, NodeFrameSet&, sal_uInt32 ) SAL_OVERRIDE ;
diff --git a/filter/source/graphicfilter/idxf/dxf2mtf.cxx b/filter/source/graphicfilter/idxf/dxf2mtf.cxx
index ba8f3fe0022e..a849b47cfc61 100644
--- a/filter/source/graphicfilter/idxf/dxf2mtf.cxx
+++ b/filter/source/graphicfilter/idxf/dxf2mtf.cxx
@@ -572,7 +572,7 @@ void DXF2GDIMetaFile::DrawHatchEntity(const DXFHatchEntity & rE, const DXFTransf
     {
         SetAreaAttribute( rE );
         sal_Int32 j = 0;
-        PolyPolygon aPolyPoly;
+        tools::PolyPolygon aPolyPoly;
         for ( j = 0; j < rE.nBoundaryPathCount; j++ )
         {
             DXFPointArray aPtAry;
diff --git a/filter/source/graphicfilter/ios2met/ios2met.cxx b/filter/source/graphicfilter/ios2met/ios2met.cxx
index 89e1c9b6ad4e..cc2d6bbecef7 100644
--- a/filter/source/graphicfilter/ios2met/ios2met.cxx
+++ b/filter/source/graphicfilter/ios2met/ios2met.cxx
@@ -213,7 +213,7 @@ struct OSPalette {
 struct OSArea {
     OSArea    * pSucc;
     sal_uInt8   nFlags;
-    PolyPolygon aPPoly;
+    tools::PolyPolygon aPPoly;
     bool    bClosed;
     Color       aCol;
     Color       aBgCol;
@@ -226,7 +226,7 @@ struct OSPath
 {
     OSPath*     pSucc;
     sal_uInt32  nID;
-    PolyPolygon aPPoly;
+    tools::PolyPolygon aPPoly;
     bool    bClosed;
     bool    bStroke;
 };
@@ -395,7 +395,7 @@ private:
     bool    IsLineInfo();
     void        DrawPolyLine( const Polygon& rPolygon );
     void        DrawPolygon( const Polygon& rPolygon );
-    void        DrawPolyPolygon( const PolyPolygon& rPolygon );
+    void        DrawPolyPolygon( const tools::PolyPolygon& rPolygon );
     sal_uInt16  ReadBigEndianWord();
     sal_uLong   ReadBigEndian3BytesLong();
     sal_uLong   ReadLittleEndian3BytesLong();
@@ -493,7 +493,7 @@ void OS2METReader::DrawPolygon( const Polygon& rPolygon )
         pVirDev->DrawPolygon( rPolygon );
 }
 
-void OS2METReader::DrawPolyPolygon( const PolyPolygon& rPolyPolygon )
+void OS2METReader::DrawPolyPolygon( const tools::PolyPolygon& rPolyPolygon )
 {
     if ( IsLineInfo() )
     {
@@ -513,7 +513,7 @@ void OS2METReader::AddPointsToArea(const Polygon & rPoly)
     sal_uInt16 nOldSize, nNewSize,i;
 
     if (pAreaStack==NULL || rPoly.GetSize()==0) return;
-    PolyPolygon * pPP=&(pAreaStack->aPPoly);
+    tools::PolyPolygon * pPP=&(pAreaStack->aPPoly);
     if (pPP->Count()==0 || pAreaStack->bClosed) pPP->Insert(rPoly);
     else {
         Polygon aLastPoly(pPP->GetObject(pPP->Count()-1));
@@ -534,7 +534,7 @@ void OS2METReader::AddPointsToPath(const Polygon & rPoly)
     sal_uInt16 nOldSize, nNewSize,i;
 
     if (pPathStack==NULL || rPoly.GetSize()==0) return;
-    PolyPolygon * pPP=&(pPathStack->aPPoly);
+    tools::PolyPolygon * pPP=&(pPathStack->aPPoly);
     if (pPP->Count()==0 /*|| pPathStack->bClosed==sal_True*/) pPP->Insert(rPoly);
     else {
         Polygon aLastPoly(pPP->GetObject(pPP->Count()-1));
@@ -1190,7 +1190,7 @@ void OS2METReader::ReadPartialArc(bool bGivenPos, sal_uInt16 nOrderSize)
 void OS2METReader::ReadPolygons()
 {
     sal_uInt32 i,j,nNumPolys, nNumPoints;
-    PolyPolygon aPolyPoly;
+    tools::PolyPolygon aPolyPoly;
     Polygon aPoly;
     Point aPoint;
     sal_uInt8 nFlags;
diff --git a/filter/source/msfilter/escherex.cxx b/filter/source/msfilter/escherex.cxx
index cac923aacc8f..2f6961b63a6c 100644
--- a/filter/source/msfilter/escherex.cxx
+++ b/filter/source/msfilter/escherex.cxx
@@ -862,7 +862,7 @@ bool EscherPropertyContainer::GetLineArrow( const bool bLineStart,
     if ( EscherPropertyValueHelper::GetPropertyValue(
             aAny, rXPropSet, sLine, false ) )
     {
-        PolyPolygon aPolyPoly( EscherPropertyContainer::GetPolyPolygon( aAny ) );
+        tools::PolyPolygon aPolyPoly( EscherPropertyContainer::GetPolyPolygon( aAny ) );
         if ( aPolyPoly.Count() && aPolyPoly[ 0 ].GetSize() )
         {
             bIsArrow = true;
@@ -1401,7 +1401,7 @@ GraphicObject lclDrawHatch( const ::com::sun::star::drawing::Hatch& rHatch, cons
     aOut.SetLineColor();
     aOut.SetFillColor(bFillBackground ? rBackColor : Color(COL_TRANSPARENT));
     aOut.DrawRect(rRect);
-    aOut.DrawHatch(PolyPolygon(rRect), Hatch((HatchStyle)rHatch.Style, Color(rHatch.Color), rHatch.Distance, (sal_uInt16)rHatch.Angle));
+    aOut.DrawHatch(tools::PolyPolygon(rRect), Hatch((HatchStyle)rHatch.Style, Color(rHatch.Color), rHatch.Distance, (sal_uInt16)rHatch.Angle));
     aMtf.Stop();
     aMtf.WindStart();
     aMtf.SetPrefMapMode(MapMode(MAP_100TH_MM));
@@ -1774,9 +1774,9 @@ bool EscherPropertyContainer::CreateGraphicProperties(
     return bRetValue;
 }
 
-PolyPolygon EscherPropertyContainer::GetPolyPolygon( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > & rXShape )
+tools::PolyPolygon EscherPropertyContainer::GetPolyPolygon( const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > & rXShape )
 {
-    PolyPolygon aRetPolyPoly;
+    tools::PolyPolygon aRetPolyPoly;
     ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > aXPropSet;
     ::com::sun::star::uno::Any aAny( rXShape->queryInterface(
         cppu::UnoType<com::sun::star::beans::XPropertySet>::get()));
@@ -1801,12 +1801,12 @@ PolyPolygon EscherPropertyContainer::GetPolyPolygon( const ::com::sun::star::uno
     return aRetPolyPoly;
 }
 
-PolyPolygon EscherPropertyContainer::GetPolyPolygon( const ::com::sun::star::uno::Any& rAny )
+tools::PolyPolygon EscherPropertyContainer::GetPolyPolygon( const ::com::sun::star::uno::Any& rAny )
 {
     bool bNoError = true;
 
     Polygon aPolygon;
-    PolyPolygon aPolyPolygon;
+    tools::PolyPolygon aPolyPolygon;
 
     if ( rAny.getValueType() == cppu::UnoType<com::sun::star::drawing::PolyPolygonBezierCoords>::get())
     {
@@ -2024,7 +2024,7 @@ bool EscherPropertyContainer::CreatePolygonProperties(
     bool    bRetValue = true;
     bool    bLine = ( nFlags & ESCHER_CREATEPOLYGON_LINE ) != 0;
 
-    PolyPolygon aPolyPolygon;
+    tools::PolyPolygon aPolyPolygon;
 
     if ( pPolygon )
         aPolyPolygon.Insert( *pPolygon, POLYPOLY_APPEND );
@@ -2385,7 +2385,7 @@ bool EscherPropertyContainer::CreateConnectorProperties(
                                 {
                                     if ( EscherPropertyValueHelper::GetPropertyValue( aAny, aXPropSet, sEdgePath ) )
                                     {
-                                        PolyPolygon aPolyPolygon = GetPolyPolygon( aAny );
+                                        tools::PolyPolygon aPolyPolygon = GetPolyPolygon( aAny );
                                         Polygon aPoly;
                                         if ( aPolyPolygon.Count() > 0 )
                                         {
@@ -4792,7 +4792,7 @@ sal_uInt32 EscherConnectorListEntry::GetConnectorRule( bool bFirst )
 
                         // #i74631# use explicit constructor here. Also XPolyPolygon is not necessary,
                         // reducing to PolyPolygon
-                        const PolyPolygon aPolyPoly(((SdrPathObj*)pPoly)->GetPathPoly());
+                        const tools::PolyPolygon aPolyPoly(((SdrPathObj*)pPoly)->GetPathPoly());
 
                         for ( a = 0; a < aPolyPoly.Count(); a++ )
                         {
diff --git a/filter/source/msfilter/msdffimp.cxx b/filter/source/msfilter/msdffimp.cxx
index c2962de8e0a7..5b4599ea2bc1 100644
--- a/filter/source/msfilter/msdffimp.cxx
+++ b/filter/source/msfilter/msdffimp.cxx
@@ -518,7 +518,7 @@ void SvxMSDffManager::SolveSolver( const SvxMSDffSolverContainer& rSolver )
                                     {
                                         bool bNotFound = true;
 
-                                        PolyPolygon aPolyPoly( EscherPropertyContainer::GetPolyPolygon( aXShape ) );
+                                        tools::PolyPolygon aPolyPoly( EscherPropertyContainer::GetPolyPolygon( aXShape ) );
                                         sal_uInt16 k, j, nPolySize = aPolyPoly.Count();
                                         if ( nPolySize )
                                         {
diff --git a/filter/source/svg/svgfontexport.cxx b/filter/source/svg/svgfontexport.cxx
index b1dd2a5cd99b..4454b8934e00 100644
--- a/filter/source/svg/svgfontexport.cxx
+++ b/filter/source/svg/svgfontexport.cxx
@@ -234,7 +234,7 @@ void SVGFontExport::implEmbedFont( const vcl::Font& rFont )
 
                     {
                         const Point         aPos;
-                        const PolyPolygon   aMissingGlyphPolyPoly( Rectangle( aPos, aSize ) );
+                        const tools::PolyPolygon   aMissingGlyphPolyPoly( Rectangle( aPos, aSize ) );
 
                         mrExport.AddAttribute( XML_NAMESPACE_NONE, "d", SVGActionWriter::GetPathString( aMissingGlyphPolyPoly, false ) );
 
@@ -258,7 +258,7 @@ void SVGFontExport::implEmbedFont( const vcl::Font& rFont )
 
 void SVGFontExport::implEmbedGlyph( OutputDevice& rOut, const OUString& rCellStr )
 {
-    PolyPolygon         aPolyPoly;
+    tools::PolyPolygon         aPolyPoly;
     const sal_Unicode   nSpace = ' ';
 
     if( rOut.GetTextOutline( aPolyPoly, rCellStr ) )
diff --git a/filter/source/svg/svgwriter.cxx b/filter/source/svg/svgwriter.cxx
index 5eb5bb4cbf46..97967fdd1b6d 100644
--- a/filter/source/svg/svgwriter.cxx
+++ b/filter/source/svg/svgwriter.cxx
@@ -1698,11 +1698,11 @@ Polygon& SVGActionWriter::ImplMap( const Polygon& rPoly, Polygon& rDstPoly ) con
     return( rDstPoly );
 }
 
-PolyPolygon& SVGActionWriter::ImplMap( const PolyPolygon& rPolyPoly, PolyPolygon& rDstPolyPoly ) const
+tools::PolyPolygon& SVGActionWriter::ImplMap( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rDstPolyPoly ) const
 {
     Polygon aPoly;
 
-    rDstPolyPoly = PolyPolygon();
+    rDstPolyPoly = tools::PolyPolygon();
 
     for( sal_uInt16 i = 0, nCount = rPolyPoly.Count(); i < nCount; ++i )
     {
@@ -1712,7 +1712,7 @@ PolyPolygon& SVGActionWriter::ImplMap( const PolyPolygon& rPolyPoly, PolyPolygon
     return( rDstPolyPoly );
 }
 
-OUString SVGActionWriter::GetPathString( const PolyPolygon& rPolyPoly, bool bLine )
+OUString SVGActionWriter::GetPathString( const tools::PolyPolygon& rPolyPoly, bool bLine )
 {
     OUString         aPathData;
     const OUString   aBlank( " " );
@@ -1919,10 +1919,10 @@ void SVGActionWriter::ImplAddLineAttr( const LineInfo &rAttrs,
 
 }
 
-void SVGActionWriter::ImplWritePolyPolygon( const PolyPolygon& rPolyPoly, bool bLineOnly,
+void SVGActionWriter::ImplWritePolyPolygon( const tools::PolyPolygon& rPolyPoly, bool bLineOnly,
                                             bool bApplyMapping )
 {
-    PolyPolygon aPolyPoly;
+    tools::PolyPolygon aPolyPoly;
 
     if( bApplyMapping )
         ImplMap( rPolyPoly, aPolyPoly );
@@ -1940,7 +1940,7 @@ void SVGActionWriter::ImplWritePolyPolygon( const PolyPolygon& rPolyPoly, bool b
 
 void SVGActionWriter::ImplWriteShape( const SVGShapeDescriptor& rShape, bool bApplyMapping )
 {
-    PolyPolygon aPolyPoly;
+    tools::PolyPolygon aPolyPoly;
 
     if( bApplyMapping )
         ImplMap( rShape.maShapePolyPoly, aPolyPoly );
@@ -2029,7 +2029,7 @@ void SVGActionWriter::ImplWriteShape( const SVGShapeDescriptor& rShape, bool bAp
     ImplWritePolyPolygon( aPolyPoly, bLineOnly, false );
 }
 
-void SVGActionWriter::ImplWritePattern( const PolyPolygon& rPolyPoly,
+void SVGActionWriter::ImplWritePattern( const tools::PolyPolygon& rPolyPoly,
                                         const Hatch* pHatch,
                                         const Gradient* pGradient,
                                         sal_uInt32 nWriteFlags )
@@ -2086,7 +2086,7 @@ void SVGActionWriter::ImplWritePattern( const PolyPolygon& rPolyPoly,
     }
 }
 
-void SVGActionWriter::ImplWriteGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient,
+void SVGActionWriter::ImplWriteGradientEx( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient,
                                            sal_uInt32 nWriteFlags)
 {
     if ( rGradient.GetStyle() == GradientStyle_LINEAR ||
@@ -2100,7 +2100,7 @@ void SVGActionWriter::ImplWriteGradientEx( const PolyPolygon& rPolyPoly, const G
     }
 }
 
-void SVGActionWriter::ImplWriteGradientLinear( const PolyPolygon& rPolyPoly,
+void SVGActionWriter::ImplWriteGradientLinear( const tools::PolyPolygon& rPolyPoly,
                                                const Gradient& rGradient )
 {
     if( rPolyPoly.Count() )
@@ -2282,7 +2282,7 @@ void SVGActionWriter::ImplWriteMask( GDIMetaFile& rMtf,
         {
             SvXMLElementExport aElemMask( mrExport, XML_NAMESPACE_NONE, aXMLElemMask, true, true );
 
-            const PolyPolygon aPolyPolygon( PolyPolygon( Rectangle( rDestPt, rDestSize ) ) );
+            const tools::PolyPolygon aPolyPolygon( tools::PolyPolygon( Rectangle( rDestPt, rDestSize ) ) );
             Gradient aGradient( rGradient );
 
             // swap gradient stops to adopt SVG mask
@@ -2858,7 +2858,7 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                 if( nWriteFlags & SVGWRITER_WRITE_FILL )
                 {
                     const MetaPolyPolygonAction*    pA = (const MetaPolyPolygonAction*) pAction;
-                    const PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
+                    const tools::PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
 
                     if( rPolyPoly.Count() )
                     {
@@ -2875,7 +2875,7 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                 {
                     const MetaGradientAction*   pA = (const MetaGradientAction*) pAction;
                     const Polygon               aRectPoly( pA->GetRect() );
-                    const PolyPolygon           aRectPolyPoly( aRectPoly );
+                    const tools::PolyPolygon           aRectPolyPoly( aRectPoly );
 
                     ImplWriteGradientEx( aRectPolyPoly, pA->GetGradient(), nWriteFlags );
                 }
@@ -2907,7 +2907,7 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                 if( nWriteFlags & SVGWRITER_WRITE_FILL )
                 {
                     const MetaTransparentAction*    pA = (const MetaTransparentAction*) pAction;
-                    const PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
+                    const tools::PolyPolygon&              rPolyPoly = pA->GetPolyPolygon();
 
                     if( rPolyPoly.Count() )
                     {
@@ -3010,7 +3010,7 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
 
                     if( bSkip )
                     {
-                        PolyPolygon aShapePolyPoly;
+                        tools::PolyPolygon aShapePolyPoly;
 
                         aFill.getPath( aShapePolyPoly );
 
@@ -3076,7 +3076,7 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                 {
                     SvMemoryStream      aMemStm( (void*) pA->GetData(), pA->GetDataSize(), STREAM_READ );
                     SvtGraphicStroke    aStroke;
-                    PolyPolygon         aStartArrow, aEndArrow;
+                    tools::PolyPolygon         aStartArrow, aEndArrow;
 
                     ReadSvtGraphicStroke( aMemStm, aStroke );
                     aStroke.getStartArrow( aStartArrow );
diff --git a/filter/source/svg/svgwriter.hxx b/filter/source/svg/svgwriter.hxx
index 6e186689b5da..459978caf6d1 100644
--- a/filter/source/svg/svgwriter.hxx
+++ b/filter/source/svg/svgwriter.hxx
@@ -127,7 +127,7 @@ public:
 
 struct SVGShapeDescriptor
 {
-    PolyPolygon                 maShapePolyPoly;
+    tools::PolyPolygon                 maShapePolyPoly;
     Color                       maShapeFillColor;
     Color                       maShapeLineColor;
     sal_Int32                   mnStrokeWidth;
@@ -334,7 +334,7 @@ private:
     Size&                   ImplMap( const Size& rSz, Size& rDstSz ) const;
     Rectangle&              ImplMap( const Rectangle& rRect, Rectangle& rDstRect ) const;
     Polygon&                ImplMap( const Polygon& rPoly, Polygon& rDstPoly ) const;
-    PolyPolygon&            ImplMap( const PolyPolygon& rPolyPoly, PolyPolygon& rDstPolyPoly ) const;
+    tools::PolyPolygon&            ImplMap( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rDstPolyPoly ) const;
 
     void                    ImplWriteLine( const Point& rPt1, const Point& rPt2, const Color* pLineColor = NULL,
                                            bool bApplyMapping = true );
@@ -342,14 +342,14 @@ private:
                                            bool bApplyMapping = true );
     void                    ImplWriteEllipse( const Point& rCenter, long nRadX, long nRadY,
                                               bool bApplyMapping = true );
-    void                    ImplWritePattern( const PolyPolygon& rPolyPoly, const Hatch* pHatch, const Gradient* pGradient, sal_uInt32 nWriteFlags );
+    void                    ImplWritePattern( const tools::PolyPolygon& rPolyPoly, const Hatch* pHatch, const Gradient* pGradient, sal_uInt32 nWriteFlags );
     void                    ImplAddLineAttr( const LineInfo &rAttrs,
                                              bool bApplyMapping = true );
-    void                    ImplWritePolyPolygon( const PolyPolygon& rPolyPoly, bool bLineOnly,
+    void                    ImplWritePolyPolygon( const tools::PolyPolygon& rPolyPoly, bool bLineOnly,
                                                   bool bApplyMapping = true );
     void                    ImplWriteShape( const SVGShapeDescriptor& rShape, bool bApplyMapping = true );
-    void                    ImplWriteGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient, sal_uInt32 nWriteFlags);
-    void                    ImplWriteGradientLinear( const PolyPolygon& rPolyPoly, const Gradient& rGradient );
+    void                    ImplWriteGradientEx( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient, sal_uInt32 nWriteFlags);
+    void                    ImplWriteGradientLinear( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
     void                    ImplWriteGradientStop( const Color& rColor, double fOffset );
     Color                   ImplGetColorWithIntensity( const Color& rColor, sal_uInt16 nIntensity );
     Color                   ImplGetGradientColor( const Color& rStartColor, const Color& rEndColor, double fOffset );
@@ -372,7 +372,7 @@ private:
 
 public:
 
-    static OUString  GetPathString( const PolyPolygon& rPolyPoly, bool bLine );
+    static OUString  GetPathString( const tools::PolyPolygon& rPolyPoly, bool bLine );
     static sal_uLong        GetChecksum( const MetaAction* pAction );
 
 public: