Get rid of :: prefix for basegfx in include/vcl and vcl

We already used it without the :: prefix, in many cases in the same
files even. It is nice to have some consistency.

I was not bored enough to do it everywhere.

Change-Id: Ic8ac5bd9b4b2c02c41e5ea937a3d9477824f21cf

37 files changed, 124 insertions, 124 deletions

diff --git a/include/vcl/canvastools.hxx b/include/vcl/canvastools.hxx
index f3af8bf340e3..6c5f6575b63e 100644
--- a/include/vcl/canvastools.hxx
+++ b/include/vcl/canvastools.hxx
@@ -161,17 +161,17 @@ namespace vcl
         Rectangle                          VCL_DLLPUBLIC rectangleFromIntegerRectangle2D( const css::geometry::IntegerRectangle2D& );
 
         // basegfx::B2D
-        Size                        VCL_DLLPUBLIC sizeFromB2DSize( const ::basegfx::B2DVector& );
-        Point                       VCL_DLLPUBLIC pointFromB2DPoint( const ::basegfx::B2DPoint& );
-        Rectangle                   VCL_DLLPUBLIC rectangleFromB2DRectangle( const ::basegfx::B2DRange& );
+        Size                        VCL_DLLPUBLIC sizeFromB2DSize( const basegfx::B2DVector& );
+        Point                       VCL_DLLPUBLIC pointFromB2DPoint( const basegfx::B2DPoint& );
+        Rectangle                   VCL_DLLPUBLIC rectangleFromB2DRectangle( const basegfx::B2DRange& );
 
         basegfx::B2DVector          VCL_DLLPUBLIC b2DSizeFromSize( const Size& );
         basegfx::B2DPoint           VCL_DLLPUBLIC b2DPointFromPoint( const Point& );
         basegfx::B2DRange           VCL_DLLPUBLIC b2DRectangleFromRectangle( const Rectangle& );
 
         // basegfx::B2I
-        Point                       VCL_DLLPUBLIC pointFromB2IPoint( const ::basegfx::B2IPoint& );
-        Rectangle                   VCL_DLLPUBLIC rectangleFromB2IRectangle( const ::basegfx::B2IRange& );
+        Point                       VCL_DLLPUBLIC pointFromB2IPoint( const basegfx::B2IPoint& );
+        Rectangle                   VCL_DLLPUBLIC rectangleFromB2IRectangle( const basegfx::B2IRange& );
     }
 }
 
diff --git a/include/vcl/devicecoordinate.hxx b/include/vcl/devicecoordinate.hxx
index 58ff3d2425dd..b098abbafb27 100644
--- a/include/vcl/devicecoordinate.hxx
+++ b/include/vcl/devicecoordinate.hxx
@@ -15,13 +15,13 @@
 #if VCL_FLOAT_DEVICE_PIXEL
 #include <basegfx/point/b2dpoint.hxx>
 typedef double DeviceCoordinate;
-typedef ::basegfx::B2DPoint DevicePoint;
+typedef basegfx::B2DPoint DevicePoint;
 
 #else /* !VCL_FLOAT_DEVICE_PIXEL */
 
 #include <basegfx/point/b2ipoint.hxx>
 typedef long DeviceCoordinate;
-typedef ::basegfx::B2IPoint DevicePoint;
+typedef basegfx::B2IPoint DevicePoint;
 
 #endif /* ! Carpet Cushion */
 
diff --git a/include/vcl/outdev.hxx b/include/vcl/outdev.hxx
index a146c86dc635..6c405788b85d 100644
--- a/include/vcl/outdev.hxx
+++ b/include/vcl/outdev.hxx
@@ -484,7 +484,7 @@ public:
     /// Create Surface for given bitmap data
     cairo::SurfaceSharedPtr     CreateBitmapSurface(const BitmapSystemData& rData, const Size& rSize) const;
     /// Return native handle for underlying surface
-    css::uno::Any               GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const ::basegfx::B2ISize& rSize) const;
+    css::uno::Any               GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const;
     css::uno::Any               GetSystemGfxDataAny() const;
 
     void                        SetRefPoint();
@@ -1123,7 +1123,7 @@ public:
                                                  sal_Int32 nLen = -1, bool bOptimize = true,
                                                  sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
 
-    bool                        GetTextOutlines( ::basegfx::B2DPolyPolygonVector &rVector,
+    bool                        GetTextOutlines( basegfx::B2DPolyPolygonVector &rVector,
                                                  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 = nullptr ) const;
diff --git a/vcl/generic/glyphs/gcach_ftyp.cxx b/vcl/generic/glyphs/gcach_ftyp.cxx
index ec5da8971769..5df5e2f5325c 100644
--- a/vcl/generic/glyphs/gcach_ftyp.cxx
+++ b/vcl/generic/glyphs/gcach_ftyp.cxx
@@ -1221,7 +1221,7 @@ static int FT_cubic_to( const FT_Vector* p1, const FT_Vector* p2, const FT_Vecto
 } // extern "C"
 
 bool ServerFont::GetGlyphOutline( sal_GlyphId aGlyphId,
-    ::basegfx::B2DPolyPolygon& rB2DPolyPoly ) const
+    basegfx::B2DPolyPolygon& rB2DPolyPoly ) const
 {
     if( maSizeFT )
         FT_Activate_Size( maSizeFT );
diff --git a/vcl/generic/print/genpspgraphics.cxx b/vcl/generic/print/genpspgraphics.cxx
index f1f92020e7d0..149f687308d3 100644
--- a/vcl/generic/print/genpspgraphics.cxx
+++ b/vcl/generic/print/genpspgraphics.cxx
@@ -431,7 +431,7 @@ void GenPspGraphics::drawPolyPolygon( sal_uInt32           nPoly,
     m_pPrinterGfx->DrawPolyPolygon (nPoly, pPoints, reinterpret_cast<const Point**>(pPtAry));
 }
 
-bool GenPspGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double /*fTransparency*/ )
+bool GenPspGraphics::drawPolyPolygon( const basegfx::B2DPolyPolygon&, double /*fTransparency*/ )
 {
         // TODO: implement and advertise OutDevSupport_B2DDraw support
         return false;
@@ -958,7 +958,7 @@ bool GenPspGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
 }
 
 bool GenPspGraphics::GetGlyphOutline( sal_GlyphId aGlyphId,
-    ::basegfx::B2DPolyPolygon& rB2DPolyPoly )
+    basegfx::B2DPolyPolygon& rB2DPolyPoly )
 {
     const int nLevel = aGlyphId >> GF_FONTSHIFT;
     if( nLevel >= MAX_FALLBACK )
diff --git a/vcl/headless/svpgdi.cxx b/vcl/headless/svpgdi.cxx
index 94871be0cc0a..a7e401b769b1 100644
--- a/vcl/headless/svpgdi.cxx
+++ b/vcl/headless/svpgdi.cxx
@@ -856,9 +856,9 @@ static void AddPolygonToPath(cairo_t* cr, const basegfx::B2DPolygon& rPolygon, b
 }
 
 bool SvpSalGraphics::drawPolyLine(
-    const ::basegfx::B2DPolygon& rPolyLine,
+    const basegfx::B2DPolygon& rPolyLine,
     double fTransparency,
-    const ::basegfx::B2DVector& rLineWidths,
+    const basegfx::B2DVector& rLineWidths,
     basegfx::B2DLineJoin eLineJoin,
     css::drawing::LineCap eLineCap)
 {
diff --git a/vcl/inc/cairotextrender.hxx b/vcl/inc/cairotextrender.hxx
index 60b1b8f7468e..6b519274e808 100644
--- a/vcl/inc/cairotextrender.hxx
+++ b/vcl/inc/cairotextrender.hxx
@@ -124,7 +124,7 @@ public:
                                     Ucs2UIntMap& rUnicodeEnc ) override;
 
     virtual bool                GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& ) override;
