Drop :: prefix from std in c*/

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

29 files changed, 110 insertions, 110 deletions

diff --git a/canvas/source/cairo/cairo_canvashelper.cxx b/canvas/source/cairo/cairo_canvashelper.cxx
index c733a25bb567..2bfd634694e2 100644
--- a/canvas/source/cairo/cairo_canvashelper.cxx
+++ b/canvas/source/cairo/cairo_canvashelper.cxx
@@ -861,9 +861,9 @@ namespace cairocanvas
                                 // use at least three steps, and at utmost the number of color
                                 // steps
                                 const unsigned int nStepCount(
-                                    ::std::max(
+                                    std::max(
                                         3U,
-                                        ::std::min(
+                                        std::min(
                                             nGradientSize / nStripSize,
                                             128U )) + 1 );
 
diff --git a/canvas/source/cairo/cairo_spritecanvashelper.cxx b/canvas/source/cairo/cairo_spritecanvashelper.cxx
index 8ffa34e4da9c..7f419e02e66c 100644
--- a/canvas/source/cairo/cairo_spritecanvashelper.cxx
+++ b/canvas/source/cairo/cairo_spritecanvashelper.cxx
@@ -266,7 +266,7 @@ namespace cairocanvas
             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) );
         ::basegfx::B2IPoint aDestPos( rDestRect.getMinimum() );
 
-        ::std::vector< ::basegfx::B2IRange > aUnscrollableAreas;
+        std::vector< ::basegfx::B2IRange > aUnscrollableAreas;
 
         // TODO(E3): This is plain buggy (but copies the behaviour of
         // the old Impress slideshow) - the scrolled area might
@@ -352,7 +352,7 @@ namespace cairocanvas
         // repaint uncovered areas from backbuffer - take the
         // _rounded_ rectangles from above, to have the update
         // consistent with the scroll above.
-        ::std::vector< ::basegfx::B2DRange > aUncoveredAreas;
+        std::vector< ::basegfx::B2DRange > aUncoveredAreas;
         ::basegfx::computeSetDifference( aUncoveredAreas,
                                          rUpdateArea.maTotalBounds,
                                          ::basegfx::B2DRange( rDestRect ) );
@@ -370,7 +370,7 @@ namespace cairocanvas
     }
 
     void SpriteCanvasHelper::opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                                           const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
