boost::foo_ptr->std::foo_ptr

Change-Id: I9219619b538b6530a89f5932ac51eb3b62eb396a

8 files changed, 104 insertions, 107 deletions

diff --git a/vcl/unx/generic/app/sm.cxx b/vcl/unx/generic/app/sm.cxx
index 65522c6a41c9..782cc9063b3a 100644
--- a/vcl/unx/generic/app/sm.cxx
+++ b/vcl/unx/generic/app/sm.cxx
@@ -141,8 +141,8 @@ public:
 };
 
 SalSession * SessionManagerClient::m_pSession = NULL;
-boost::scoped_ptr< ICEConnectionObserver >
-SessionManagerClient::m_pICEConnectionObserver;
+std::unique_ptr< ICEConnectionObserver >
+SessionManagerClient::m_xICEConnectionObserver;
 SmcConn SessionManagerClient::m_pSmcConnection = NULL;
 OString SessionManagerClient::m_aClientID;
 bool SessionManagerClient::m_bDocSaveDone = false; // HACK
@@ -403,8 +403,8 @@ void SessionManagerClient::saveDone()
 {
     if( m_pSmcConnection )
     {
-        assert(m_pICEConnectionObserver);
-        osl::MutexGuard g(m_pICEConnectionObserver->m_ICEMutex);
+        assert(m_xICEConnectionObserver);
+        osl::MutexGuard g(m_xICEConnectionObserver->m_ICEMutex);
         SmcSetProperties( m_pSmcConnection, nSmProps, ppSmProps );
         SmcSaveYourselfDone( m_pSmcConnection, True );
         SAL_INFO("vcl.sm", "sent SaveYourselfDone SmRestartHint of " << *pSmRestartHint );
@@ -414,17 +414,17 @@ void SessionManagerClient::saveDone()
 
 void SessionManagerClient::open(SalSession * pSession)
 {
-    assert(!m_pSession && !m_pICEConnectionObserver && !m_pSmcConnection);
+    assert(!m_pSession && !m_xICEConnectionObserver && !m_pSmcConnection);
         // must only be called once
     m_pSession = pSession;
     // This is the way Xt does it, so we can too:
     if( getenv( "SESSION_MANAGER" ) )
     {
-        m_pICEConnectionObserver.reset(new ICEConnectionObserver);
-        m_pICEConnectionObserver->activate();
+        m_xICEConnectionObserver.reset(new ICEConnectionObserver);
+        m_xICEConnectionObserver->activate();
 
         {
-            osl::MutexGuard g(m_pICEConnectionObserver->m_ICEMutex);
+            osl::MutexGuard g(m_xICEConnectionObserver->m_ICEMutex);
 
             static SmcCallbacks aCallbacks; // does this need to be static?
             aCallbacks.save_yourself.callback           = SaveYourselfProc;
@@ -489,15 +489,15 @@ void SessionManagerClient::close()
 {
     if( m_pSmcConnection )
     {
-        assert(m_pICEConnectionObserver);
+        assert(m_xICEConnectionObserver);
         {
-            osl::MutexGuard g(m_pICEConnectionObserver->m_ICEMutex);
+            osl::MutexGuard g(m_xICEConnectionObserver->m_ICEMutex);
             SAL_INFO("vcl.sm", "attempting SmcCloseConnection");
             SmcCloseConnection( m_pSmcConnection, 0, NULL );
             SAL_INFO("vcl.sm", "SmcConnection closed");
         }
-        m_pICEConnectionObserver->deactivate();
-        m_pICEConnectionObserver.reset();
+        m_xICEConnectionObserver->deactivate();
+        m_xICEConnectionObserver.reset();
         m_pSmcConnection = NULL;
     }
 }
@@ -507,8 +507,8 @@ bool SessionManagerClient::queryInteraction()
     bool bRet = false;
     if( m_pSmcConnection )
     {
-        assert(m_pICEConnectionObserver);
-        osl::MutexGuard g(m_pICEConnectionObserver->m_ICEMutex);
+        assert(m_xICEConnectionObserver);
+        osl::MutexGuard g(m_xICEConnectionObserver->m_ICEMutex);
         if( SmcInteractRequest( m_pSmcConnection, SmDialogNormal, InteractProc, NULL ) )
             bRet = true;
     }
@@ -519,8 +519,8 @@ void SessionManagerClient::interactionDone( bool bCancelShutdown )
 {
     if( m_pSmcConnection )
     {
-        assert(m_pICEConnectionObserver);
-        osl::MutexGuard g(m_pICEConnectionObserver->m_ICEMutex);
+        assert(m_xICEConnectionObserver);
+        osl::MutexGuard g(m_xICEConnectionObserver->m_ICEMutex);
         SmcInteractDone( m_pSmcConnection, bCancelShutdown ? True : False );
     }
 }
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index 17a9a10a57f7..07f8efc7eefa 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -641,12 +641,12 @@ void X11SalGraphicsImpl::copyBits( const SalTwoRect& rPosAry,
         // #i60699# No chance to handle graphics exposures - we copy
         // to a temp bitmap first, into which no repaints are
         // technically possible.
-        boost::scoped_ptr<SalBitmap> pDDB(pSrcGraphics->getBitmap( rPosAry.mnSrcX,
+        std::unique_ptr<SalBitmap> xDDB(pSrcGraphics->getBitmap( rPosAry.mnSrcX,
                                                                    rPosAry.mnSrcY,
                                                                    rPosAry.mnSrcWidth,
                                                                    rPosAry.mnSrcHeight ));
 
-        if( !pDDB )
+        if( !xDDB )
         {
             stderr0( "SalGraphics::CopyBits !pSrcGraphics->GetBitmap()\n" );
             return;
@@ -655,7 +655,7 @@ void X11SalGraphicsImpl::copyBits( const SalTwoRect& rPosAry,
         SalTwoRect aPosAry( rPosAry );
 
         aPosAry.mnSrcX = 0, aPosAry.mnSrcY = 0;
-        drawBitmap( aPosAry, *pDDB );
+        drawBitmap( aPosAry, *xDDB );
     }
     else {
         stderr0( "X11SalGraphicsImpl::CopyBits from Printer not yet implemented\n" );
diff --git a/vcl/unx/generic/gdi/salbmp.cxx b/vcl/unx/generic/gdi/salbmp.cxx
index 8a38b1bfba6c..45f0a9cd1637 100644
--- a/vcl/unx/generic/gdi/salbmp.cxx
+++ b/vcl/unx/generic/gdi/salbmp.cxx
@@ -50,7 +50,7 @@
 #include <valgrind/memcheck.h>
 #endif
 
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 // - SalBitmap -
 
@@ -414,8 +414,8 @@ XImage* X11SalBitmap::ImplCreateXImage(
         {
             BitmapBuffer*   pDstBuf;
             sal_uLong           nDstFormat = BMP_FORMAT_TOP_DOWN;
-            boost::scoped_ptr<BitmapPalette> pPal;
-            boost::scoped_ptr<ColorMask> pMask;
+            std::unique_ptr<BitmapPalette> xPal;
+            std::unique_ptr<ColorMask> xMask;
 
             switch( pImage->bits_per_pixel )
             {
@@ -454,7 +454,7 @@ XImage* X11SalBitmap::ImplCreateXImage(
 
                     #endif
 
-                    pMask.reset(new ColorMask( pImage->red_mask, pImage->green_mask, pImage->blue_mask ));
+                    xMask.reset(new ColorMask( pImage->red_mask, pImage->green_mask, pImage->blue_mask ));
                 }
                 break;
 
@@ -485,17 +485,17 @@ XImage* X11SalBitmap::ImplCreateXImage(
 
             if( pImage->depth == 1 )
             {
-                pPal.reset(new BitmapPalette( 2 ));
-                (*pPal)[ 0 ] = Color( COL_BLACK );
-                (*pPal)[ 1 ] = Color( COL_WHITE );
+                xPal.reset(new BitmapPalette( 2 ));
+                (*xPal)[ 0 ] = Color( COL_BLACK );
+                (*xPal)[ 1 ] = Color( COL_WHITE );
             }
             else if( pImage->depth == 8 && mbGrey )
             {
-                pPal.reset(new BitmapPalette( 256 ));
+                xPal.reset(new BitmapPalette( 256 ));
 
                 for( sal_uInt16 i = 0; i < 256; i++ )
                 {
-                    BitmapColor&    rBmpCol = (*pPal)[ i ];
+                    BitmapColor&    rBmpCol = (*xPal)[ i ];
 
                     rBmpCol.SetRed( i );
                     rBmpCol.SetGreen( i );
@@ -510,12 +510,12 @@ XImage* X11SalBitmap::ImplCreateXImage(
                                             , (sal_uLong)(1 << pImage->depth)
                                             );
 
-                pPal.reset(new BitmapPalette( nCols ));
+                xPal.reset(new BitmapPalette( nCols ));
 
                 for( sal_uInt16 i = 0; i < nCols; i++ )
                 {
                     const SalColor  nColor( rColMap.GetColor( i ) );
-                    BitmapColor&    rBmpCol = (*pPal)[ i ];
+                    BitmapColor&    rBmpCol = (*xPal)[ i ];
 
                     rBmpCol.SetRed( SALCOLOR_RED( nColor ) );
                     rBmpCol.SetGreen( SALCOLOR_GREEN( nColor ) );
@@ -523,9 +523,9 @@ XImage* X11SalBitmap::ImplCreateXImage(
                 }
             }
 
-            pDstBuf = StretchAndConvert( *mpDIB, rTwoRect, nDstFormat, pPal.get(), pMask.get() );
-            pPal.reset();
-            pMask.reset();
+            pDstBuf = StretchAndConvert( *mpDIB, rTwoRect, nDstFormat, xPal.get(), xMask.get() );
+            xPal.reset();
+            xMask.reset();
 
             if( pDstBuf && pDstBuf->mpBits )
             {
diff --git a/vcl/unx/generic/gdi/salgdi.cxx b/vcl/unx/generic/gdi/salgdi.cxx
index 673e5cf1a5af..8bd40736e3ec 100644
--- a/vcl/unx/generic/gdi/salgdi.cxx
+++ b/vcl/unx/generic/gdi/salgdi.cxx
@@ -85,13 +85,13 @@ X11SalGraphics::X11SalGraphics():
 {
     if (OpenGLHelper::isVCLOpenGLEnabled())
     {
-        mpImpl.reset(new X11OpenGLSalGraphicsImpl(*this));
-        mpTextRenderImpl.reset((new OpenGLX11CairoTextRender(false, *this)));
+        mxImpl.reset(new X11OpenGLSalGraphicsImpl(*this));
+        mxTextRenderImpl.reset((new OpenGLX11CairoTextRender(false, *this)));
     }
     else
     {
-        mpTextRenderImpl.reset((new X11CairoTextRender(false, *this)));
-        mpImpl.reset(new X11SalGraphicsImpl(*this));
+        mxTextRenderImpl.reset((new X11CairoTextRender(false, *this)));
+        mxImpl.reset(new X11SalGraphicsImpl(*this));
     }
 
 }
@@ -109,7 +109,7 @@ void X11SalGraphics::freeResources()
     DBG_ASSERT( !pPaintRegion_, "pPaintRegion_" );
     if( mpClipRegion ) XDestroyRegion( mpClipRegion ), mpClipRegion = None;
 
-    mpImpl->freeResources();
+    mxImpl->freeResources();
 
     if( hBrush_ )       XFreePixmap( pDisplay, hBrush_ ), hBrush_ = None;
     if( pFontGC_ ) XFreeGC( pDisplay, pFontGC_ ), pFontGC_ = None;
@@ -124,7 +124,7 @@ void X11SalGraphics::freeResources()
 
 SalGraphicsImpl* X11SalGraphics::GetImpl() const
 {
-    return mpImpl.get();
+    return mxImpl.get();
 }
 
 void X11SalGraphics::SetDrawable( Drawable aDrawable, SalX11Screen nXScreen )
@@ -165,7 +165,7 @@ void X11SalGraphics::Init( SalFrame *pFrame, Drawable aTarget,
     bVirDev_    = false;
 
     SetDrawable( aTarget, nXScreen );
-    mpImpl->Init();
+    mxImpl->Init();
 }
 
 void X11SalGraphics::DeInit()
@@ -314,123 +314,123 @@ void X11SalGraphics::GetResolution( sal_Int32 &rDPIX, sal_Int32 &rDPIY ) // cons
 
 sal_uInt16 X11SalGraphics::GetBitCount() const
 {
-    return mpImpl->GetBitCount();
+    return mxImpl->GetBitCount();
 }
 
 long X11SalGraphics::GetGraphicsWidth() const
 {
-    return mpImpl->GetGraphicsWidth();
+    return mxImpl->GetGraphicsWidth();
 }
 
 void X11SalGraphics::ResetClipRegion()
 {
-    mpImpl->ResetClipRegion();
+    mxImpl->ResetClipRegion();
 }
 
 bool X11SalGraphics::setClipRegion( const vcl::Region& i_rClip )
 {
-    return mpImpl->setClipRegion( i_rClip );
+    return mxImpl->setClipRegion( i_rClip );
 }
 
 void X11SalGraphics::SetLineColor()
 {
-    mpImpl->SetLineColor();
+    mxImpl->SetLineColor();
 }
 
 void X11SalGraphics::SetLineColor( SalColor nSalColor )
 {
-    mpImpl->SetLineColor( nSalColor );
+    mxImpl->SetLineColor( nSalColor );
 }
 
 void X11SalGraphics::SetFillColor()
 {
-    mpImpl->SetFillColor();
+    mxImpl->SetFillColor();
 }
 
 void X11SalGraphics::SetFillColor( SalColor nSalColor )
 {
-    mpImpl->SetFillColor( nSalColor );
+    mxImpl->SetFillColor( nSalColor );
 }
 
 void X11SalGraphics::SetROPLineColor( SalROPColor nROPColor )
 {
-    mpImpl->SetROPLineColor( nROPColor );
+    mxImpl->SetROPLineColor( nROPColor );
 }
 
 void X11SalGraphics::SetROPFillColor( SalROPColor nROPColor )
 {
-    mpImpl->SetROPFillColor( nROPColor );
+    mxImpl->SetROPFillColor( nROPColor );
 }
 
 void X11SalGraphics::SetXORMode( bool bSet, bool bInvertOnly )
 {
-    mpImpl->SetXORMode( bSet, bInvertOnly );
+    mxImpl->SetXORMode( bSet, bInvertOnly );
 }
 
 void X11SalGraphics::drawPixel( long nX, long nY )
 {
-    mpImpl->drawPixel( nX, nY );
+    mxImpl->drawPixel( nX, nY );
 }
 
 void X11SalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
 {
-    mpImpl->drawPixel( nX, nY, nSalColor );
+    mxImpl->drawPixel( nX, nY, nSalColor );
 }
 
 void X11SalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
 {
-    mpImpl->drawLine( nX1, nY1, nX2, nY2 );
+    mxImpl->drawLine( nX1, nY1, nX2, nY2 );
 }
 
 void X11SalGraphics::drawRect( long nX, long nY, long nDX, long nDY )
 {
-    mpImpl->drawRect( nX, nY, nDX, nDY );
+    mxImpl->drawRect( nX, nY, nDX, nDY );
 }
 
 void X11SalGraphics::drawPolyLine( sal_uInt32 nPoints, const SalPoint *pPtAry )
 {
-    mpImpl->drawPolyLine( nPoints, pPtAry );
+    mxImpl->drawPolyLine( nPoints, pPtAry );
 }
 
 void X11SalGraphics::drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry )
 {
-    mpImpl->drawPolygon( nPoints, pPtAry );
+    mxImpl->drawPolygon( nPoints, pPtAry );
 }
 
 void X11SalGraphics::drawPolyPolygon( sal_uInt32 nPoly,
                                    const sal_uInt32    *pPoints,
                                    PCONSTSALPOINT  *pPtAry )
 {
-    mpImpl->drawPolyPolygon( nPoly, pPoints, pPtAry );
+    mxImpl->drawPolyPolygon( nPoly, pPoints, pPtAry );
 }
 
 bool X11SalGraphics::drawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry )
 {
-    return mpImpl->drawPolyLineBezier( nPoints, pPtAry, pFlgAry );
+    return mxImpl->drawPolyLineBezier( nPoints, pPtAry, pFlgAry );
 }
 
 bool X11SalGraphics::drawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry )
 {
-    return mpImpl->drawPolygonBezier( nPoints, pPtAry, pFlgAry );
+    return mxImpl->drawPolygonBezier( nPoints, pPtAry, pFlgAry );
 }
 
 bool X11SalGraphics::drawPolyPolygonBezier( sal_uInt32 nPoints, const sal_uInt32* pPoints,
                                                 const SalPoint* const* pPtAry, const sal_uInt8* const* pFlgAry)
 {
-    return mpImpl->drawPolyPolygonBezier( nPoints, pPoints, pPtAry, pFlgAry );
+    return mxImpl->drawPolyPolygonBezier( nPoints, pPoints, pPtAry, pFlgAry );
 }
 
 void X11SalGraphics::invert( sal_uInt32 nPoints,
                              const SalPoint* pPtAry,
                              SalInvert nFlags )
 {
-    mpImpl->invert( nPoints, pPtAry, nFlags );
+    mxImpl->invert( nPoints, pPtAry, nFlags );
 }
 
 bool X11SalGraphics::drawEPS( long nX, long nY, long nWidth,
         long nHeight, void* pPtr, sal_uLong nSize )
 {
-    return mpImpl->drawEPS( nX, nY, nWidth, nHeight, pPtr, nSize );
+    return mxImpl->drawEPS( nX, nY, nWidth, nHeight, pPtr, nSize );
 }
 
 XRenderPictFormat* X11SalGraphics::GetXRenderFormat() const
@@ -458,7 +458,7 @@ SystemGraphicsData X11SalGraphics::GetGraphicsData() const
 // draw a poly-polygon
 bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency )
 {
-    return mpImpl->drawPolyPolygon( rOrigPolyPoly, fTransparency );
+    return mxImpl->drawPolyPolygon( rOrigPolyPoly, fTransparency );
 }
 
 bool X11SalGraphics::drawPolyLine(
@@ -468,23 +468,23 @@ bool X11SalGraphics::drawPolyLine(
     basegfx::B2DLineJoin eLineJoin,
     com::sun::star::drawing::LineCap eLineCap)
 {
-    return mpImpl->drawPolyLine( rPolygon, fTransparency, rLineWidth,
+    return mxImpl->drawPolyLine( rPolygon, fTransparency, rLineWidth,
             eLineJoin, eLineCap );
 }
 
 bool X11SalGraphics::drawGradient(const tools::PolyPolygon& rPoly, const Gradient& rGradient)
 {
-    return mpImpl->drawGradient(rPoly, rGradient);
+    return mxImpl->drawGradient(rPoly, rGradient);
 }
 
 void X11SalGraphics::BeginPaint()
 {
-    return mpImpl->beginPaint();
+    return mxImpl->beginPaint();
 }
 
 void X11SalGraphics::EndPaint()
 {
-    return mpImpl->endPaint();
+    return mxImpl->endPaint();
 }
 
 SalGeometryProvider *X11SalGraphics::GetGeometryProvider() const
diff --git a/vcl/unx/generic/gdi/salgdi2.cxx b/vcl/unx/generic/gdi/salgdi2.cxx
index bd9238001468..850b2a84ee41 100644
--- a/vcl/unx/generic/gdi/salgdi2.cxx
+++ b/vcl/unx/generic/gdi/salgdi2.cxx
@@ -39,7 +39,6 @@
 
 #include "vcl/bmpacc.hxx"
 #include <outdata.hxx>
-#include <boost/scoped_ptr.hpp>
 
 void X11SalGraphics::CopyScreenArea( Display* pDisplay,
                                      Drawable aSrc, SalX11Screen nXScreenSrc, int nSrcDepth,
@@ -80,14 +79,14 @@ void X11SalGraphics::CopyScreenArea( Display* pDisplay,
 
 bool X11SalGraphics::FillPixmapFromScreen( X11Pixmap* pPixmap, int nX, int nY )
 {
-    X11GraphicsImpl& rImpl = dynamic_cast<X11GraphicsImpl&>(*mpImpl.get());
+    X11GraphicsImpl& rImpl = dynamic_cast<X11GraphicsImpl&>(*mxImpl.get());
     return rImpl.FillPixmapFromScreen( pPixmap, nX, nY );
 }
 
 bool X11SalGraphics::RenderPixmapToScreen( X11Pixmap* pPixmap, X11Pixmap* pMask, int nX, int nY )
 {
     SAL_INFO( "vcl", "RenderPixmapToScreen" );
-    X11GraphicsImpl& rImpl = dynamic_cast<X11GraphicsImpl&>(*mpImpl.get());
+    X11GraphicsImpl& rImpl = dynamic_cast<X11GraphicsImpl&>(*mxImpl.get());
     return rImpl.RenderPixmapToScreen( pPixmap, pMask, nX, nY );
 }
 
@@ -151,7 +150,7 @@ void X11SalGraphics::YieldGraphicsExpose()
 void X11SalGraphics::copyBits( const SalTwoRect& rPosAry,
                                   SalGraphics      *pSSrcGraphics )
 {
-    mpImpl->copyBits( rPosAry, pSSrcGraphics );
+    mxImpl->copyBits( rPosAry, pSSrcGraphics );
 }
 
 void X11SalGraphics::copyArea ( long nDestX,    long nDestY,
@@ -159,13 +158,13 @@ void X11SalGraphics::copyArea ( long nDestX,    long nDestY,
                                 long nSrcWidth, long nSrcHeight,
                                 sal_uInt16 n )
 {
-    mpImpl->copyArea( nDestX, nDestY, nSrcX, nSrcY, nSrcWidth, nSrcHeight, n );
+    mxImpl->copyArea( nDestX, nDestY, nSrcX, nSrcY, nSrcWidth, nSrcHeight, n );
 }
 
 bool X11SalGraphics::blendBitmap( const SalTwoRect& rTR,
                                   const SalBitmap& rBitmap )
 {
-    return mpImpl->blendBitmap( rTR, rBitmap );
+    return mxImpl->blendBitmap( rTR, rBitmap );
 }
 
 bool X11SalGraphics::blendAlphaBitmap( const SalTwoRect& rTR,
@@ -173,31 +172,31 @@ bool X11SalGraphics::blendAlphaBitmap( const SalTwoRect& rTR,
                                        const SalBitmap& rMaskBitmap,
                                        const SalBitmap& rAlphaBitmap )
 {
-    return mpImpl->blendAlphaBitmap( rTR, rSrcBitmap, rMaskBitmap, rAlphaBitmap );
+    return mxImpl->blendAlphaBitmap( rTR, rSrcBitmap, rMaskBitmap, rAlphaBitmap );
 }
 
 void X11SalGraphics::drawBitmap( const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap )
 {
-    mpImpl->drawBitmap( rPosAry, rSalBitmap );
+    mxImpl->drawBitmap( rPosAry, rSalBitmap );
 }
 
 void X11SalGraphics::drawBitmap( const SalTwoRect& rPosAry,
                                  const SalBitmap& rSrcBitmap,
                                  const SalBitmap& rMaskBitmap )
 {
-    mpImpl->drawBitmap( rPosAry, rSrcBitmap, rMaskBitmap );
+    mxImpl->drawBitmap( rPosAry, rSrcBitmap, rMaskBitmap );
 }
 
 bool X11SalGraphics::drawAlphaBitmap( const SalTwoRect& rTR,
     const SalBitmap& rSrcBitmap, const SalBitmap& rAlphaBmp )
 {
-    return mpImpl->drawAlphaBitmap( rTR, rSrcBitmap, rAlphaBmp );
+    return mxImpl->drawAlphaBitmap( rTR, rSrcBitmap, rAlphaBmp );
 }
 
 bool X11SalGraphics::drawAlphaBitmap( const SalTwoRect& rTR,
                                       const SalBitmap& rBitmap )
 {
-    return mpImpl->drawAlphaBitmap( rTR, rBitmap );
+    return mxImpl->drawAlphaBitmap( rTR, rBitmap );
 }
 
 bool X11SalGraphics::drawTransformedBitmap(
@@ -207,37 +206,37 @@ bool X11SalGraphics::drawTransformedBitmap(
     const SalBitmap& rSourceBitmap,
     const SalBitmap* pAlphaBitmap)
 {
-    return mpImpl->drawTransformedBitmap( rNull, rX, rY, rSourceBitmap, pAlphaBitmap );
+    return mxImpl->drawTransformedBitmap( rNull, rX, rY, rSourceBitmap, pAlphaBitmap );
 }
 
 bool X11SalGraphics::drawAlphaRect( long nX, long nY, long nWidth,
                                     long nHeight, sal_uInt8 nTransparency )
 {
-    return mpImpl->drawAlphaRect( nX, nY, nWidth, nHeight, nTransparency );
+    return mxImpl->drawAlphaRect( nX, nY, nWidth, nHeight, nTransparency );
 }
 
 void X11SalGraphics::drawBitmap( const SalTwoRect& rRect,
                                  const SalBitmap& rBitmap,
                                  SalColor nColor )
 {
-    mpImpl->drawBitmap( rRect, rBitmap, nColor );
+    mxImpl->drawBitmap( rRect, rBitmap, nColor );
 }
 
 void X11SalGraphics::drawMask( const SalTwoRect& rPosAry,
                                const SalBitmap &rSalBitmap,
                                SalColor nMaskColor )
 {
-    mpImpl->drawMask( rPosAry, rSalBitmap, nMaskColor );
+    mxImpl->drawMask( rPosAry, rSalBitmap, nMaskColor );
 }
 
 SalBitmap *X11SalGraphics::getBitmap( long nX, long nY, long nDX, long nDY )
 {
-    return mpImpl->getBitmap( nX, nY, nDX, nDY );
+    return mxImpl->getBitmap( nX, nY, nDX, nDY );
 }
 
 SalColor X11SalGraphics::getPixel( long nX, long nY )
 {
-    return mpImpl->getPixel( nX, nY );
+    return mxImpl->getPixel( nX, nY );
 }
 
 void X11SalGraphics::invert( long       nX,
@@ -246,7 +245,7 @@ void X11SalGraphics::invert( long       nX,
                                 long        nDY,
                                 SalInvert   nFlags )
 {
-    mpImpl->invert( nX, nY, nDX, nDY, nFlags );
+    mxImpl->invert( nX, nY, nDX, nDY, nFlags );
 }
 
 bool X11SalGraphics::supportsOperation( OutDevSupportType eType ) const
diff --git a/vcl/unx/generic/gdi/salgdi3.cxx b/vcl/unx/generic/gdi/salgdi3.cxx
index 622f77860e66..53afb0107aec 100644
--- a/vcl/unx/generic/gdi/salgdi3.cxx
+++ b/vcl/unx/generic/gdi/salgdi3.cxx
@@ -91,30 +91,30 @@ X11SalGraphics::GetFontGC()
 
 void X11SalGraphics::DrawServerFontLayout( const ServerFontLayout& rLayout )
 {
-    mpTextRenderImpl->DrawServerFontLayout(rLayout);
+    mxTextRenderImpl->DrawServerFontLayout(rLayout);
 }
 
 const FontCharMapPtr X11SalGraphics::GetFontCharMap() const
 {
-    return mpTextRenderImpl->GetFontCharMap();
+    return mxTextRenderImpl->GetFontCharMap();
 }
 
 bool X11SalGraphics::GetFontCapabilities(vcl::FontCapabilities &rGetImplFontCapabilities) const
 {
-    return mpTextRenderImpl->GetFontCapabilities(rGetImplFontCapabilities);
+    return mxTextRenderImpl->GetFontCapabilities(rGetImplFontCapabilities);
 }
 
 // SalGraphics
 
 sal_uInt16 X11SalGraphics::SetFont( FontSelectPattern *pEntry, int nFallbackLevel )
 {
-    return mpTextRenderImpl->SetFont(pEntry, nFallbackLevel);
+    return mxTextRenderImpl->SetFont(pEntry, nFallbackLevel);
 }
 
 void
 X11SalGraphics::SetTextColor( SalColor nSalColor )
 {
-    mpTextRenderImpl->SetTextColor(nSalColor);
+    mxTextRenderImpl->SetTextColor(nSalColor);
     nTextPixel_     = GetPixel( nSalColor );
     bFontGC_        = false;
 }
@@ -123,44 +123,44 @@ bool X11SalGraphics::AddTempDevFont( PhysicalFontCollection* pFontCollection,
                                      const OUString& rFileURL,
                                      const OUString& rFontName )
 {
-    return mpTextRenderImpl->AddTempDevFont(pFontCollection, rFileURL, rFontName);
+    return mxTextRenderImpl->AddTempDevFont(pFontCollection, rFileURL, rFontName);
 }
 
 void X11SalGraphics::ClearDevFontCache()
 {
-    mpTextRenderImpl->ClearDevFontCache();
+    mxTextRenderImpl->ClearDevFontCache();
 }
 
 void X11SalGraphics::GetDevFontList( PhysicalFontCollection* pFontCollection )
 {
-    mpTextRenderImpl->GetDevFontList(pFontCollection);
+    mxTextRenderImpl->GetDevFontList(pFontCollection);
 }
 
 void
 X11SalGraphics::GetFontMetric( ImplFontMetricData *pMetric, int nFallbackLevel )
 {
-    mpTextRenderImpl->GetFontMetric(pMetric, nFallbackLevel);
+    mxTextRenderImpl->GetFontMetric(pMetric, nFallbackLevel);
 }
 
 bool X11SalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
 {
-    return mpTextRenderImpl->GetGlyphBoundRect(aGlyphId, rRect);
+    return mxTextRenderImpl->GetGlyphBoundRect(aGlyphId, rRect);
 }
 
 bool X11SalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId,
     ::basegfx::B2DPolyPolygon& rPolyPoly )
 {
-    return mpTextRenderImpl->GetGlyphOutline(aGlyphId, rPolyPoly);
+    return mxTextRenderImpl->GetGlyphOutline(aGlyphId, rPolyPoly);
 }
 
 SalLayout* X11SalGraphics::GetTextLayout( ImplLayoutArgs& rArgs, int nFallbackLevel )
 {
-    return mpTextRenderImpl->GetTextLayout(rArgs, nFallbackLevel);
+    return mxTextRenderImpl->GetTextLayout(rArgs, nFallbackLevel);
 }
 
 SystemFontData X11SalGraphics::GetSysFontData( int nFallbackLevel ) const
 {
-    return mpTextRenderImpl->GetSysFontData(nFallbackLevel);
+    return mxTextRenderImpl->GetSysFontData(nFallbackLevel);
 }
 
 bool X11SalGraphics::CreateFontSubset(
@@ -173,23 +173,23 @@ bool X11SalGraphics::CreateFontSubset(
                                    FontSubsetInfo& rInfo
                                    )
 {
-    return mpTextRenderImpl->CreateFontSubset(rToFile, pFont,
+    return mxTextRenderImpl->CreateFontSubset(rToFile, pFont,
             pGlyphIds, pEncoding, pWidths, nGlyphCount, rInfo);
 }
 
 const void* X11SalGraphics::GetEmbedFontData( const PhysicalFontFace* pFont, const sal_Ucs* pUnicodes, sal_Int32* pWidths, size_t nLen, FontSubsetInfo& rInfo, long* pDataLen )
 {
-    return mpTextRenderImpl->GetEmbedFontData(pFont, pUnicodes, pWidths, nLen, rInfo, pDataLen);
+    return mxTextRenderImpl->GetEmbedFontData(pFont, pUnicodes, pWidths, nLen, rInfo, pDataLen);
 }
 
 void X11SalGraphics::FreeEmbedFontData( const void* pData, long nLen )
 {
-    mpTextRenderImpl->FreeEmbedFontData(pData, nLen);
+    mxTextRenderImpl->FreeEmbedFontData(pData, nLen);
 }
 
 const Ucs2SIntMap* X11SalGraphics::GetFontEncodingVector( const PhysicalFontFace* pFont, const Ucs2OStrMap** pNonEncoded, std::set<sal_Unicode> const** ppPriority)
 {
-    return mpTextRenderImpl->GetFontEncodingVector(pFont, pNonEncoded, ppPriority);
+    return mxTextRenderImpl->GetFontEncodingVector(pFont, pNonEncoded, ppPriority);
 }
 
 void X11SalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
@@ -197,7 +197,7 @@ void X11SalGraphics::GetGlyphWidths( const PhysicalFontFace* pFont,
                                    Int32Vector& rWidths,
                                    Ucs2UIntMap& rUnicodeEnc )
 {
-    mpTextRenderImpl->GetGlyphWidths(pFont, bVertical, rWidths, rUnicodeEnc);
+    mxTextRenderImpl->GetGlyphWidths(pFont, bVertical, rWidths, rUnicodeEnc);
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/unx/generic/gdi/salvd.cxx b/vcl/unx/generic/gdi/salvd.cxx
index 3ec516bd038d..f7d572f374be 100644
--- a/vcl/unx/generic/gdi/salvd.cxx
+++ b/vcl/unx/generic/gdi/salvd.cxx
@@ -78,7 +78,7 @@ void X11SalGraphics::Init( X11SalVirtualDevice *pDevice, SalColormap* pColormap,
 
     const Drawable aVdevDrawable = pDevice->GetDrawable();
     SetDrawable( aVdevDrawable, m_nXScreen );
-    mpImpl->Init();
+    mxImpl->Init();
 }
 
 X11SalVirtualDevice::X11SalVirtualDevice( SalGraphics* pGraphics,
diff --git a/vcl/unx/generic/printer/printerinfomanager.cxx b/vcl/unx/generic/printer/printerinfomanager.cxx
index 51c9c2f3ae75..2690c881bd02 100644
--- a/vcl/unx/generic/printer/printerinfomanager.cxx
+++ b/vcl/unx/generic/printer/printerinfomanager.cxx
@@ -40,8 +40,6 @@
 #include "osl/mutex.hxx"
 #include "osl/process.h"
 
-#include <boost/scoped_ptr.hpp>
-
 // filename of configuration files
 #define PRINT_FILENAME  "psprint.conf"
 // the group of the global defaults