-    virtual bool                GetGlyphOutline( sal_GlyphId nIndex, ::basegfx::B2DPolyPolygon& ) override;
+    virtual bool                GetGlyphOutline( sal_GlyphId nIndex, basegfx::B2DPolyPolygon& ) override;
     virtual SalLayout*          GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) override;
     virtual void                DrawServerFontLayout( const ServerFontLayout& ) override;
 #if ENABLE_CAIRO_CANVAS
diff --git a/vcl/inc/generic/glyphcache.hxx b/vcl/inc/generic/glyphcache.hxx
index 722e6b1b9d33..cff39beff401 100644
--- a/vcl/inc/generic/glyphcache.hxx
+++ b/vcl/inc/generic/glyphcache.hxx
@@ -182,7 +182,7 @@ public:
     sal_GlyphId             GetGlyphIndex( sal_UCS4 ) const;
     sal_GlyphId             GetRawGlyphIndex( sal_UCS4, sal_UCS4 = 0 ) const;
     sal_GlyphId             FixupGlyphIndex( sal_GlyphId aGlyphId, sal_UCS4 ) const;
-    bool                    GetGlyphOutline( sal_GlyphId aGlyphId, ::basegfx::B2DPolyPolygon& ) const;
+    bool                    GetGlyphOutline( sal_GlyphId aGlyphId, basegfx::B2DPolyPolygon& ) const;
     bool                    GetAntialiasAdvice() const;
 
 private:
diff --git a/vcl/inc/headless/svpgdi.hxx b/vcl/inc/headless/svpgdi.hxx
index ab675a9ad836..d8cdaf16d6c1 100644
--- a/vcl/inc/headless/svpgdi.hxx
+++ b/vcl/inc/headless/svpgdi.hxx
@@ -148,7 +148,7 @@ public:
                                             Int32Vector& rWidths,
                                             Ucs2UIntMap& rUnicodeEnc ) override;
     virtual bool            GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& ) override;
-    virtual bool            GetGlyphOutline( sal_GlyphId nIndex, ::basegfx::B2DPolyPolygon& ) override;
+    virtual bool            GetGlyphOutline( sal_GlyphId nIndex, basegfx::B2DPolyPolygon& ) override;
     virtual SalLayout*      GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) override;
     virtual void            DrawServerFontLayout( const ServerFontLayout& ) override;
     virtual bool            supportsOperation( OutDevSupportType ) const override;
@@ -156,10 +156,10 @@ public:
     virtual void            drawPixel( long nX, long nY, SalColor nSalColor ) override;
     virtual void            drawLine( long nX1, long nY1, long nX2, long nY2 ) override;
     virtual void            drawRect( long nX, long nY, long nWidth, long nHeight ) override;
-    virtual bool            drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
-    virtual bool            drawPolyLine( const ::basegfx::B2DPolygon&,
+    virtual bool            drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool            drawPolyLine( const basegfx::B2DPolygon&,
                                           double fTransparency,
-                                          const ::basegfx::B2DVector& rLineWidths,
+                                          const basegfx::B2DVector& rLineWidths,
                                           basegfx::B2DLineJoin,
                                           css::drawing::LineCap) override;
     virtual void            drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
diff --git a/vcl/inc/openglgdiimpl.hxx b/vcl/inc/openglgdiimpl.hxx
index fc9507108a00..813a7be74dc1 100644
--- a/vcl/inc/openglgdiimpl.hxx
+++ b/vcl/inc/openglgdiimpl.hxx
@@ -235,12 +235,12 @@ public:
     virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 
     virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
-    virtual bool drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
 
     virtual bool drawPolyLine(
-                const ::basegfx::B2DPolygon&,
+                const basegfx::B2DPolygon&,
                 double fTransparency,
-                const ::basegfx::B2DVector& rLineWidths,
+                const basegfx::B2DVector& rLineWidths,
                 basegfx::B2DLineJoin,
                 css::drawing::LineCap) override;
 
diff --git a/vcl/inc/quartz/salgdi.h b/vcl/inc/quartz/salgdi.h
index 34476dfe1e4d..51fe8492a820 100644
--- a/vcl/inc/quartz/salgdi.h
+++ b/vcl/inc/quartz/salgdi.h
@@ -238,14 +238,14 @@ public:
     virtual void            drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
     virtual void            drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
     virtual void            drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
-    virtual bool            drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool            drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
     virtual bool            drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
     virtual bool            drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
     virtual bool            drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints, const SalPoint* const* pPtAry, const sal_uInt8* const* pFlgAry ) override;
     virtual bool            drawPolyLine(
-                                const ::basegfx::B2DPolygon&,
+                                const basegfx::B2DPolygon&,
                                 double fTransparency,
-                                const ::basegfx::B2DVector& rLineWidths,
+                                const basegfx::B2DVector& rLineWidths,
                                 basegfx::B2DLineJoin,
                                 css::drawing::LineCap eLineCap) override;
     virtual bool            drawGradient( const tools::PolyPolygon&, const Gradient& ) override { return false; };
diff --git a/vcl/inc/salgdi.hxx b/vcl/inc/salgdi.hxx
index 98c3b8fa5c74..0397fcdabff5 100644
--- a/vcl/inc/salgdi.hxx
+++ b/vcl/inc/salgdi.hxx
@@ -452,7 +452,7 @@ public:
     virtual cairo::SurfaceSharedPtr CreateSurface(const OutputDevice& rRefDevice, int x, int y, int width, int height) const = 0;
     /// Create Surface for given bitmap data
     virtual cairo::SurfaceSharedPtr CreateBitmapSurface(const OutputDevice& rRefDevice, const BitmapSystemData& rData, const Size& rSize) const = 0;
-    virtual css::uno::Any       GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const ::basegfx::B2ISize& rSize) const = 0;
+    virtual css::uno::Any       GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const = 0;
 
     virtual SystemFontData      GetSysFontData( int nFallbacklevel ) const = 0;
 
@@ -474,12 +474,12 @@ protected:
     virtual void                drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) = 0;
 
     virtual void                drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) = 0;