+                                           const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
     {
         ENSURE_OR_THROW( mpOwningSpriteCanvas &&
                           mpOwningSpriteCanvas->getBufferSurface(),
@@ -415,7 +415,7 @@ namespace cairocanvas
     }
 
     void SpriteCanvasHelper::genericUpdate( const ::basegfx::B2DRange&                          rRequestedArea,
-                                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
+                                            const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
     {
         // TODO
         SAL_INFO("canvas.cairo", "SpriteCanvasHelper::genericUpdate called");
@@ -437,17 +437,17 @@ namespace cairocanvas
         // otherwise, truncation of size below might leave visible
         // areas uncovered by VDev.
         const Point aOutputPosition(
-            ::std::max( sal_Int32( 0 ),
+            std::max( sal_Int32( 0 ),
                         static_cast< sal_Int32 >(rRequestedArea.getMinX()) ),
-            ::std::max( sal_Int32( 0 ),
+            std::max( sal_Int32( 0 ),
                         static_cast< sal_Int32 >(rRequestedArea.getMinY()) ) );
         // round output size towards +infty. Don't want to truncate a
         // fraction of a sprite pixel... Limit size of VDev to output
         // device's area.
         const Size  aOutputSize(
-            ::std::min( rSize.getX(),
+            std::min( rSize.getX(),
                         ::canvas::tools::roundUp( rRequestedArea.getMaxX() - aOutputPosition.X()) ),
-            ::std::min( rSize.getY(),
+            std::min( rSize.getY(),
                         ::canvas::tools::roundUp( rRequestedArea.getMaxY() - aOutputPosition.Y()) ) );
 
         cairo_rectangle( pCompositingCairo.get(), aOutputPosition.X(), aOutputPosition.Y(), aOutputSize.Width(), aOutputSize.Height() );
diff --git a/canvas/source/cairo/cairo_spritecanvashelper.hxx b/canvas/source/cairo/cairo_spritecanvashelper.hxx
index 35cf73629653..1c71b4878a5a 100644
--- a/canvas/source/cairo/cairo_spritecanvashelper.hxx
+++ b/canvas/source/cairo/cairo_spritecanvashelper.hxx
@@ -111,10 +111,10 @@ namespace cairocanvas
                            const ::canvas::SpriteRedrawManager::UpdateArea&     rUpdateArea );
 
         void opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                           const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+                           const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
 
         void genericUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+                            const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
 
     private:
         ::cairo::SurfaceSharedPtr const & getCompositingSurface( const ::basegfx::B2ISize& rNeededSize );
diff --git a/canvas/source/cairo/cairo_textlayout.cxx b/canvas/source/cairo/cairo_textlayout.cxx
index eaf439923992..3b6356c6cd51 100644
--- a/canvas/source/cairo/cairo_textlayout.cxx
+++ b/canvas/source/cairo/cairo_textlayout.cxx
@@ -306,7 +306,7 @@ namespace cairocanvas
         setupLayoutMode( rOutDev, mnTextDirection );
 
         // TODO(P2): cache that
-        ::std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
+        std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
 
         if( maLogicalAdvancements.getLength() )
         {
@@ -553,7 +553,7 @@ namespace cairocanvas
                                                      renderState);
 
         // fill integer offsets
-        ::std::transform( inputOffsets.getConstArray(),
+        std::transform( inputOffsets.getConstArray(),
                           inputOffsets.getConstArray()+inputOffsets.getLength(),
                           outputOffsets,
                           OffsetTransformer( aMatrix ) );
diff --git a/canvas/source/directx/dx_9rm.cxx b/canvas/source/directx/dx_9rm.cxx
index 4b41d302b54b..db4f151123dd 100644
--- a/canvas/source/directx/dx_9rm.cxx
+++ b/canvas/source/directx/dx_9rm.cxx
@@ -183,7 +183,7 @@ namespace dxcanvas
 
             virtual void resize( const ::basegfx::B2IRange& rect ) override;
             virtual ::basegfx::B2IVector getPageSize() override;
-            virtual ::std::shared_ptr<canvas::ISurface> createSurface( const ::basegfx::B2IVector& surfaceSize ) override;
+            virtual std::shared_ptr<canvas::ISurface> createSurface( const ::basegfx::B2IVector& surfaceSize ) override;
             virtual void beginPrimitive( PrimitiveType eType ) override;
             virtual void endPrimitive() override;
             virtual void pushVertex( const ::canvas::Vertex& vertex ) override;
@@ -212,7 +212,7 @@ namespace dxcanvas
             COMReference<IDirect3D9>                    mpDirect3D9;
             COMReference<IDirect3DSwapChain9>           mpSwapChain;
             COMReference<IDirect3DVertexBuffer9>        mpVertexBuffer;
-            ::std::shared_ptr<canvas::ISurface>                 mpTexture;
+            std::shared_ptr<canvas::ISurface>                 mpTexture;
             VclPtr<SystemChildWindow>                   mpWindow;
             ::basegfx::B2IVector                        maSize;
             typedef std::vector<canvas::Vertex>         vertexCache_t;
@@ -514,7 +514,7 @@ namespace dxcanvas
             ::basegfx::B2IVector aPageSize(maPageSize);
             while(true)
             {
-                mpTexture = ::std::shared_ptr<canvas::ISurface>(
+                mpTexture = std::shared_ptr<canvas::ISurface>(
                     new DXSurface(*this,aPageSize));
                 if(mpTexture->isValid())
                     break;
@@ -980,13 +980,13 @@ namespace dxcanvas
         // DXRenderModule::createSurface
 
 
-        ::std::shared_ptr<canvas::ISurface> DXRenderModule::createSurface( const ::basegfx::B2IVector& surfaceSize )
+        std::shared_ptr<canvas::ISurface> DXRenderModule::createSurface( const ::basegfx::B2IVector& surfaceSize )
         {
             // TODO(P2): get rid of those fine-grained locking
             ::osl::MutexGuard aGuard( maMutex );
 
             if(isDisposed())
-                return ::std::shared_ptr<canvas::ISurface>();
+                return std::shared_ptr<canvas::ISurface>();
 
             const ::basegfx::B2IVector& rPageSize( getPageSize() );
             ::basegfx::B2ISize aSize(surfaceSize);
@@ -998,7 +998,7 @@ namespace dxcanvas
             if(mpTexture.use_count() == 1)
                 return mpTexture;
 
-            return ::std::shared_ptr<canvas::ISurface>( new DXSurface(*this,aSize) );
+            return std::shared_ptr<canvas::ISurface>( new DXSurface(*this,aSize) );
         }
 
 
diff --git a/canvas/source/directx/dx_canvascustomsprite.cxx b/canvas/source/directx/dx_canvascustomsprite.cxx
index b0e4b740ef67..4a87a66b04a8 100644
--- a/canvas/source/directx/dx_canvascustomsprite.cxx
+++ b/canvas/source/directx/dx_canvascustomsprite.cxx
@@ -40,7 +40,7 @@ namespace dxcanvas
     CanvasCustomSprite::CanvasCustomSprite( const css::geometry::RealSize2D&   rSpriteSize,
                                             const SpriteCanvasRef&                          rRefDevice,
                                             const IDXRenderModuleSharedPtr&                 rRenderModule,
-                                            const ::std::shared_ptr<canvas::ISurfaceProxyManager>&  rSurfaceProxy,
+                                            const std::shared_ptr<canvas::ISurfaceProxyManager>&  rSurfaceProxy,
                                             bool                                            bShowSpriteBounds ) :
         mpSpriteCanvas( rRefDevice ),
         mpSurface()
diff --git a/canvas/source/directx/dx_canvascustomsprite.hxx b/canvas/source/directx/dx_canvascustomsprite.hxx
index a3b57917ed7b..1772741a3fdf 100644
--- a/canvas/source/directx/dx_canvascustomsprite.hxx
+++ b/canvas/source/directx/dx_canvascustomsprite.hxx
@@ -99,7 +99,7 @@ namespace dxcanvas
         CanvasCustomSprite( const css::geometry::RealSize2D&   rSpriteSize,
                             const SpriteCanvasRef&                          rRefDevice,
                             const IDXRenderModuleSharedPtr&                 rRenderModule,
-                            const ::std::shared_ptr<canvas::ISurfaceProxyManager>&  rSurfaceProxy,
+                            const std::shared_ptr<canvas::ISurfaceProxyManager>&  rSurfaceProxy,
                             bool                                            bShowSpriteBounds );
 
         virtual void disposeThis() override;
diff --git a/canvas/source/directx/dx_canvashelper.cxx b/canvas/source/directx/dx_canvashelper.cxx
index 94b9c322b5ea..72c63ffc2816 100644
--- a/canvas/source/directx/dx_canvashelper.cxx
+++ b/canvas/source/directx/dx_canvashelper.cxx
@@ -358,8 +358,8 @@ namespace dxcanvas
             if(bIsMiter)
                 aPen.SetMiterLimit( static_cast< Gdiplus::REAL >(strokeAttributes.MiterLimit) );
 
-            const ::std::vector< Gdiplus::REAL >& rDashArray(
-                ::comphelper::sequenceToContainer< ::std::vector< Gdiplus::REAL >, double >(
+            const std::vector< Gdiplus::REAL >& rDashArray(
+                ::comphelper::sequenceToContainer< std::vector< Gdiplus::REAL >, double >(
                     strokeAttributes.DashArray ) );
             if( !rDashArray.empty() )
             {
diff --git a/canvas/source/directx/dx_canvashelper_texturefill.cxx b/canvas/source/directx/dx_canvashelper_texturefill.cxx
index c9853cf4a36e..4bebeb8c30f2 100644
--- a/canvas/source/directx/dx_canvashelper_texturefill.cxx
+++ b/canvas/source/directx/dx_canvashelper_texturefill.cxx
@@ -186,9 +186,9 @@ namespace dxcanvas
 
         int numColorSteps( const Gdiplus::Color& rColor1, const Gdiplus::Color& rColor2 )
         {
-            return ::std::max(
+            return std::max(
                 labs( rColor1.GetRed() - rColor2.GetRed() ),
-                ::std::max(
+                std::max(
                     labs( rColor1.GetGreen() - rColor2.GetGreen() ),
                     labs( rColor1.GetBlue()  - rColor2.GetBlue() ) ) );
         }
diff --git a/canvas/source/directx/dx_impltools.cxx b/canvas/source/directx/dx_impltools.cxx
index 60429f2a500d..a748b5d9729f 100644
--- a/canvas/source/directx/dx_impltools.cxx
+++ b/canvas/source/directx/dx_impltools.cxx
@@ -174,7 +174,7 @@ namespace dxcanvas
             }
 
             void graphicsPathFromB2DPolygon( GraphicsPathSharedPtr&             rOutput,
-                                             ::std::vector< Gdiplus::PointF >&  rPoints,
+                                             std::vector< Gdiplus::PointF >&  rPoints,
                                              const ::basegfx::B2DPolygon&       rPoly,
                                              bool bNoLineJoin)
             {
@@ -406,7 +406,7 @@ namespace dxcanvas
         GraphicsPathSharedPtr graphicsPathFromRealPoint2DSequence( const uno::Sequence< uno::Sequence< geometry::RealPoint2D > >& points )
         {
             GraphicsPathSharedPtr pRes( new Gdiplus::GraphicsPath() );
-            ::std::vector< Gdiplus::PointF > aPoints;
+            std::vector< Gdiplus::PointF > aPoints;
 
             sal_Int32 nCurrPoly;
             for( nCurrPoly=0; nCurrPoly<points.getLength(); ++nCurrPoly )
@@ -419,7 +419,7 @@ namespace dxcanvas
                     // TODO(F1): Closed/open polygons
 
                     // convert from RealPoint2D array to Gdiplus::PointF array
-                    ::std::transform( points[nCurrPoly].getConstArray(),
+                    std::transform( points[nCurrPoly].getConstArray(),
                                       points[nCurrPoly].getConstArray()+nCurrSize,
                                       aPoints.begin(),
                                       implGdiPlusPointFromRealPoint2D );
@@ -434,7 +434,7 @@ namespace dxcanvas
         GraphicsPathSharedPtr graphicsPathFromB2DPolygon( const ::basegfx::B2DPolygon& rPoly, bool bNoLineJoin )
         {
             GraphicsPathSharedPtr               pRes( new Gdiplus::GraphicsPath() );
-            ::std::vector< Gdiplus::PointF >    aPoints;
+            std::vector< Gdiplus::PointF >    aPoints;
 
             graphicsPathFromB2DPolygon( pRes, aPoints, rPoly, bNoLineJoin );
 
@@ -444,7 +444,7 @@ namespace dxcanvas
         GraphicsPathSharedPtr graphicsPathFromB2DPolyPolygon( const ::basegfx::B2DPolyPolygon& rPoly, bool bNoLineJoin )
         {
             GraphicsPathSharedPtr               pRes( new Gdiplus::GraphicsPath() );
-            ::std::vector< Gdiplus::PointF >    aPoints;
+            std::vector< Gdiplus::PointF >    aPoints;
 
             const sal_uInt32 nPolies( rPoly.count() );
             for( sal_uInt32 nCurrPoly=0; nCurrPoly<nPolies; ++nCurrPoly )
diff --git a/canvas/source/directx/dx_spritecanvashelper.cxx b/canvas/source/directx/dx_spritecanvashelper.cxx
index f8661d82a0d3..d10a6fe66824 100644
--- a/canvas/source/directx/dx_spritecanvashelper.cxx
+++ b/canvas/source/directx/dx_spritecanvashelper.cxx
@@ -79,7 +79,7 @@ namespace dxcanvas
     void SpriteCanvasHelper::init( SpriteCanvas&                                    rParent,
                                    ::canvas::SpriteRedrawManager&                   rManager,
                                    const IDXRenderModuleSharedPtr&                  rRenderModule,
-                                   const ::std::shared_ptr<canvas::ISurfaceProxyManager>&   rSurfaceProxy,
+                                   const std::shared_ptr<canvas::ISurfaceProxyManager>&   rSurfaceProxy,
                                    const DXSurfaceBitmapSharedPtr&                  rBackBuffer,
                                    const ::basegfx::B2ISize&                        rOutputOffset )
     {
@@ -265,7 +265,7 @@ namespace dxcanvas
         // repaint uncovered areas from backbuffer - take the
         // _rounded_ rectangles from above, to have the update
         // consistent with the scroll above.
-        ::std::vector< ::basegfx::B2DRange > aUncoveredAreas;
+        std::vector< ::basegfx::B2DRange > aUncoveredAreas;
         ::basegfx::computeSetDifference( aUncoveredAreas,
                                          rUpdateArea.maTotalBounds,
                                          ::basegfx::B2DRange( rDestRect ) );
@@ -283,7 +283,7 @@ namespace dxcanvas
     }
 
     void SpriteCanvasHelper::opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                                           const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
+                                           const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
     {
         ENSURE_OR_THROW( mpRenderModule &&
                           mpBackBuffer,
@@ -313,7 +313,7 @@ namespace dxcanvas
     }
 
     void SpriteCanvasHelper::genericUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
+                                            const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
     {
         ENSURE_OR_THROW( mpRenderModule &&
                           mpBackBuffer,
diff --git a/canvas/source/directx/dx_spritecanvashelper.hxx b/canvas/source/directx/dx_spritecanvashelper.hxx
index d3f48ab0cfa9..5137d6f9f208 100644
--- a/canvas/source/directx/dx_spritecanvashelper.hxx
+++ b/canvas/source/directx/dx_spritecanvashelper.hxx
@@ -46,7 +46,7 @@ namespace dxcanvas
         void init( SpriteCanvas&                                    rParent,
                    ::canvas::SpriteRedrawManager&                   rManager,
                    const IDXRenderModuleSharedPtr&                  rRenderModule,
-                   const ::std::shared_ptr<canvas::ISurfaceProxyManager>&   rSurfaceProxy,
+                   const std::shared_ptr<canvas::ISurfaceProxyManager>&   rSurfaceProxy,
                    const DXSurfaceBitmapSharedPtr&                  rBackBuffer,
                    const ::basegfx::B2ISize&                        rOutputOffset );
 
@@ -119,10 +119,10 @@ namespace dxcanvas
                            const ::canvas::SpriteRedrawManager::UpdateArea&     rUpdateArea );
 
         void opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                           const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+                           const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
 
         void genericUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+                            const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
 
     private:
         /// For generating sprites
@@ -134,7 +134,7 @@ namespace dxcanvas
         /// DX device, handling all low-level rendering
         IDXRenderModuleSharedPtr                        mpRenderModule;
 
-        ::std::shared_ptr<canvas::ISurfaceProxyManager>         mpSurfaceProxy;
+        std::shared_ptr<canvas::ISurfaceProxyManager>         mpSurfaceProxy;
 
         /// Backbuffer, contains the static canvas render output
         DXSurfaceBitmapSharedPtr                        mpBackBuffer;
diff --git a/canvas/source/directx/dx_spritedevicehelper.cxx b/canvas/source/directx/dx_spritedevicehelper.cxx
index ac8ce68d2c82..41f5b63ba655 100644
--- a/canvas/source/directx/dx_spritedevicehelper.cxx
+++ b/canvas/source/directx/dx_spritedevicehelper.cxx
@@ -56,8 +56,8 @@ namespace dxcanvas
                                    bool                  /*bFullscreen*/ )
     {
         // #i60490# ensure backbuffer has sensible minimal size
-        const sal_Int32 w( ::std::max(sal_Int32(1),sal_Int32(rRect.Width)));
-        const sal_Int32 h( ::std::max(sal_Int32(1),sal_Int32(rRect.Height)));
+        const sal_Int32 w( std::max(sal_Int32(1),sal_Int32(rRect.Width)));
+        const sal_Int32 h( std::max(sal_Int32(1),sal_Int32(rRect.Height)));
 
         rSpriteCanvas.setWindow(
             uno::Reference<awt::XWindow2>(
@@ -185,8 +185,8 @@ namespace dxcanvas
         // #i60490# ensure backbuffer has sensible minimal size
         const sal_Int32 x(rBounds.X);
         const sal_Int32 y(rBounds.Y);
-        const sal_Int32 w(::std::max(sal_Int32(1),sal_Int32(rBounds.Width)));
-        const sal_Int32 h(::std::max(sal_Int32(1),sal_Int32(rBounds.Height)));
+        const sal_Int32 w(std::max(sal_Int32(1),sal_Int32(rBounds.Width)));
+        const sal_Int32 h(std::max(sal_Int32(1),sal_Int32(rBounds.Height)));
 
         if( mpRenderModule )
             mpRenderModule->resize(::basegfx::B2IRange(x,y,x+w,y+h));
diff --git a/canvas/source/directx/dx_spritedevicehelper.hxx b/canvas/source/directx/dx_spritedevicehelper.hxx
index 9d5eed1b9789..88848d4bf0ce 100644
--- a/canvas/source/directx/dx_spritedevicehelper.hxx
+++ b/canvas/source/directx/dx_spritedevicehelper.hxx
@@ -68,7 +68,7 @@ namespace dxcanvas
 
         const IDXRenderModuleSharedPtr& getRenderModule() const { return mpRenderModule; }
         const DXSurfaceBitmapSharedPtr& getBackBuffer() const { return mpBackBuffer; }
-        const ::std::shared_ptr<canvas::ISurfaceProxyManager> &getSurfaceProxy() const { return mpSurfaceProxyManager; }
+        const std::shared_ptr<canvas::ISurfaceProxyManager> &getSurfaceProxy() const { return mpSurfaceProxyManager; }
 
         css::uno::Any isAccelerated() const;
 
@@ -89,7 +89,7 @@ namespace dxcanvas
         DXSurfaceBitmapSharedPtr                mpBackBuffer;
 
         /// Instance passing out HW textures
-        ::std::shared_ptr<canvas::ISurfaceProxyManager> mpSurfaceProxyManager;
+        std::shared_ptr<canvas::ISurfaceProxyManager> mpSurfaceProxyManager;
 
         /// Our encapsulation interface to DirectX
         IDXRenderModuleSharedPtr                mpRenderModule;
diff --git a/canvas/source/directx/dx_textlayout_drawhelper.cxx b/canvas/source/directx/dx_textlayout_drawhelper.cxx
index fb8e184f9cc6..6e279788a8c1 100644
--- a/canvas/source/directx/dx_textlayout_drawhelper.cxx
+++ b/canvas/source/directx/dx_textlayout_drawhelper.cxx
@@ -201,7 +201,7 @@ namespace dxcanvas
             {
                 // create the DXArray
                 const sal_Int32 nLen( rLogicalAdvancements.getLength() );
-                ::std::unique_ptr<sal_Int32[]> pDXArray( new sal_Int32[nLen] );
+                std::unique_ptr<sal_Int32[]> pDXArray( new sal_Int32[nLen] );
                 for( sal_Int32 i=0; i<nLen; ++i )
                     pDXArray[i] = basegfx::fround( rLogicalAdvancements[i] );
 
diff --git a/canvas/source/directx/dx_winstuff.hxx b/canvas/source/directx/dx_winstuff.hxx
index cb1840d4d42b..1214c99c71cd 100644
--- a/canvas/source/directx/dx_winstuff.hxx
+++ b/canvas/source/directx/dx_winstuff.hxx
@@ -122,7 +122,7 @@ namespace dxcanvas
         COMReference& operator=( const COMReference& rRHS )
         {
             COMReference aTmp(rRHS);
-            ::std::swap( mp, aTmp.mp );
+            std::swap( mp, aTmp.mp );
 
             return *this;
         }
diff --git a/canvas/source/opengl/ogl_canvashelper.cxx b/canvas/source/opengl/ogl_canvashelper.cxx
index 67707bba4c59..d2edda651e4f 100644
--- a/canvas/source/opengl/ogl_canvashelper.cxx
+++ b/canvas/source/opengl/ogl_canvashelper.cxx
@@ -38,7 +38,7 @@
 #include "ogl_canvashelper.hxx"
 
 using namespace ::com::sun::star;
-using namespace ::std::placeholders;
+using namespace std::placeholders;
 
 namespace oglcanvas
 {
@@ -81,7 +81,7 @@ namespace oglcanvas
         rendering::ARGBColor            maARGBColor;
         ::basegfx::B2DPolyPolygonVector maPolyPolys;
 
-        ::std::function< bool (
+        std::function< bool (
                             const CanvasHelper&,
                             const ::basegfx::B2DHomMatrix&,
                             GLenum,
@@ -409,7 +409,7 @@ namespace oglcanvas
             Action& rAct=mpRecordedActions->back();
 
             setupGraphicsState( rAct, viewState, renderState );
-            rAct.maFunction = ::std::bind(&lcl_drawPoint,
+            rAct.maFunction = std::bind(&lcl_drawPoint,
                                             _1,_2,_3,_4,_5,
                                             aPoint);
         }
@@ -427,7 +427,7 @@ namespace oglcanvas
             Action& rAct=mpRecordedActions->back();
 
             setupGraphicsState( rAct, viewState, renderState );
-            rAct.maFunction = ::std::bind(&lcl_drawLine,
+            rAct.maFunction = std::bind(&lcl_drawLine,
                                           _1, _2, _3, _4, _5,
                                           aStartPoint, aEndPoint);
         }
@@ -447,7 +447,7 @@ namespace oglcanvas
             setupGraphicsState( rAct, viewState, renderState );
 
             // TODO(F2): subdivide&render whole curve
-            rAct.maFunction = ::std::bind(&lcl_drawLine,
+            rAct.maFunction = std::bind(&lcl_drawLine,
                                             _1,_2,_3,_4,_5,
                                             geometry::RealPoint2D(
                                                 aBezierSegment.Px,
@@ -600,7 +600,7 @@ namespace oglcanvas
                     const ::canvas::ParametricPolyPolygon::Values& rValues(
                         pGradient->getValues() );
 
-                    rAct.maFunction = ::std::bind(&lcl_fillGradientPolyPolygon,
+                    rAct.maFunction = std::bind(&lcl_fillGradientPolyPolygon,
                                                     _1,_2,_3,_4,
                                                     rValues,
                                                     textures[0],
@@ -643,7 +643,7 @@ namespace oglcanvas
                                 aPixelData,
                                 canvas::tools::getStdColorSpace()));
 
-                        rAct.maFunction = ::std::bind(&lcl_fillTexturedPolyPolygon,
+                        rAct.maFunction = std::bind(&lcl_fillTexturedPolyPolygon,
                                                         _1,_2,_3,_4,
                                                         textures[0],
                                                         aSize,
@@ -764,7 +764,7 @@ namespace oglcanvas
                 {
                     // create the DXArray
                     const sal_Int32 nLen( aLogicalAdvancements.getLength() );
-                    ::std::unique_ptr<long[]> pDXArray( new long[nLen] );
+                    std::unique_ptr<long[]> pDXArray( new long[nLen] );
                     for( sal_Int32 i=0; i<nLen; ++i )
                         pDXArray[i] = basegfx::fround( aLogicalAdvancements[i] );
 
@@ -820,7 +820,7 @@ namespace oglcanvas
                 Action& rAct=mpRecordedActions->back();
 
                 setupGraphicsState( rAct, viewState, renderState );
-                rAct.maFunction = ::std::bind(&lcl_drawOwnBitmap,
+                rAct.maFunction = std::bind(&lcl_drawOwnBitmap,
                                                 _1,_2,_3,_4,_5,
                                                 *pOwnBitmap);
             }
@@ -849,7 +849,7 @@ namespace oglcanvas
                     Action& rAct=mpRecordedActions->back();
 
                     setupGraphicsState( rAct, viewState, renderState );
-                    rAct.maFunction = ::std::bind(&lcl_drawGenericBitmap,
+                    rAct.maFunction = std::bind(&lcl_drawGenericBitmap,
                                                     _1,_2,_3,_4,_5,
                                                     aSize, aARGBBytes,
                                                     rtl_crc32(0,
diff --git a/canvas/source/opengl/ogl_textlayout.cxx b/canvas/source/opengl/ogl_textlayout.cxx
index 0331c8c9d2ba..5857367938e5 100644
--- a/canvas/source/opengl/ogl_textlayout.cxx
+++ b/canvas/source/opengl/ogl_textlayout.cxx
@@ -85,7 +85,7 @@ namespace oglcanvas
         // fake text bounds by either taking the advancement values,
         // or assuming square glyph boxes (width similar to height)
         const rendering::FontRequest& rFontRequest( mpFont->getFontRequest() );
-        const double nFontSize( ::std::max( rFontRequest.CellSize,
+        const double nFontSize( std::max( rFontRequest.CellSize,
                                             rFontRequest.ReferenceAdvancement ) );
         if( maLogicalAdvancements.getLength() )
         {
diff --git a/canvas/source/tools/canvascustomspritehelper.cxx b/canvas/source/tools/canvascustomspritehelper.cxx
index 37d010cd932c..0cbefbc5bf15 100644
--- a/canvas/source/tools/canvascustomspritehelper.cxx
+++ b/canvas/source/tools/canvascustomspritehelper.cxx
@@ -107,7 +107,7 @@ namespace canvas
                 {
                     // aClipBoundsB = maCurrClipBounds, i.e. last
                     // clip, intersected with sprite area
-                    typedef ::std::vector< ::basegfx::B2DRectangle > VectorOfRects;
+                    typedef std::vector< ::basegfx::B2DRectangle > VectorOfRects;
                     VectorOfRects aClipDifferences;
 
                     // get all rectangles covered by exactly one
@@ -171,11 +171,11 @@ namespace canvas
                           "CanvasCustomSpriteHelper::init(): Invalid owning sprite canvas" );
 
         mpSpriteCanvas = rOwningSpriteCanvas;
-        maSize.setX( ::std::max( 1.0,
+        maSize.setX( std::max( 1.0,
                                  ceil( rSpriteSize.Width ) ) ); // round up to nearest int,
                                                                  // enforce sprite to have at
                                                                  // least (1,1) pixel size
-        maSize.setY( ::std::max( 1.0,
+        maSize.setY( std::max( 1.0,
                                  ceil( rSpriteSize.Height ) ) );
     }
 
diff --git a/canvas/source/tools/canvastools.cxx b/canvas/source/tools/canvastools.cxx
index 640c3a3e3b93..ee41f6732d2a 100644
--- a/canvas/source/tools/canvastools.cxx
+++ b/canvas/source/tools/canvastools.cxx
@@ -69,8 +69,8 @@ namespace canvas
         geometry::RealSize2D createInfiniteSize2D()
         {
             return geometry::RealSize2D(
-                ::std::numeric_limits<double>::infinity(),
-                ::std::numeric_limits<double>::infinity() );
+                std::numeric_limits<double>::infinity(),
+                std::numeric_limits<double>::infinity() );
         }
 
         rendering::RenderState& initRenderState( rendering::RenderState& renderState )
@@ -1052,7 +1052,7 @@ namespace canvas
 
         bool clipScrollArea( ::basegfx::B2IRange&                  io_rSourceArea,
                              ::basegfx::B2IPoint&                  io_rDestPoint,
-                             ::std::vector< ::basegfx::B2IRange >& o_ClippedAreas,
+                             std::vector< ::basegfx::B2IRange >& o_ClippedAreas,
                              const ::basegfx::B2IRange&            rBounds )
         {
             ::basegfx::B2IRange aResultingDestArea;
@@ -1228,7 +1228,7 @@ namespace canvas
             // longest line in gradient bound rect
             const int nGradientSize(
                 static_cast<int>(
-                    ::std::max(
+                    std::max(
                         ::basegfx::B2DVector(aRightBottom-aLeftTop).getLength(),
                         ::basegfx::B2DVector(aRightTop-aLeftBottom).getLength() ) + 1.0 ) );
 
@@ -1237,8 +1237,8 @@ namespace canvas
 
             // use at least three steps, and at utmost the number of color
             // steps
-            return ::std::max( 3,
-                               ::std::min(
+            return std::max( 3,
+                               std::min(
                                    nGradientSize / nStripSize,
                                    nColorSteps ) );
         }
diff --git a/canvas/source/tools/spriteredrawmanager.cxx b/canvas/source/tools/spriteredrawmanager.cxx
index aaf99c5eaea5..3cf44368c3f8 100644
--- a/canvas/source/tools/spriteredrawmanager.cxx
+++ b/canvas/source/tools/spriteredrawmanager.cxx
@@ -235,10 +235,10 @@ namespace canvas
 
         // sort sprites after prio
         VectorOfSprites aSortedSpriteVector;
-        ::std::copy( maSprites.begin(),
+        std::copy( maSprites.begin(),
                      maSprites.end(),
-                     ::std::back_insert_iterator< VectorOfSprites >(aSortedSpriteVector) );
-        ::std::sort( aSortedSpriteVector.begin(),
+                     std::back_insert_iterator< VectorOfSprites >(aSortedSpriteVector) );
+        std::sort( aSortedSpriteVector.begin(),
                      aSortedSpriteVector.end(),
                      aSpriteComparator );
 
@@ -254,18 +254,18 @@ namespace canvas
                 aUpdatableSprites.push_back( rSprite );
         }
 
-        ::std::sort( aUpdatableSprites.begin(),
+        std::sort( aUpdatableSprites.begin(),
                      aUpdatableSprites.end(),
                      aSpriteComparator );
 
         VectorOfSprites::iterator aEnd=
-            ::std::unique( aUpdatableSprites.begin(),
+            std::unique( aUpdatableSprites.begin(),
                            aUpdatableSprites.end() );
 
         // for each unique sprite, check the change event vector,
         // calculate the update operation from that, and add the
         // result to the aUpdateArea.
-        ::std::for_each( aUpdatableSprites.begin(),
+        std::for_each( aUpdatableSprites.begin(),
                          aEnd,
                          SpriteUpdater( rUpdateAreas,
                                         maChangeRecords) );
@@ -279,11 +279,11 @@ namespace canvas
         // (i.e. the difference between aSortedSpriteVector and
         // aUpdatableSprites).
         VectorOfSprites aUnchangedSprites;
-        ::std::set_difference( aSortedSpriteVector.begin(),
+        std::set_difference( aSortedSpriteVector.begin(),
                                aSortedSpriteVector.end(),
                                aUpdatableSprites.begin(),
                                aEnd,
-                               ::std::back_insert_iterator< VectorOfSprites >(aUnchangedSprites),
+                               std::back_insert_iterator< VectorOfSprites >(aUnchangedSprites),
                                aSpriteComparator );
 
         // add each remaining unchanged sprite to connected ranges,
@@ -318,7 +318,7 @@ namespace canvas
     bool SpriteRedrawManager::isAreaUpdateScroll( ::basegfx::B2DRectangle&  o_rMoveStart,
                                                   ::basegfx::B2DRectangle&  o_rMoveEnd,
                                                   const UpdateArea&         rUpdateArea,
-                                                  ::std::size_t             nNumSprites ) const
+                                                  std::size_t             nNumSprites ) const
     {
         // check for a solitary move, which consists of exactly two
         // pure-move entries, the first with valid, the second with
@@ -378,7 +378,7 @@ namespace canvas
     }
 
     bool SpriteRedrawManager::isAreaUpdateOpaque( const UpdateArea& rUpdateArea,
-                                                  ::std::size_t     nNumSprites ) const
+                                                  std::size_t     nNumSprites ) const
     {
         // check whether the sprites in the update area's list will
         // fully cover the given area _and_ do that in an opaque way
@@ -406,9 +406,9 @@ namespace canvas
 
         // and check whether _any_ of the sprites tells that its area
         // update will not be opaque.
-        return ::std::none_of( rUpdateArea.maComponentList.begin(),
+        return std::none_of( rUpdateArea.maComponentList.begin(),
                                 aEnd,
-                                [&aTrueArea, this]( const ::std::pair< ::basegfx::B2DRange, SpriteInfo >& cp )
+                                [&aTrueArea, this]( const std::pair< ::basegfx::B2DRange, SpriteInfo >& cp )
                                 { return this->isAreaUpdateNotOpaque(aTrueArea, cp); } );
     }
 
@@ -421,9 +421,9 @@ namespace canvas
         // component (return false)
         const SpriteConnectedRanges::ComponentListType::const_iterator aEnd(
             rUpdateArea.maComponentList.end() );
-        return ::std::any_of( rUpdateArea.maComponentList.begin(),
+        return std::any_of( rUpdateArea.maComponentList.begin(),
                                 aEnd,
-                                []( const ::std::pair< ::basegfx::B2DRange, SpriteInfo >& cp )
+                                []( const std::pair< ::basegfx::B2DRange, SpriteInfo >& cp )
                                 { return cp.second.needsUpdate(); } );
     }
 
diff --git a/canvas/source/tools/surface.cxx b/canvas/source/tools/surface.cxx
index e596ea535dae..adea0c2a983d 100644
--- a/canvas/source/tools/surface.cxx
+++ b/canvas/source/tools/surface.cxx
@@ -208,10 +208,10 @@ namespace canvas
             ::basegfx::fround(rArea.getMaximum().getY()) );
 
         // clip the positions to the area this surface covers
-        aPos1.setX(::std::max(aPos1.getX(),maSourceOffset.getX()));
-        aPos1.setY(::std::max(aPos1.getY(),maSourceOffset.getY()));
-        aPos2.setX(::std::min(aPos2.getX(),maSourceOffset.getX()+maSize.getX()));
-        aPos2.setY(::std::min(aPos2.getY(),maSourceOffset.getY()+maSize.getY()));
+        aPos1.setX(std::max(aPos1.getX(),maSourceOffset.getX()));
+        aPos1.setY(std::max(aPos1.getY(),maSourceOffset.getY()));
+        aPos2.setX(std::min(aPos2.getX(),maSourceOffset.getX()+maSize.getX()));
+        aPos2.setY(std::min(aPos2.getY(),maSourceOffset.getY()+maSize.getY()));
 
         // if the resulting area is empty, return immediately
         ::basegfx::B2IVector aSize(aPos2 - aPos1);
diff --git a/canvas/source/tools/surfaceproxy.cxx b/canvas/source/tools/surfaceproxy.cxx
index a9fb781fcb9a..2699820ccb1c 100644
--- a/canvas/source/tools/surfaceproxy.cxx
+++ b/canvas/source/tools/surfaceproxy.cxx
@@ -63,9 +63,9 @@ namespace canvas
                 // the current surface is located at the position [x,y]
                 // and has the size [min(restx,pagesizex),min(resty,pagesizey)
                 ::basegfx::B2IPoint aOffset(x,y);
-                ::basegfx::B2ISize aSize( ::std::min( aImageSize.getX()-x,
+                ::basegfx::B2ISize aSize( std::min( aImageSize.getX()-x,
                                                       aPageSize.getX() ),
-                                          ::std::min( aImageSize.getY()-y,
+                                          std::min( aImageSize.getY()-y,
                                                       aPageSize.getY() ) );
 
                 maSurfaceList.push_back(
diff --git a/canvas/source/vcl/canvascustomsprite.cxx b/canvas/source/vcl/canvascustomsprite.cxx
index e8ee7752cc0d..ab1d4c80cd72 100644
--- a/canvas/source/vcl/canvascustomsprite.cxx
+++ b/canvas/source/vcl/canvascustomsprite.cxx
@@ -60,11 +60,11 @@ namespace vclcanvas
 
 
         const ::Size aSize(
-            static_cast<sal_Int32>( ::std::max( 1.0,
+            static_cast<sal_Int32>( std::max( 1.0,
                                                 ceil( rSpriteSize.Width ))),  // round up to nearest int,
                                                                               // enforce sprite to have at
                                                                                // least (1,1) pixel size
-            static_cast<sal_Int32>( ::std::max( 1.0,
+            static_cast<sal_Int32>( std::max( 1.0,
                                                 ceil( rSpriteSize.Height ))) );
 
         // create content backbuffer in screen depth
diff --git a/canvas/source/vcl/canvashelper.cxx b/canvas/source/vcl/canvashelper.cxx
index 90c399b15e3f..f13780d143c6 100644
--- a/canvas/source/vcl/canvashelper.cxx
+++ b/canvas/source/vcl/canvashelper.cxx
@@ -357,8 +357,8 @@ namespace vclcanvas
             // apply dashing, if any
             if( strokeAttributes.DashArray.getLength() )
             {
-                const ::std::vector<double>& aDashArray(
-                    ::comphelper::sequenceToContainer< ::std::vector<double> >(strokeAttributes.DashArray) );
+                const std::vector<double>& aDashArray(
+                    ::comphelper::sequenceToContainer< std::vector<double> >(strokeAttributes.DashArray) );
 
                 ::basegfx::B2DPolyPolygon aDashedPolyPoly;
 
@@ -1010,7 +1010,7 @@ namespace vclcanvas
         rOutDev.SetAntialiasing( AntialiasingFlags::EnableB2dDraw );
 
         const Rectangle aRect( vcl::unotools::rectangleFromIntegerRectangle2D(rect) );
-        const sal_uInt16    nBitCount( ::std::min( (sal_uInt16)24U,
+        const sal_uInt16    nBitCount( std::min( (sal_uInt16)24U,
                                                (sal_uInt16)rOutDev.GetBitCount() ) );
         const BitmapPalette* pPalette = nullptr;
 
diff --git a/canvas/source/vcl/canvashelper_texturefill.cxx b/canvas/source/vcl/canvashelper_texturefill.cxx
index 462ae479fd41..8f76a08d80a2 100644
--- a/canvas/source/vcl/canvashelper_texturefill.cxx
+++ b/canvas/source/vcl/canvashelper_texturefill.cxx
@@ -523,9 +523,9 @@ namespace vclcanvas
 
         int numColorSteps( const ::Color& rColor1, const ::Color& rColor2 )
         {
-            return ::std::max(
+            return std::max(
                 labs( rColor1.GetRed() - rColor2.GetRed() ),
-                ::std::max(
+                std::max(
                     labs( rColor1.GetGreen() - rColor2.GetGreen() ),
                     labs( rColor1.GetBlue()  - rColor2.GetBlue() ) ) );
         }
diff --git a/canvas/source/vcl/spritecanvashelper.cxx b/canvas/source/vcl/spritecanvashelper.cxx
index 775e53872990..b8ea28bad033 100644
--- a/canvas/source/vcl/spritecanvashelper.cxx
+++ b/canvas/source/vcl/spritecanvashelper.cxx
@@ -354,7 +354,7 @@ namespace vclcanvas
             ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) );
         ::basegfx::B2IPoint aDestPos( rDestRect.getMinimum() );
 
-        ::std::vector< ::basegfx::B2IRange > aUnscrollableAreas;
+        std::vector< ::basegfx::B2IRange > aUnscrollableAreas;
 
         // Since strictly speaking, this scroll algorithm is plain
         // buggy, the scrolled area might actually lie _below_ another
@@ -415,7 +415,7 @@ namespace vclcanvas
         // repaint uncovered areas from backbuffer - take the
         // _rounded_ rectangles from above, to have the update
         // consistent with the scroll above.
-        ::std::vector< ::basegfx::B2DRange > aUncoveredAreas;
+        std::vector< ::basegfx::B2DRange > aUncoveredAreas;
         ::basegfx::computeSetDifference( aUncoveredAreas,
                                          rUpdateArea.maTotalBounds,
                                          ::basegfx::B2DRange( rDestRect ) );
@@ -425,7 +425,7 @@ namespace vclcanvas
     }
 
     void SpriteCanvasHelper::opaqueUpdate( SAL_UNUSED_PARAMETER const ::basegfx::B2DRange&,
-                                           const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
+                                           const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
     {
         ENSURE_OR_THROW( mpOwningSpriteCanvas &&
                          mpOwningSpriteCanvas->getBackBuffer() &&
@@ -452,7 +452,7 @@ namespace vclcanvas
     }
 
     void SpriteCanvasHelper::genericUpdate( const ::basegfx::B2DRange&                          rRequestedArea,
-                                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
+                                            const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
     {
         ENSURE_OR_THROW( mpOwningSpriteCanvas &&
                          mpOwningSpriteCanvas->getBackBuffer() &&
@@ -471,20 +471,20 @@ namespace vclcanvas
         // otherwise, truncation of size below might leave visible
         // areas uncovered by VDev.
         const ::Point aOutputPosition(
-            ::std::max( sal_Int32( 0 ),
+            std::max( sal_Int32( 0 ),
                         static_cast< sal_Int32 >(rRequestedArea.getMinX()) ),
-            ::std::max( sal_Int32( 0 ),
+            std::max( sal_Int32( 0 ),
                         static_cast< sal_Int32 >(rRequestedArea.getMinY()) ) );
         // round output size towards +infty. Don't want to truncate a
         // fraction of a sprite pixel... Limit coverage of VDev to
         // output device's area (i.e. not only to total size, but to
         // cover _only_ the visible parts).
         const ::Size aOutputSize(
-            ::std::max( sal_Int32( 0 ),
-                        ::std::min( static_cast< sal_Int32 >(rTargetSizePixel.Width() - aOutputPosition.X()),
+            std::max( sal_Int32( 0 ),
+                        std::min( static_cast< sal_Int32 >(rTargetSizePixel.Width() - aOutputPosition.X()),
                                     ::canvas::tools::roundUp( rRequestedArea.getMaxX() - aOutputPosition.X() ))),
-            ::std::max( sal_Int32( 0 ),
-                        ::std::min( static_cast< sal_Int32 >(rTargetSizePixel.Height() - aOutputPosition.Y()),
+            std::max( sal_Int32( 0 ),
+                        std::min( static_cast< sal_Int32 >(rTargetSizePixel.Height() - aOutputPosition.Y()),
                                     ::canvas::tools::roundUp( rRequestedArea.getMaxY() - aOutputPosition.Y() ))));
 
         // early exit for empty output area.
diff --git a/canvas/source/vcl/spritecanvashelper.hxx b/canvas/source/vcl/spritecanvashelper.hxx
index 6c4631696113..d2186da26dda 100644
--- a/canvas/source/vcl/spritecanvashelper.hxx
+++ b/canvas/source/vcl/spritecanvashelper.hxx
@@ -113,10 +113,10 @@ namespace vclcanvas
                            const ::canvas::SpriteRedrawManager::UpdateArea&     rUpdateArea );
 
         void opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                           const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+                           const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
 
         void genericUpdate( const ::basegfx::B2DRange&                          rTotalArea,
-                            const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+                            const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
 
         css::uno::Any isUnsafeScrolling() const
         {
diff --git a/canvas/source/vcl/textlayout.cxx b/canvas/source/vcl/textlayout.cxx
index bdab9f9a6fab..98f5f43d7bf1 100644
--- a/canvas/source/vcl/textlayout.cxx
+++ b/canvas/source/vcl/textlayout.cxx
@@ -119,7 +119,7 @@ namespace vclcanvas
             uno::Sequence<double>(4),
             rendering::CompositeOperation::SOURCE);
 
-        ::std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
+        std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
         setupTextOffsets(aOffsets.get(), maLogicalAdvancements, aViewState, aRenderState);
 
         std::vector< uno::Reference< rendering::XPolyPolygon2D> > aOutlineSequence;
@@ -171,7 +171,7 @@ namespace vclcanvas
             uno::Sequence<double>(4),
             rendering::CompositeOperation::SOURCE);
 
-        ::std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
+        std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
         setupTextOffsets(aOffsets.get(), maLogicalAdvancements, aViewState, aRenderState);
 
         MetricVector aMetricVector;
@@ -365,7 +365,7 @@ namespace vclcanvas
         if( maLogicalAdvancements.getLength() )
         {
             // TODO(P2): cache that
-            ::std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
+            std::unique_ptr< long []> aOffsets(new long[maLogicalAdvancements.getLength()]);
             setupTextOffsets( aOffsets.get(), maLogicalAdvancements, viewState, renderState );
 
             // TODO(F3): ensure correct length and termination for DX
@@ -435,7 +435,7 @@ namespace vclcanvas
                                                      renderState);
 
         // fill integer offsets
-        ::std::transform( inputOffsets.getConstArray(),
+        std::transform( inputOffsets.getConstArray(),
                           inputOffsets.getConstArray()+inputOffsets.getLength(),
                           outputOffsets,
                           OffsetTransformer( aMatrix ) );