-    virtual bool                drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) = 0;
+    virtual bool                drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) = 0;
 
     virtual bool                drawPolyLine(
-                                    const ::basegfx::B2DPolygon&,
+                                    const basegfx::B2DPolygon&,
                                     double fTransparency,
-                                    const ::basegfx::B2DVector& rLineWidths,
+                                    const basegfx::B2DVector& rLineWidths,
                                     basegfx::B2DLineJoin,
                                     css::drawing::LineCap) = 0;
 
diff --git a/vcl/inc/salgdiimpl.hxx b/vcl/inc/salgdiimpl.hxx
index 3324012dac29..dd391b1a2441 100644
--- a/vcl/inc/salgdiimpl.hxx
+++ b/vcl/inc/salgdiimpl.hxx
@@ -98,12 +98,12 @@ public:
     virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) = 0;
 
     virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) = 0;
-    virtual bool drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) = 0;
+    virtual bool drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) = 0;
 
     virtual bool drawPolyLine(
-                const ::basegfx::B2DPolygon&,
+                const basegfx::B2DPolygon&,
                 double fTransparency,
-                const ::basegfx::B2DVector& rLineWidths,
+                const basegfx::B2DVector& rLineWidths,
                 basegfx::B2DLineJoin,
                 css::drawing::LineCap) = 0;
 
diff --git a/vcl/inc/sallayout.hxx b/vcl/inc/sallayout.hxx
index 47d75da40904..cf7d53ff5543 100644
--- a/vcl/inc/sallayout.hxx
+++ b/vcl/inc/sallayout.hxx
@@ -186,7 +186,7 @@ public:
     virtual int     GetNextGlyphs( int nLen, sal_GlyphId* pGlyphIdAry, Point& rPos, int&,
                                    DeviceCoordinate* pGlyphAdvAry = nullptr, int* pCharPosAry = nullptr,
                                    const PhysicalFontFace** pFallbackFonts = nullptr ) const = 0;
-    virtual bool    GetOutline( SalGraphics&, ::basegfx::B2DPolyPolygonVector& ) const;
+    virtual bool    GetOutline( SalGraphics&, basegfx::B2DPolyPolygonVector& ) const;
     virtual bool    GetBoundRect( SalGraphics&, Rectangle& ) const;
 
     static bool     IsSpacingGlyph( sal_GlyphId );
@@ -242,7 +242,7 @@ public:
     virtual int     GetNextGlyphs( int nLen, sal_GlyphId* pGlyphIdxAry, Point& rPos,
                                    int&, DeviceCoordinate* pGlyphAdvAry, int* pCharPosAry,
                                    const PhysicalFontFace** pFallbackFonts ) const override;
-    virtual bool    GetOutline( SalGraphics&, ::basegfx::B2DPolyPolygonVector& ) const override;
+    virtual bool    GetOutline( SalGraphics&, basegfx::B2DPolyPolygonVector& ) const override;
 
     // used only by OutputDevice::ImplLayout, TODO: make friend
     explicit        MultiSalLayout( SalLayout& rBaseLayout,
diff --git a/vcl/inc/textrender.hxx b/vcl/inc/textrender.hxx
index c43ddc6ebd96..f726255a2b24 100644
--- a/vcl/inc/textrender.hxx
+++ b/vcl/inc/textrender.hxx
@@ -79,7 +79,7 @@ public:
                                         Ucs2UIntMap& rUnicodeEnc ) = 0;
 
     virtual bool                    GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& ) = 0;
-    virtual bool                    GetGlyphOutline( sal_GlyphId nIndex, ::basegfx::B2DPolyPolygon& ) = 0;
+    virtual bool                    GetGlyphOutline( sal_GlyphId nIndex, basegfx::B2DPolyPolygon& ) = 0;
     virtual SalLayout*              GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) = 0;
     virtual void                    DrawServerFontLayout( const ServerFontLayout& ) = 0;
 #if ENABLE_CAIRO_CANVAS
diff --git a/vcl/inc/unx/salgdi.h b/vcl/inc/unx/salgdi.h
index 04da6ed1c3c3..9f744c8d1408 100644
--- a/vcl/inc/unx/salgdi.h
+++ b/vcl/inc/unx/salgdi.h
@@ -149,7 +149,7 @@ public:
                                         Ucs2UIntMap& rUnicodeEnc ) override;
 
     virtual bool                    GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& ) override;
-    virtual bool                    GetGlyphOutline( sal_GlyphId nIndex, ::basegfx::B2DPolyPolygon& ) override;
+    virtual bool                    GetGlyphOutline( sal_GlyphId nIndex, basegfx::B2DPolyPolygon& ) override;
     virtual SalLayout*              GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) override;
     virtual void                    DrawServerFontLayout( const ServerFontLayout& ) override;
 
@@ -166,12 +166,12 @@ public:
                                         const sal_uInt32* pPoints,
                                         PCONSTSALPOINT* pPtAry ) override;
 
-    virtual bool                    drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool                    drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
 
     virtual bool                    drawPolyLine(
-                                        const ::basegfx::B2DPolygon&,
+                                        const basegfx::B2DPolygon&,
                                         double fTransparency,
-                                        const ::basegfx::B2DVector& rLineWidth,
+                                        const basegfx::B2DVector& rLineWidth,
                                         basegfx::B2DLineJoin,
                                         css::drawing::LineCap ) override;
 
diff --git a/vcl/inc/win/salgdi.h b/vcl/inc/win/salgdi.h
index 4ff01fa6ed43..8c233a8c665f 100644
--- a/vcl/inc/win/salgdi.h
+++ b/vcl/inc/win/salgdi.h
@@ -265,11 +265,11 @@ protected:
     virtual void        drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
     virtual void        drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
     virtual void        drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
-    virtual bool        drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool        drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
     virtual bool        drawPolyLine(
-        const ::basegfx::B2DPolygon&,
+        const basegfx::B2DPolygon&,
         double fTransparency,
-        const ::basegfx::B2DVector& rLineWidth,
+        const basegfx::B2DVector& rLineWidth,
         basegfx::B2DLineJoin,
         css::drawing::LineCap) override;
     virtual bool        drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry ) override;
@@ -425,7 +425,7 @@ public:
             int             GetMinKashidaWidth();
 
     virtual bool            GetGlyphBoundRect( sal_GlyphId, Rectangle& ) override;
-    virtual bool            GetGlyphOutline( sal_GlyphId, ::basegfx::B2DPolyPolygon& ) override;
+    virtual bool            GetGlyphOutline( sal_GlyphId, basegfx::B2DPolyPolygon& ) override;
 
     virtual SalLayout*      GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) override;
     virtual void            DrawServerFontLayout( const ServerFontLayout& ) override;
diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx
index 5054a6faa1f9..fe5c475258a4 100644
--- a/vcl/opengl/gdiimpl.cxx
+++ b/vcl/opengl/gdiimpl.cxx
@@ -950,27 +950,27 @@ void OpenGLSalGraphicsImpl::DrawRect( const Rectangle& rRect )
 
 void OpenGLSalGraphicsImpl::DrawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
 {
-    ::basegfx::B2DPolygon aPolygon;
+    basegfx::B2DPolygon aPolygon;
 
     for( sal_uInt32 i = 0; i < nPoints; i++ )
-        aPolygon.append( ::basegfx::B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
+        aPolygon.append( basegfx::B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
     aPolygon.setClosed( true );
 
-    if( ::basegfx::tools::isConvex( aPolygon ) )
+    if( basegfx::tools::isConvex( aPolygon ) )
     {
         if( nPoints > 2L )
             DrawConvexPolygon( nPoints, pPtAry );
     }
     else
     {
-        const ::basegfx::B2DPolyPolygon aPolyPolygon( aPolygon );
+        const basegfx::B2DPolyPolygon aPolyPolygon( aPolygon );
         DrawPolyPolygon( aPolyPolygon );
     }
 }
 
 void OpenGLSalGraphicsImpl::DrawPolyPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon, bool blockAA )
 {
-    const ::basegfx::B2DPolyPolygon& aSimplePolyPolygon = ::basegfx::tools::solveCrossovers( rPolyPolygon );
+    const basegfx::B2DPolyPolygon& aSimplePolyPolygon = ::basegfx::tools::solveCrossovers( rPolyPolygon );
     basegfx::B2DTrapezoidVector aB2DTrapVector;
     basegfx::tools::trapezoidSubdivide( aB2DTrapVector, aSimplePolyPolygon );
     // draw tesselation result
@@ -1483,7 +1483,7 @@ void OpenGLSalGraphicsImpl::drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32*
     PostDraw();
 }
 
-bool OpenGLSalGraphicsImpl::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency )
+bool OpenGLSalGraphicsImpl::drawPolyPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency )
 {
     VCL_GL_INFO( "::drawPolyPolygon trans " << fTransparency );
     if( rPolyPolygon.count() <= 0 )
@@ -1508,9 +1508,9 @@ bool OpenGLSalGraphicsImpl::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rP
 }
 
 bool OpenGLSalGraphicsImpl::drawPolyLine(
-            const ::basegfx::B2DPolygon& rPolygon,
+            const basegfx::B2DPolygon& rPolygon,
             double fTransparency,
-            const ::basegfx::B2DVector& rLineWidth,
+            const basegfx::B2DVector& rLineWidth,
             basegfx::B2DLineJoin eLineJoin,
             css::drawing::LineCap eLineCap)
 {
@@ -1568,7 +1568,7 @@ bool OpenGLSalGraphicsImpl::drawPolyLine(
     {
         for( sal_uInt32 i = 0; i < aAreaPolyPoly.count(); i++ )
         {
-            const ::basegfx::B2DPolyPolygon aOnePoly( aAreaPolyPoly.getB2DPolygon( i ) );
+            const basegfx::B2DPolyPolygon aOnePoly( aAreaPolyPoly.getB2DPolygon( i ) );
             DrawPolyPolygon( aOnePoly );
         }
     }
diff --git a/vcl/quartz/salgdicommon.cxx b/vcl/quartz/salgdicommon.cxx
index 1c74efa6802a..8a94e19968d7 100644
--- a/vcl/quartz/salgdicommon.cxx
+++ b/vcl/quartz/salgdicommon.cxx
@@ -78,7 +78,7 @@ typedef std::vector<unsigned char> ByteVector;
 static const basegfx::B2DPoint aHalfPointOfs ( 0.5, 0.5 );
 
 static void AddPolygonToPath( CGMutablePathRef xPath,
-                              const ::basegfx::B2DPolygon& rPolygon,
+                              const basegfx::B2DPolygon& rPolygon,
                               bool bClosePath, bool bPixelSnap, bool bLineDraw )
 {
     // short circuit if there is nothing to do
@@ -106,7 +106,7 @@ static void AddPolygonToPath( CGMutablePathRef xPath,
             }
         }
 
-        ::basegfx::B2DPoint aPoint = rPolygon.getB2DPoint( nClosedIdx );
+        basegfx::B2DPoint aPoint = rPolygon.getB2DPoint( nClosedIdx );
 
         if( bPixelSnap)
         {
@@ -163,7 +163,7 @@ static void AddPolygonToPath( CGMutablePathRef xPath,
 }
 
 static void AddPolyPolygonToPath( CGMutablePathRef xPath,
-                                  const ::basegfx::B2DPolyPolygon& rPolyPoly,
+                                  const basegfx::B2DPolyPolygon& rPolyPoly,
                                   bool bPixelSnap, bool bLineDraw )
 {
     // short circuit if there is nothing to do
@@ -174,7 +174,7 @@ static void AddPolyPolygonToPath( CGMutablePathRef xPath,
     }
     for( int nPolyIdx = 0; nPolyIdx < nPolyCount; ++nPolyIdx )
     {
-        const ::basegfx::B2DPolygon rPolygon = rPolyPoly.getB2DPolygon( nPolyIdx );
+        const basegfx::B2DPolygon rPolygon = rPolyPoly.getB2DPolygon( nPolyIdx );
         AddPolygonToPath( xPath, rPolygon, true, bPixelSnap, bLineDraw );
     }
 }
@@ -957,9 +957,9 @@ void AquaSalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
     ImplDrawPixel( nX, nY, aPixelColor );
 }
 
-bool AquaSalGraphics::drawPolyLine( const ::basegfx::B2DPolygon& rPolyLine,
+bool AquaSalGraphics::drawPolyLine( const basegfx::B2DPolygon& rPolyLine,
                                     double fTransparency,
-                                    const ::basegfx::B2DVector& rLineWidths,
+                                    const basegfx::B2DVector& rLineWidths,
                                     basegfx::B2DLineJoin eLineJoin,
                                     css::drawing::LineCap eLineCap)
 {
diff --git a/vcl/source/gdi/sallayout.cxx b/vcl/source/gdi/sallayout.cxx
index 50bef0594c0e..570980299da3 100644
--- a/vcl/source/gdi/sallayout.cxx
+++ b/vcl/source/gdi/sallayout.cxx
@@ -693,13 +693,13 @@ int SalLayout::CalcAsianKerning( sal_UCS4 c, bool bLeft, bool /*TODO:? bVertical
 }
 
 bool SalLayout::GetOutline( SalGraphics& rSalGraphics,
-    ::basegfx::B2DPolyPolygonVector& rVector ) const
+    basegfx::B2DPolyPolygonVector& rVector ) const
 {
     bool bAllOk = true;
     bool bOneOk = false;
 
     Point aPos;
-    ::basegfx::B2DPolyPolygon aGlyphOutline;
+    basegfx::B2DPolyPolygon aGlyphOutline;
     for( int nStart = 0;;)
     {
         sal_GlyphId nLGlyph;
@@ -2005,7 +2005,7 @@ int MultiSalLayout::GetNextGlyphs( int nLen, sal_GlyphId* pGlyphIdxAry, Point& r
 }
 
 bool MultiSalLayout::GetOutline( SalGraphics& rGraphics,
-                                 ::basegfx::B2DPolyPolygonVector& rPPV ) const
+                                 basegfx::B2DPolyPolygonVector& rPPV ) const
 {
     bool bRet = false;
 
diff --git a/vcl/source/helper/canvastools.cxx b/vcl/source/helper/canvastools.cxx
index 19f8a754458a..3b76ab42a617 100644
--- a/vcl/source/helper/canvastools.cxx
+++ b/vcl/source/helper/canvastools.cxx
@@ -337,19 +337,19 @@ namespace vcl
                          static_cast<long>(rSize.Height + .5) );
         }
 
-        ::Size sizeFromB2DSize( const ::basegfx::B2DVector& rVec )
+        ::Size sizeFromB2DSize( const basegfx::B2DVector& rVec )
         {
             return ::Size( FRound( rVec.getX() ),
                            FRound( rVec.getY() ) );
         }
 
-        ::Point pointFromB2DPoint( const ::basegfx::B2DPoint& rPoint )
+        ::Point pointFromB2DPoint( const basegfx::B2DPoint& rPoint )
         {
             return ::Point( FRound( rPoint.getX() ),
                             FRound( rPoint.getY() ) );
         }
 
-        ::Rectangle rectangleFromB2DRectangle( const ::basegfx::B2DRange& rRect )
+        ::Rectangle rectangleFromB2DRectangle( const basegfx::B2DRange& rRect )
         {
             return ::Rectangle( FRound( rRect.getMinX() ),
                                 FRound( rRect.getMinY() ),
@@ -357,13 +357,13 @@ namespace vcl
                                 FRound( rRect.getMaxY() ) );
         }
 
-        Point pointFromB2IPoint( const ::basegfx::B2IPoint& rPoint )
+        Point pointFromB2IPoint( const basegfx::B2IPoint& rPoint )
         {
             return ::Point( rPoint.getX(),
                             rPoint.getY() );
         }
 
-        Rectangle rectangleFromB2IRectangle( const ::basegfx::B2IRange& rRect )
+        Rectangle rectangleFromB2IRectangle( const basegfx::B2IRange& rRect )
         {
             return ::Rectangle( rRect.getMinX(),
                                 rRect.getMinY(),
@@ -371,21 +371,21 @@ namespace vcl
                                 rRect.getMaxY() );
         }
 
-        ::basegfx::B2DVector b2DSizeFromSize( const ::Size& rSize )
+        basegfx::B2DVector b2DSizeFromSize( const ::Size& rSize )
         {
-            return ::basegfx::B2DVector( rSize.Width(),
+            return basegfx::B2DVector( rSize.Width(),
                                          rSize.Height() );
         }
 
-        ::basegfx::B2DPoint b2DPointFromPoint( const ::Point& rPoint )
+        basegfx::B2DPoint b2DPointFromPoint( const ::Point& rPoint )
         {
-            return ::basegfx::B2DPoint( rPoint.X(),
+            return basegfx::B2DPoint( rPoint.X(),
                                         rPoint.Y() );
         }
 
-        ::basegfx::B2DRange b2DRectangleFromRectangle( const ::Rectangle& rRect )
+        basegfx::B2DRange b2DRectangleFromRectangle( const ::Rectangle& rRect )
         {
-            return ::basegfx::B2DRange( rRect.Left(),
+            return basegfx::B2DRange( rRect.Left(),
                                         rRect.Top(),
                                         rRect.Right(),
                                         rRect.Bottom() );
diff --git a/vcl/source/outdev/map.cxx b/vcl/source/outdev/map.cxx
index 1a0b2799ab66..e2a85a705352 100644
--- a/vcl/source/outdev/map.cxx
+++ b/vcl/source/outdev/map.cxx
@@ -1057,7 +1057,7 @@ tools::PolyPolygon OutputDevice::LogicToPixel( const tools::PolyPolygon& rLogicP
 basegfx::B2DPolyPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly ) const
 {
     basegfx::B2DPolyPolygon aTransformedPoly = rLogicPolyPoly;
-    const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation();
+    const basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation();
     aTransformedPoly.transform( rTransformationMatrix );
     return aTransformedPoly;
 }
@@ -1201,7 +1201,7 @@ basegfx::B2DPolyPolygon OutputDevice::LogicToPixel( const basegfx::B2DPolyPolygo
                                                     const MapMode& rMapMode ) const
 {
     basegfx::B2DPolyPolygon aTransformedPoly = rLogicPolyPoly;
-    const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation( rMapMode );
+    const basegfx::B2DHomMatrix& rTransformationMatrix = GetViewTransformation( rMapMode );
     aTransformedPoly.transform( rTransformationMatrix );
     return aTransformedPoly;
 }
@@ -1302,7 +1302,7 @@ tools::PolyPolygon OutputDevice::PixelToLogic( const tools::PolyPolygon& rDevice
 basegfx::B2DPolyPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolyPolygon& rPixelPolyPoly ) const
 {
     basegfx::B2DPolyPolygon aTransformedPoly = rPixelPolyPoly;
-    const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation();
+    const basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation();
     aTransformedPoly.transform( rTransformationMatrix );
     return aTransformedPoly;
 }
@@ -1450,7 +1450,7 @@ basegfx::B2DPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolygon& rPixe
                                                 const MapMode& rMapMode ) const
 {
     basegfx::B2DPolygon aTransformedPoly = rPixelPoly;
-    const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
+    const basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
     aTransformedPoly.transform( rTransformationMatrix );
     return aTransformedPoly;
 }
@@ -1459,7 +1459,7 @@ basegfx::B2DPolyPolygon OutputDevice::PixelToLogic( const basegfx::B2DPolyPolygo
                                                     const MapMode& rMapMode ) const
 {
     basegfx::B2DPolyPolygon aTransformedPoly = rPixelPolyPoly;
-    const ::basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
+    const basegfx::B2DHomMatrix& rTransformationMatrix = GetInverseViewTransformation( rMapMode );
     aTransformedPoly.transform( rTransformationMatrix );
     return aTransformedPoly;
 }
diff --git a/vcl/source/outdev/outdev.cxx b/vcl/source/outdev/outdev.cxx
index b343f502e0fe..5d7f98de73cf 100644
--- a/vcl/source/outdev/outdev.cxx
+++ b/vcl/source/outdev/outdev.cxx
@@ -366,7 +366,7 @@ cairo::SurfaceSharedPtr OutputDevice::CreateBitmapSurface(const BitmapSystemData
     return mpGraphics->CreateBitmapSurface(*this, rData, rSize);
 }
 
-css::uno::Any OutputDevice::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const ::basegfx::B2ISize& rSize) const
+css::uno::Any OutputDevice::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const
 {
     if (!mpGraphics)
     {
diff --git a/vcl/source/outdev/polygon.cxx b/vcl/source/outdev/polygon.cxx
index 563a4b2454da..4ba8caf293a3 100644
--- a/vcl/source/outdev/polygon.cxx
+++ b/vcl/source/outdev/polygon.cxx
@@ -68,7 +68,7 @@ void OutputDevice::DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly )
        ROP_OVERPAINT == GetRasterOp() &&
        (IsLineColor() || IsFillColor()))
     {
-        const ::basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
+        const basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
         basegfx::B2DPolyPolygon aB2DPolyPolygon(rPolyPoly.getB2DPolyPolygon());
         bool bSuccess(true);
 
@@ -83,7 +83,7 @@ void OutputDevice::DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly )
 
         if(bSuccess && IsLineColor())
         {
-            const ::basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
+            const basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
 
             if(mnAntialiasing & AntialiasingFlags::PixelSnapHairline)
             {
@@ -178,7 +178,7 @@ void OutputDevice::DrawPolygon( const tools::Polygon& rPoly )
        ROP_OVERPAINT == GetRasterOp() &&
        (IsLineColor() || IsFillColor()))
     {
-        const ::basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
+        const basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
         basegfx::B2DPolygon aB2DPolygon(rPoly.getB2DPolygon());
         bool bSuccess(true);
 
@@ -193,7 +193,7 @@ void OutputDevice::DrawPolygon( const tools::Polygon& rPoly )
 
         if(bSuccess && IsLineColor())
         {
-            const ::basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
+            const basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
 
             if(mnAntialiasing & AntialiasingFlags::PixelSnapHairline)
             {
@@ -293,7 +293,7 @@ void OutputDevice::ImplDrawPolyPolygonWithB2DPolyPolygon(const basegfx::B2DPolyP
 
         if(bSuccess && IsLineColor())
         {
-            const ::basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
+            const basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
 
             if(mnAntialiasing & AntialiasingFlags::PixelSnapHairline)
             {
diff --git a/vcl/source/outdev/polyline.cxx b/vcl/source/outdev/polyline.cxx
index 18f5d625a6b0..6bd72495870f 100644
--- a/vcl/source/outdev/polyline.cxx
+++ b/vcl/source/outdev/polyline.cxx
@@ -61,8 +61,8 @@ void OutputDevice::DrawPolyLine( const tools::Polygon& rPoly )
     if ( DrawPolyLineDirect( rPoly.getB2DPolygon() ) )
     {
         basegfx::B2DPolygon aB2DPolyLine(rPoly.getB2DPolygon());
-        const ::basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
-        const ::basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
+        const basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
+        const basegfx::B2DVector aB2DLineWidth( 1.0, 1.0 );
 
         // transform the polygon
         aB2DPolyLine.transform( aTransform );
@@ -311,7 +311,7 @@ bool OutputDevice::DrawPolyLineDirect( const basegfx::B2DPolygon& rB2DPolygon,
         // transform the line width if used
         if( fLineWidth != 0.0 )
         {
-            aB2DLineWidth = aTransform * ::basegfx::B2DVector( fLineWidth, fLineWidth );
+            aB2DLineWidth = aTransform * basegfx::B2DVector( fLineWidth, fLineWidth );
         }
 
         // transform the polygon
diff --git a/vcl/source/outdev/text.cxx b/vcl/source/outdev/text.cxx
index 8bb77789378f..37edc64ae6e0 100644
--- a/vcl/source/outdev/text.cxx
+++ b/vcl/source/outdev/text.cxx
@@ -2630,7 +2630,7 @@ bool OutputDevice::GetTextBoundRect( Rectangle& rRect,
     return false;
 }
 
-bool OutputDevice::GetTextOutlines( ::basegfx::B2DPolyPolygonVector& rVector,
+bool OutputDevice::GetTextOutlines( basegfx::B2DPolyPolygonVector& rVector,
                                         const OUString& rStr, sal_Int32 nBase,
                                         sal_Int32 nIndex, sal_Int32 nLen,
                                         bool bOptimize, sal_uLong nLayoutWidth, const long* pDXArray ) const
@@ -2691,7 +2691,7 @@ bool OutputDevice::GetTextOutlines( ::basegfx::B2DPolyPolygonVector& rVector,
         if( bRet )
         {
             // transform polygon to pixel units
-            ::basegfx::B2DHomMatrix aMatrix;
+            basegfx::B2DHomMatrix aMatrix;
 
             int nWidthFactor = pSalLayout->GetUnitsPerPixel();
             if( nXOffset | mnTextOffX | mnTextOffY )
@@ -2709,7 +2709,7 @@ bool OutputDevice::GetTextOutlines( ::basegfx::B2DPolyPolygonVector& rVector,
 
             if( !aMatrix.isIdentity() )
             {
-                ::basegfx::B2DPolyPolygonVector::iterator aIt = rVector.begin();
+                basegfx::B2DPolyPolygonVector::iterator aIt = rVector.begin();
                 for(; aIt != rVector.end(); ++aIt )
                     (*aIt).transform( aMatrix );
             }
@@ -2848,8 +2848,8 @@ bool OutputDevice::GetTextOutlines( ::basegfx::B2DPolyPolygonVector& rVector,
                 {
                     // convert  to B2DPolyPolygon
                     // TODO: get rid of intermediate tool's PolyPolygon
-                    ::basegfx::B2DPolyPolygon aB2DPolyPoly = aPolyPoly.getB2DPolyPolygon();
-                    ::basegfx::B2DHomMatrix aMatrix;
+                    basegfx::B2DPolyPolygon aB2DPolyPoly = aPolyPoly.getB2DPolyPolygon();
+                    basegfx::B2DHomMatrix aMatrix;
                     aMatrix.scale( fScaleX, fScaleY );
                     int nAngle = GetFont().GetOrientation();
                     if( nAngle )
@@ -2881,14 +2881,14 @@ bool OutputDevice::GetTextOutlines( PolyPolyVector& rResultVector,
     rResultVector.clear();
 
     // get the basegfx polypolygon vector
-    ::basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
+    basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
     if( !GetTextOutlines( aB2DPolyPolyVector, rStr, nBase, nIndex, nLen,
                          bOptimize, nTWidth, pDXArray ) )
         return false;
 
     // convert to a tool polypolygon vector
     rResultVector.reserve( aB2DPolyPolyVector.size() );
-    ::basegfx::B2DPolyPolygonVector::const_iterator aIt = aB2DPolyPolyVector.begin();
+    basegfx::B2DPolyPolygonVector::const_iterator aIt = aB2DPolyPolyVector.begin();
     for(; aIt != aB2DPolyPolyVector.end(); ++aIt )
         rResultVector.push_back(tools::PolyPolygon(*aIt)); // #i76339#
 
@@ -2907,13 +2907,13 @@ bool OutputDevice::GetTextOutline( tools::PolyPolygon& rPolyPoly, const OUString
     rPolyPoly.Clear();
 
     // get the basegfx polypolygon vector
-    ::basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
+    basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
     if( !GetTextOutlines( aB2DPolyPolyVector, rStr, nBase, nIndex, nLen,
                          bOptimize, nTWidth, pDXArray ) )
         return false;
 
     // convert and merge into a tool polypolygon
-    ::basegfx::B2DPolyPolygonVector::const_iterator aIt = aB2DPolyPolyVector.begin();
+    basegfx::B2DPolyPolygonVector::const_iterator aIt = aB2DPolyPolyVector.begin();
     for(; aIt != aB2DPolyPolyVector.end(); ++aIt )
         for( unsigned int i = 0; i < aIt->count(); ++i )
             rPolyPoly.Insert(tools::Polygon((*aIt).getB2DPolygon( i ))); // #i76339#
diff --git a/vcl/source/outdev/transparent.cxx b/vcl/source/outdev/transparent.cxx
index 4c8a4050f862..3839a3380d4b 100644
--- a/vcl/source/outdev/transparent.cxx
+++ b/vcl/source/outdev/transparent.cxx
@@ -238,7 +238,7 @@ void OutputDevice::DrawTransparent( const basegfx::B2DPolyPolygon& rB2DPolyPoly,
        (ROP_OVERPAINT == GetRasterOp()) )
     {
         // b2dpolygon support not implemented yet on non-UNX platforms
-        const ::basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
+        const basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
         basegfx::B2DPolyPolygon aB2DPolyPolygon(rB2DPolyPoly);
 
         // transform the polygon into device space and ensure it is closed
@@ -255,8 +255,8 @@ void OutputDevice::DrawTransparent( const basegfx::B2DPolyPolygon& rB2DPolyPoly,
             const int nPolyCount = aB2DPolyPolygon.count();
             for( int nPolyIdx = 0; nPolyIdx < nPolyCount; ++nPolyIdx )
             {
-                const ::basegfx::B2DPolygon aOnePoly = aB2DPolyPolygon.getB2DPolygon( nPolyIdx );
-                mpGraphics->DrawPolyLine( aOnePoly, fTransparency, aHairlineWidth, ::basegfx::B2DLineJoin::NONE, css::drawing::LineCap_BUTT, this );
+                const basegfx::B2DPolygon aOnePoly = aB2DPolyPolygon.getB2DPolygon( nPolyIdx );
+                mpGraphics->DrawPolyLine( aOnePoly, fTransparency, aHairlineWidth, basegfx::B2DLineJoin::NONE, css::drawing::LineCap_BUTT, this );
             }
         }
 
@@ -324,7 +324,7 @@ bool OutputDevice::DrawTransparentNatively ( const tools::PolyPolygon& rPolyPoly
 
         // get the polygon in device coordinates
         basegfx::B2DPolyPolygon aB2DPolyPolygon( rPolyPoly.getB2DPolyPolygon() );
-        const ::basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
+        const basegfx::B2DHomMatrix aTransform = ImplGetDeviceTransformation();
         aB2DPolyPolygon.transform( aTransform );
 
         const double fTransparency = 0.01 * nTransparencePercent;
@@ -351,9 +351,9 @@ bool OutputDevice::DrawTransparentNatively ( const tools::PolyPolygon& rPolyPoly
             const int nPolyCount = aB2DPolyPolygon.count();
             for( int nPolyIdx = 0; nPolyIdx < nPolyCount; ++nPolyIdx )
             {
-                const ::basegfx::B2DPolygon& rPolygon = aB2DPolyPolygon.getB2DPolygon( nPolyIdx );
+                const basegfx::B2DPolygon& rPolygon = aB2DPolyPolygon.getB2DPolygon( nPolyIdx );
                 bDrawn = mpGraphics->DrawPolyLine( rPolygon, fTransparency, aLineWidths,
-                                                   ::basegfx::B2DLineJoin::NONE, css::drawing::LineCap_BUTT, this );
+                                                   basegfx::B2DLineJoin::NONE, css::drawing::LineCap_BUTT, this );
             }
             // prepare to restore the fill color
             mbInitFillColor = mbFillColor;
diff --git a/vcl/unx/generic/gdi/cairotextrender.cxx b/vcl/unx/generic/gdi/cairotextrender.cxx
index 38462a16bdef..5434ddbe40bf 100644
--- a/vcl/unx/generic/gdi/cairotextrender.cxx
+++ b/vcl/unx/generic/gdi/cairotextrender.cxx
@@ -493,7 +493,7 @@ bool CairoTextRender::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect
 }
 
 bool CairoTextRender::GetGlyphOutline( sal_GlyphId aGlyphId,
-    ::basegfx::B2DPolyPolygon& rPolyPoly )
+    basegfx::B2DPolyPolygon& rPolyPoly )
 {
     const int nLevel = aGlyphId >> GF_FONTSHIFT;
     if( nLevel >= MAX_FALLBACK )
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index 745f52f8f4e2..645db2ce2a72 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -1449,7 +1449,7 @@ bool X11SalGraphicsImpl::drawEPS( long,long,long,long,void*,sal_uLong )
 }
 
 // draw a poly-polygon
-bool X11SalGraphicsImpl::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency )
+bool X11SalGraphicsImpl::drawPolyPolygon( const basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency )
 {
     // nothing to do for empty polypolygons
     const int nOrigPolyCount = rOrigPolyPoly.count();
@@ -1503,7 +1503,7 @@ long X11SalGraphicsImpl::GetGraphicsHeight() const
         return 0;
 }
 
-bool X11SalGraphicsImpl::drawFilledTrapezoids( const ::basegfx::B2DTrapezoid* pB2DTraps, int nTrapCount, double fTransparency )
+bool X11SalGraphicsImpl::drawFilledTrapezoids( const basegfx::B2DTrapezoid* pB2DTraps, int nTrapCount, double fTransparency )
 {
     if( nTrapCount <= 0 )
         return true;
@@ -1572,9 +1572,9 @@ bool X11SalGraphicsImpl::drawFilledTrapezoids( const ::basegfx::B2DTrapezoid* pB
 }
 
 bool X11SalGraphicsImpl::drawPolyLine(
-    const ::basegfx::B2DPolygon& rPolygon,
+    const basegfx::B2DPolygon& rPolygon,
     double fTransparency,
-    const ::basegfx::B2DVector& rLineWidth,
+    const basegfx::B2DVector& rLineWidth,
     basegfx::B2DLineJoin eLineJoin,
     css::drawing::LineCap eLineCap)
 {
@@ -1647,7 +1647,7 @@ bool X11SalGraphicsImpl::drawPolyLine(
     const int nPolyCount = aAreaPolyPoly.count();
     for( int nPolyIdx = 0; nPolyIdx < nPolyCount; ++nPolyIdx )
     {
-        const ::basegfx::B2DPolyPolygon aOnePoly( aAreaPolyPoly.getB2DPolygon( nPolyIdx ) );
+        const basegfx::B2DPolyPolygon aOnePoly( aAreaPolyPoly.getB2DPolygon( nPolyIdx ) );
         bDrawnOk = drawPolyPolygon( aOnePoly, fTransparency );
         if( !bDrawnOk )
             break;
diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index 5031faf9bbc6..f964e4a59131 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -88,7 +88,7 @@ private:
                                );
 
     XID GetXRenderPicture();
-    bool drawFilledTrapezoids( const ::basegfx::B2DTrapezoid*, int nTrapCount, double fTransparency );
+    bool drawFilledTrapezoids( const basegfx::B2DTrapezoid*, int nTrapCount, double fTransparency );
 
     long GetGraphicsHeight() const;
 
@@ -153,12 +153,12 @@ public:
     virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 
     virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
-    virtual bool drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
 
     virtual bool drawPolyLine(
-                const ::basegfx::B2DPolygon&,
+                const basegfx::B2DPolygon&,
                 double fTransparency,
-                const ::basegfx::B2DVector& rLineWidths,
+                const basegfx::B2DVector& rLineWidths,
                 basegfx::B2DLineJoin,
                 css::drawing::LineCap) override;
 
diff --git a/vcl/unx/generic/gdi/salgdi.cxx b/vcl/unx/generic/gdi/salgdi.cxx
index 738d59bf769c..09ca082d0944 100644
--- a/vcl/unx/generic/gdi/salgdi.cxx
+++ b/vcl/unx/generic/gdi/salgdi.cxx
@@ -524,7 +524,7 @@ cairo::SurfaceSharedPtr X11SalGraphics::CreateBitmapSurface( const OutputDevice&
     return cairo::SurfaceSharedPtr();
 }
 
-css::uno::Any X11SalGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const ::basegfx::B2ISize& /*rSize*/) const
+css::uno::Any X11SalGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& /*rSize*/) const
 {
     cairo::X11Surface& rXlibSurface=dynamic_cast<cairo::X11Surface&>(*rSurface.get());
     css::uno::Sequence< css::uno::Any > args( 3 );
@@ -535,15 +535,15 @@ css::uno::Any X11SalGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rS
 }
 
 // draw a poly-polygon
-bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency )
+bool X11SalGraphics::drawPolyPolygon( const basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency )
 {
     return mxImpl->drawPolyPolygon( rOrigPolyPoly, fTransparency );
 }
 
 bool X11SalGraphics::drawPolyLine(
-    const ::basegfx::B2DPolygon& rPolygon,
+    const basegfx::B2DPolygon& rPolygon,
     double fTransparency,
-    const ::basegfx::B2DVector& rLineWidth,
+    const basegfx::B2DVector& rLineWidth,
     basegfx::B2DLineJoin eLineJoin,
     css::drawing::LineCap eLineCap)
 {
diff --git a/vcl/unx/generic/gdi/salgdi3.cxx b/vcl/unx/generic/gdi/salgdi3.cxx
index aa4c5c47714b..e7542ddd97ca 100644
--- a/vcl/unx/generic/gdi/salgdi3.cxx
+++ b/vcl/unx/generic/gdi/salgdi3.cxx
@@ -146,7 +146,7 @@ bool X11SalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
 }
 
 bool X11SalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId,
-    ::basegfx::B2DPolyPolygon& rPolyPoly )
+    basegfx::B2DPolyPolygon& rPolyPoly )
 {
     return mxTextRenderImpl->GetGlyphOutline(aGlyphId, rPolyPoly);
 }
diff --git a/vcl/win/gdi/gdiimpl.cxx b/vcl/win/gdi/gdiimpl.cxx
index dc16217155bb..7a1bbdc66026 100644
--- a/vcl/win/gdi/gdiimpl.cxx
+++ b/vcl/win/gdi/gdiimpl.cxx
@@ -1979,7 +1979,7 @@ void impAddB2DPolygonToGDIPlusGraphicsPathInteger(Gdiplus::GpPath *pPath, const
     }
 }
 
-bool WinSalGraphicsImpl::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency)
+bool WinSalGraphicsImpl::drawPolyPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency)
 {
     const sal_uInt32 nCount(rPolyPolygon.count());
 
diff --git a/vcl/win/gdi/gdiimpl.hxx b/vcl/win/gdi/gdiimpl.hxx
index c36052cc955f..b93d1f361292 100644
--- a/vcl/win/gdi/gdiimpl.hxx
+++ b/vcl/win/gdi/gdiimpl.hxx
@@ -104,12 +104,12 @@ public:
     virtual void drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 
     virtual void drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry ) override;
-    virtual bool drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency ) override;
+    virtual bool drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
 
     virtual bool drawPolyLine(
-                const ::basegfx::B2DPolygon&,
+                const basegfx::B2DPolygon&,
                 double fTransparency,
-                const ::basegfx::B2DVector& rLineWidths,
+                const basegfx::B2DVector& rLineWidths,
                 basegfx::B2DLineJoin,
                 css::drawing::LineCap) override;
 
diff --git a/vcl/win/gdi/salgdi3.cxx b/vcl/win/gdi/salgdi3.cxx
index 732118689fef..7b20a631e5a6 100644
--- a/vcl/win/gdi/salgdi3.cxx
+++ b/vcl/win/gdi/salgdi3.cxx
@@ -1974,7 +1974,7 @@ bool WinSalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
 }
 
 bool WinSalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId,
-    ::basegfx::B2DPolyPolygon& rB2DPolyPoly )
+    basegfx::B2DPolyPolygon& rB2DPolyPoly )
 {
     rB2DPolyPoly.clear();
 
diff --git a/vcl/win/gdi/salgdi_gdiplus.cxx b/vcl/win/gdi/salgdi_gdiplus.cxx
index b07186550132..f821e03606ea 100644
--- a/vcl/win/gdi/salgdi_gdiplus.cxx
+++ b/vcl/win/gdi/salgdi_gdiplus.cxx
@@ -26,7 +26,7 @@
 
 #include "gdiimpl.hxx"
 
-bool WinSalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency)
+bool WinSalGraphics::drawPolyPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency)
 {
     return mpImpl->drawPolyPolygon( rPolyPolygon, fTransparency );
 }
diff --git a/vcl/workben/vcldemo.cxx b/vcl/workben/vcldemo.cxx
index 423ff2a23231..31b0b58b9273 100644
--- a/vcl/workben/vcldemo.cxx
+++ b/vcl/workben/vcldemo.cxx
@@ -258,7 +258,7 @@ public:
                     drawing::LineCap_BUTT, drawing::LineCap_ROUND, drawing::LineCap_SQUARE, drawing::LineCap_BUTT,
                     drawing::LineCap_BUTT, drawing::LineCap_ROUND, drawing::LineCap_SQUARE, drawing::LineCap_BUTT
                 };
-                ::basegfx::B2DLineJoin eJoins[] = {
+                basegfx::B2DLineJoin eJoins[] = {
                     basegfx::B2DLineJoin::NONE,  basegfx::B2DLineJoin::Middle, basegfx::B2DLineJoin::Bevel,  basegfx::B2DLineJoin::Miter,
                     basegfx::B2DLineJoin::Round, basegfx::B2DLineJoin::NONE,   basegfx::B2DLineJoin::Middle, basegfx::B2DLineJoin::Bevel,
                     basegfx::B2DLineJoin::Miter, basegfx::B2DLineJoin::Round,  basegfx::B2DLineJoin::NONE,   basegfx::B2DLineJoin::Middle,