Remove visual noise from canvas

Change-Id: I0f01a4064ab6d1f55647ecdc1a8710e289e5d96c

24 files changed, 182 insertions, 182 deletions

diff --git a/canvas/source/cairo/cairo_spritecanvashelper.hxx b/canvas/source/cairo/cairo_spritecanvashelper.hxx
index b18747e97250..9bec3dfcc294 100644
--- a/canvas/source/cairo/cairo_spritecanvashelper.hxx
+++ b/canvas/source/cairo/cairo_spritecanvashelper.hxx
@@ -88,7 +88,7 @@ namespace cairocanvas
 
 
         // SpriteRedrawManager functor calls
-        // -------------------------------------------------
+
 
         /** Gets called for simple background repaints
          */
diff --git a/canvas/source/cairo/cairo_xlib_cairo.cxx b/canvas/source/cairo/cairo_xlib_cairo.cxx
index bae6943a47bc..f52a8e7be056 100644
--- a/canvas/source/cairo/cairo_xlib_cairo.cxx
+++ b/canvas/source/cairo/cairo_xlib_cairo.cxx
@@ -37,7 +37,7 @@ namespace
     {
         // The X protocol request CreatePixmap puts an upper bound
         // of 16 bit to the size.
-        //
+
         // see, e.g. moz#424333, fdo#48961
         // we've a duplicate of this in vcl :-(
         if (width > SAL_MAX_INT16 || height > SAL_MAX_INT16)
diff --git a/canvas/source/directx/dx_9rm.cxx b/canvas/source/directx/dx_9rm.cxx
index 6323ca42f7d4..aab66832f757 100644
--- a/canvas/source/directx/dx_9rm.cxx
+++ b/canvas/source/directx/dx_9rm.cxx
@@ -73,17 +73,17 @@
 
 using namespace ::com::sun::star;
 
-//////////////////////////////////////////////////////////////////////////////////
+
 // 'dxcanvas' namespace
-//////////////////////////////////////////////////////////////////////////////////
+
 
 namespace dxcanvas
 {
     namespace
     {
-        //////////////////////////////////////////////////////////////////////////////////
+
         // monitorSupport
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         class monitorSupport
         {
@@ -127,9 +127,9 @@ namespace dxcanvas
 
         class DXRenderModule;
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         /** ISurface implemenation.
 
@@ -173,9 +173,9 @@ namespace dxcanvas
         };
 
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         /// Default implementation of IDXRenderModule
         class DXRenderModule : public IDXRenderModule
@@ -256,9 +256,9 @@ namespace dxcanvas
 
         ::osl::Mutex DXRenderModule::maMutex;
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::ImplRenderModuleGuard
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         inline DXSurface::ImplRenderModuleGuard::ImplRenderModuleGuard(
             DXRenderModule& rRenderModule ) :
@@ -296,9 +296,9 @@ namespace dxcanvas
             }
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::DXSurface
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         DXSurface::DXSurface( DXRenderModule&           rRenderModule,
                               const ::basegfx::B2ISize& rSize ) :
@@ -339,9 +339,9 @@ namespace dxcanvas
             maSize = rSize;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::~DXSurface
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         DXSurface::~DXSurface()
         {
@@ -352,9 +352,9 @@ namespace dxcanvas
 #endif
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::selectTexture
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXSurface::selectTexture()
         {
@@ -368,9 +368,9 @@ namespace dxcanvas
             return true;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::isValid
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXSurface::isValid()
         {
@@ -381,9 +381,9 @@ namespace dxcanvas
             return true;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::update
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXSurface::update( const ::basegfx::B2IPoint& rDestPos,
                                 const ::basegfx::B2IRange& rSourceRect,
@@ -545,9 +545,9 @@ namespace dxcanvas
             return true;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXSurface::getSize
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         ::basegfx::B2IVector DXSurface::getSize()
         {
@@ -559,9 +559,9 @@ namespace dxcanvas
             return mpTexture;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::DXRenderModule
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         DXRenderModule::DXRenderModule( const ::Window& rWindow ) :
             mhWnd(0),
@@ -628,18 +628,18 @@ namespace dxcanvas
             mpVertexBuffer=COMReference<IDirect3DVertexBuffer9>(pVB);
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::~DXRenderModule
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         DXRenderModule::~DXRenderModule()
         {
             disposing();
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::disposing
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::disposing()
         {
@@ -656,9 +656,9 @@ namespace dxcanvas
             // objects are dead.
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::create
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXRenderModule::create( const ::Window& rWindow )
         {
@@ -722,9 +722,9 @@ namespace dxcanvas
             return true;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::verifyDevice
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXRenderModule::verifyDevice( const UINT nAdapter )
         {
@@ -778,9 +778,9 @@ namespace dxcanvas
         }
 
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::createDevice
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXRenderModule::createDevice()
         {
@@ -881,9 +881,9 @@ namespace dxcanvas
             return true;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::createSystemMemorySurface
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         COMReference<IDirect3DSurface9> DXRenderModule::createSystemMemorySurface( const ::basegfx::B2IVector& rSize )
         {
@@ -909,9 +909,9 @@ namespace dxcanvas
             return COMReference<IDirect3DSurface9>(pSurface);
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::flip
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXRenderModule::flip( const ::basegfx::B2IRectangle& rUpdateArea,
                                    const ::basegfx::B2IRectangle& /*rCurrWindowArea*/ )
@@ -979,17 +979,17 @@ namespace dxcanvas
             return true;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::screenShot
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::screenShot()
         {
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::resize
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::resize( const ::basegfx::B2IRange& rect )
         {
@@ -1049,9 +1049,9 @@ namespace dxcanvas
             }
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::getPageSize
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         ::basegfx::B2IVector DXRenderModule::getPageSize()
         {
@@ -1060,9 +1060,9 @@ namespace dxcanvas
             return maPageSize;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::createSurface
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         ::canvas::ISurfaceSharedPtr DXRenderModule::createSurface( const ::basegfx::B2IVector& surfaceSize )
         {
@@ -1085,9 +1085,9 @@ namespace dxcanvas
             return ::canvas::ISurfaceSharedPtr( new DXSurface(*this,aSize) );
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::beginPrimitive
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::beginPrimitive( PrimitiveType eType )
         {
@@ -1105,9 +1105,9 @@ namespace dxcanvas
             mnCount=0;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::endPrimitive
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::endPrimitive()
         {
@@ -1122,9 +1122,9 @@ namespace dxcanvas
             mnCount=0;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::pushVertex
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::pushVertex( const ::canvas::Vertex& vertex )
         {
@@ -1170,9 +1170,9 @@ namespace dxcanvas
             }
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::isError
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         bool DXRenderModule::isError()
         {
@@ -1182,9 +1182,9 @@ namespace dxcanvas
             return mbError;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::getAdapterFromWindow
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         UINT DXRenderModule::getAdapterFromWindow()
         {
@@ -1196,9 +1196,9 @@ namespace dxcanvas
             return static_cast<UINT>(-1);
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::commitVertexCache
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::commitVertexCache()
         {
@@ -1224,9 +1224,9 @@ namespace dxcanvas
             }
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXRenderModule::flushVertexCache
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         void DXRenderModule::flushVertexCache()
         {
@@ -1332,9 +1332,9 @@ namespace dxcanvas
         }
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // createRenderModule
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     IDXRenderModuleSharedPtr createRenderModule( const ::Window& rParent )
     {
diff --git a/canvas/source/directx/dx_bitmap.cxx b/canvas/source/directx/dx_bitmap.cxx
index cf9e89e2f9cf..145848eea05a 100644
--- a/canvas/source/directx/dx_bitmap.cxx
+++ b/canvas/source/directx/dx_bitmap.cxx
@@ -40,9 +40,9 @@ using namespace ::com::sun::star;
 
 namespace dxcanvas
 {
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXBitmap::DXBitmap
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     DXBitmap::DXBitmap( const BitmapSharedPtr& rBitmap,
                         bool                   bWithAlpha ) :
diff --git a/canvas/source/directx/dx_canvas.hxx b/canvas/source/directx/dx_canvas.hxx
index fc23d09ca22c..78e63ffef1d6 100644
--- a/canvas/source/directx/dx_canvas.hxx
+++ b/canvas/source/directx/dx_canvas.hxx
@@ -102,7 +102,7 @@ namespace dxcanvas
 
     typedef ::rtl::Reference< Canvas > CanvasRef;
 
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
+
 
     typedef ::cppu::WeakComponentImplHelper7< ::com::sun::star::rendering::XBitmapCanvas,
                                                ::com::sun::star::rendering::XIntegerBitmap,
diff --git a/canvas/source/directx/dx_canvashelper_texturefill.cxx b/canvas/source/directx/dx_canvashelper_texturefill.cxx
index a59e10a71454..40a3a101d0ee 100644
--- a/canvas/source/directx/dx_canvashelper_texturefill.cxx
+++ b/canvas/source/directx/dx_canvashelper_texturefill.cxx
@@ -226,7 +226,7 @@ namespace dxcanvas
                                           1.0) )
             {
                 // KLUDGE 1:
-                //
+
                 // And here comes the greatest shortcoming of the GDI+
                 // gradients ever: SetFocusScales completely ignores
                 // transformations, both when set at the PathGradientBrush
@@ -362,7 +362,7 @@ namespace dxcanvas
             else
             {
                 // KLUDGE 2:
-                //
+
                 // We're generating a PathGradientBrush from scratch here,
                 // and put in a transformed GraphicsPath (transformed with
                 // the texture transform). This is because the
diff --git a/canvas/source/directx/dx_spritecanvashelper.hxx b/canvas/source/directx/dx_spritecanvashelper.hxx
index f11986119c0d..ec764913afd2 100644
--- a/canvas/source/directx/dx_spritecanvashelper.hxx
+++ b/canvas/source/directx/dx_spritecanvashelper.hxx
@@ -92,7 +92,7 @@ namespace dxcanvas
 
 
         // SpriteRedrawManager functor calls
-        // -------------------------------------------------
+
 
         /** Gets called for simple background repaints
          */
diff --git a/canvas/source/directx/dx_surfacebitmap.cxx b/canvas/source/directx/dx_surfacebitmap.cxx
index c45d5af9fa79..e61ad2060135 100644
--- a/canvas/source/directx/dx_surfacebitmap.cxx
+++ b/canvas/source/directx/dx_surfacebitmap.cxx
@@ -44,9 +44,9 @@ namespace dxcanvas
 {
     namespace
     {
-        //////////////////////////////////////////////////////////////////////////////////
+
         // DXColorBuffer
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         struct DXColorBuffer : public canvas::IColorBuffer
         {
@@ -129,9 +129,9 @@ namespace dxcanvas
             return canvas::IColorBuffer::FMT_X8R8G8B8;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////
+
         // GDIColorBuffer
-        //////////////////////////////////////////////////////////////////////////////////
+
 
         struct GDIColorBuffer : public canvas::IColorBuffer
         {
@@ -208,9 +208,9 @@ namespace dxcanvas
         }
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::DXSurfaceBitmap
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     DXSurfaceBitmap::DXSurfaceBitmap( const ::basegfx::B2IVector&                   rSize,
                                       const canvas::ISurfaceProxyManagerSharedPtr&  rMgr,
@@ -231,18 +231,18 @@ namespace dxcanvas
         init();
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::getSize
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     ::basegfx::B2IVector DXSurfaceBitmap::getSize() const
     {
         return maSize;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::init
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void DXSurfaceBitmap::init()
     {
@@ -278,9 +278,9 @@ namespace dxcanvas
         mpSurfaceProxy = mpSurfaceManager->createSurfaceProxy(mpColorBuffer);
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::resize
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool DXSurfaceBitmap::resize( const ::basegfx::B2IVector& rSize )
     {
@@ -293,9 +293,9 @@ namespace dxcanvas
         return true;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::clear
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void DXSurfaceBitmap::clear()
     {
@@ -305,18 +305,18 @@ namespace dxcanvas
         pGraphics->Clear( transColor );
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::hasAlpha
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool DXSurfaceBitmap::hasAlpha() const
     {
         return mbAlpha;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::getGraphics
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     GraphicsSharedPtr DXSurfaceBitmap::getGraphics()
     {
@@ -332,9 +332,9 @@ namespace dxcanvas
             return createSurfaceGraphics(mpSurface);
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::getBitmap
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     BitmapSharedPtr DXSurfaceBitmap::getBitmap() const
     {
@@ -386,9 +386,9 @@ namespace dxcanvas
         return pResult;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool DXSurfaceBitmap::draw( double                           fAlpha,
                                 const ::basegfx::B2DPoint&       rPos,
@@ -404,9 +404,9 @@ namespace dxcanvas
         return mpSurfaceProxy->draw( fAlpha, rPos, rClipPoly, rTransform );
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool DXSurfaceBitmap::draw( double                         fAlpha,
                                 const ::basegfx::B2DPoint&     rPos,
@@ -422,9 +422,9 @@ namespace dxcanvas
         return mpSurfaceProxy->draw( fAlpha, rPos, rArea, rTransform );
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool DXSurfaceBitmap::draw( double                         fAlpha,
                                 const ::basegfx::B2DPoint&     rPos,
@@ -439,9 +439,9 @@ namespace dxcanvas
         return mpSurfaceProxy->draw( fAlpha, rPos, rTransform );
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool DXSurfaceBitmap::draw( const ::basegfx::B2IRange& rArea )
     {
@@ -460,9 +460,9 @@ namespace dxcanvas
                                     aTransform);
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::imageDebugger
-    //////////////////////////////////////////////////////////////////////////////////
+
 #if defined(DX_DEBUG_IMAGES)
 # if OSL_DEBUG_LEVEL > 0
     void DXSurfaceBitmap::imageDebugger()
@@ -494,9 +494,9 @@ namespace dxcanvas
 # endif
 #endif
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::getData
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     uno::Sequence< sal_Int8 > DXSurfaceBitmap::getData( rendering::IntegerBitmapLayout&     /*bitmapLayout*/,
                                                         const geometry::IntegerRectangle2D& rect )
@@ -582,9 +582,9 @@ namespace dxcanvas
         }
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::setData
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void DXSurfaceBitmap::setData( const uno::Sequence< sal_Int8 >&      data,
                                    const rendering::IntegerBitmapLayout& /*bitmapLayout*/,
@@ -666,9 +666,9 @@ namespace dxcanvas
         mbIsSurfaceDirty = true;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::setPixel
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void DXSurfaceBitmap::setPixel( const uno::Sequence< sal_Int8 >&      color,
                                     const rendering::IntegerBitmapLayout& /*bitmapLayout*/,
@@ -730,9 +730,9 @@ namespace dxcanvas
         mbIsSurfaceDirty = true;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // DXSurfaceBitmap::getPixel
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     uno::Sequence< sal_Int8 > DXSurfaceBitmap::getPixel( rendering::IntegerBitmapLayout&   /*bitmapLayout*/,
                                                          const geometry::IntegerPoint2D&   pos )
diff --git a/canvas/source/directx/dx_textlayout_drawhelper.cxx b/canvas/source/directx/dx_textlayout_drawhelper.cxx
index 183e6a11e3a4..a7409ba5ba16 100644
--- a/canvas/source/directx/dx_textlayout_drawhelper.cxx
+++ b/canvas/source/directx/dx_textlayout_drawhelper.cxx
@@ -49,7 +49,7 @@ class ::com::sun::star::rendering::XCanvasFont;
 using namespace ::com::sun::star;
 
 
-//////////////////////////////////////////////////////////////////////////////
+
 
 namespace dxcanvas
 {
diff --git a/canvas/source/directx/dx_vcltools.cxx b/canvas/source/directx/dx_vcltools.cxx
index d6f819969b39..401c13fbab46 100644
--- a/canvas/source/directx/dx_vcltools.cxx
+++ b/canvas/source/directx/dx_vcltools.cxx
@@ -184,16 +184,16 @@ namespace dxcanvas
 
                     // By convention, the access buffer always has
                     // one of the following formats:
-                    //
+
                     //    BMP_FORMAT_1BIT_MSB_PAL
                     //    BMP_FORMAT_4BIT_MSN_PAL
                     //    BMP_FORMAT_8BIT_PAL
                     //    BMP_FORMAT_16BIT_TC_LSB_MASK
                     //    BMP_FORMAT_24BIT_TC_BGR
                     //    BMP_FORMAT_32BIT_TC_MASK
-                    //
+
                     // and is always BMP_FORMAT_BOTTOM_UP
-                    //
+
                     // This is the way
                     // WinSalBitmap::AcquireBuffer() sets up the
                     // buffer
@@ -326,16 +326,16 @@ namespace dxcanvas
 
                     // By convention, the access buffer always has
                     // one of the following formats:
-                    //
+
                     //    BMP_FORMAT_1BIT_MSB_PAL
                     //    BMP_FORMAT_4BIT_MSN_PAL
                     //    BMP_FORMAT_8BIT_PAL
                     //    BMP_FORMAT_16BIT_TC_LSB_MASK
                     //    BMP_FORMAT_24BIT_TC_BGR
                     //    BMP_FORMAT_32BIT_TC_MASK
-                    //
+
                     // and is always BMP_FORMAT_BOTTOM_UP
-                    //
+
                     // This is the way
                     // WinSalBitmap::AcquireBuffer() sets up the
                     // buffer
diff --git a/canvas/source/opengl/ogl_spritedevicehelper.hxx b/canvas/source/opengl/ogl_spritedevicehelper.hxx
index aa8172564f0b..f50691899134 100644
--- a/canvas/source/opengl/ogl_spritedevicehelper.hxx
+++ b/canvas/source/opengl/ogl_spritedevicehelper.hxx
@@ -113,7 +113,7 @@ namespace oglcanvas
         /// Get instance of internal texture cache
         TextureCache& getTextureCache() const;
 
-        ////////////////////////////////////////////////////////
+
 
         // nobody except IBufferContext implementations are supposed
         // to use this
diff --git a/canvas/source/simplecanvas/simplecanvasimpl.cxx b/canvas/source/simplecanvas/simplecanvasimpl.cxx
index 803de0585d0b..5cf289a172ca 100644
--- a/canvas/source/simplecanvas/simplecanvasimpl.cxx
+++ b/canvas/source/simplecanvas/simplecanvasimpl.cxx
@@ -172,7 +172,7 @@ namespace
             tools::initViewState(maViewState);
         }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////////
+
 
     private:
         // Ifc XServiceName
@@ -362,7 +362,7 @@ namespace
                 return createStrokingRenderState();
         }
 
-        ///////////////////////////////////////////////////////////////////////////////////////////////
+
 
         typedef o3tl::LazyUpdate<
             rendering::FontRequest,
diff --git a/canvas/source/tools/elapsedtime.cxx b/canvas/source/tools/elapsedtime.cxx
index 447936de9a91..54b9bf6b77a2 100644
--- a/canvas/source/tools/elapsedtime.cxx
+++ b/canvas/source/tools/elapsedtime.cxx
@@ -30,7 +30,7 @@
 
 // TEMP!!!
 // Awaiting corresponding functionality in OSL
-//
+
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <winbase.h>
@@ -54,7 +54,7 @@ double ElapsedTime::getSystemTime()
 {
     // TEMP!!!
     // Awaiting corresponding functionality in OSL
-    //
+
 
     // is there a performance counter available?
     static bool bTimeSetupDone( false );
diff --git a/canvas/source/tools/pagemanager.cxx b/canvas/source/tools/pagemanager.cxx
index c2df1a142e21..d6ae95fc61a9 100644
--- a/canvas/source/tools/pagemanager.cxx
+++ b/canvas/source/tools/pagemanager.cxx
@@ -24,13 +24,13 @@
 namespace canvas
 {
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager
-    //////////////////////////////////////////////////////////////////////////////////
 
-    //////////////////////////////////////////////////////////////////////////////////
+
+
     // PageManager::allocateSpace
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     FragmentSharedPtr PageManager::allocateSpace( const ::basegfx::B2ISize& rSize )
     {
@@ -74,9 +74,9 @@ namespace canvas
         return pFragment;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager::free
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void PageManager::free( const FragmentSharedPtr& pFragment )
     {
@@ -94,9 +94,9 @@ namespace canvas
         pFragment->free(pFragment);
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager::nakedFragment
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void PageManager::nakedFragment( const FragmentSharedPtr& pFragment )
     {
@@ -151,9 +151,9 @@ namespace canvas
         }
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager::relocate
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool PageManager::relocate( const FragmentSharedPtr& pFragment )
     {
@@ -181,9 +181,9 @@ namespace canvas
         return false;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager::validatePages
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void PageManager::validatePages()
     {
@@ -192,18 +192,18 @@ namespace canvas
                          ::boost::mem_fn(&Page::validate));
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager::getPageSize
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     ::basegfx::B2ISize PageManager::getPageSize() const
     {
         return mpRenderModule->getPageSize();
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager::getRenderModule
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     canvas::IRenderModuleSharedPtr PageManager::getRenderModule() const
     {
diff --git a/canvas/source/tools/pagemanager.hxx b/canvas/source/tools/pagemanager.hxx
index 55025551f84e..1307fa0167d5 100644
--- a/canvas/source/tools/pagemanager.hxx
+++ b/canvas/source/tools/pagemanager.hxx
@@ -29,9 +29,9 @@
 namespace canvas
 {
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManager
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     class PageManager
     {
@@ -72,9 +72,9 @@ namespace canvas
         bool relocate( const FragmentSharedPtr& pFragment );
     };
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // PageManagerSharedPtr
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     typedef ::boost::shared_ptr< PageManager > PageManagerSharedPtr;
 }
diff --git a/canvas/source/tools/spriteredrawmanager.cxx b/canvas/source/tools/spriteredrawmanager.cxx
index d77fc5bd43ca..ee97967068cb 100644
--- a/canvas/source/tools/spriteredrawmanager.cxx
+++ b/canvas/source/tools/spriteredrawmanager.cxx
@@ -433,7 +433,7 @@ namespace canvas
     {
         // check whether SpriteInfo::needsUpdate returns false for
         // all elements of this area's contained sprites
-        //
+
         // if not a single changed sprite found - just ignore this
         // component (return false)
         const SpriteConnectedRanges::ComponentListType::const_iterator aEnd(
diff --git a/canvas/source/tools/surface.cxx b/canvas/source/tools/surface.cxx
index d30b8f4a8d9f..717f8722dc98 100644
--- a/canvas/source/tools/surface.cxx
+++ b/canvas/source/tools/surface.cxx
@@ -27,9 +27,9 @@
 namespace canvas
 {
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::Surface
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     Surface::Surface( const PageManagerSharedPtr&  rPageManager,
                       const IColorBufferSharedPtr& rColorBuffer,
@@ -44,9 +44,9 @@ namespace canvas
     {
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::~Surface
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     Surface::~Surface()
     {
@@ -54,18 +54,18 @@ namespace canvas
             mpPageManager->free(mpFragment);
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::getUVCoords
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void Surface::setColorBufferDirty()
     {
         mbIsDirty=true;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::getUVCoords
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     basegfx::B2DRectangle Surface::getUVCoords() const
     {
@@ -87,9 +87,9 @@ namespace canvas
                                         (oy+sy)/ph );
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::getUVCoords
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     basegfx::B2DRectangle Surface::getUVCoords( const ::basegfx::B2IPoint& rPos,
                                                 const ::basegfx::B2ISize&  rSize ) const
@@ -109,9 +109,9 @@ namespace canvas
                                         (oy+sy)/ph );
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool Surface::draw( double                          fAlpha,
                         const ::basegfx::B2DPoint&      rPos,
@@ -209,9 +209,9 @@ namespace canvas
         return !(pRenderModule->isError());
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::drawRectangularArea
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool Surface::drawRectangularArea(
                         double                         fAlpha,
@@ -335,9 +335,9 @@ namespace canvas
         return !(pRenderModule->isError());
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::drawWithClip
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool Surface::drawWithClip( double                          fAlpha,
                                 const ::basegfx::B2DPoint&      rPos,
@@ -443,9 +443,9 @@ namespace canvas
         return !(pRenderModule->isError());
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface::prepareRendering
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void Surface::prepareRendering()
     {
diff --git a/canvas/source/tools/surface.hxx b/canvas/source/tools/surface.hxx
index 294662e329b3..4b73eea6e252 100644
--- a/canvas/source/tools/surface.hxx
+++ b/canvas/source/tools/surface.hxx
@@ -35,9 +35,9 @@
 
 namespace canvas
 {
-    //////////////////////////////////////////////////////////////////////////////////
+
     // Surface
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     /** surfaces denote occupied areas withing pages.
 
diff --git a/canvas/source/tools/surfaceproxy.cxx b/canvas/source/tools/surfaceproxy.cxx
index e2510b4e2b62..76cce3b96d04 100644
--- a/canvas/source/tools/surfaceproxy.cxx
+++ b/canvas/source/tools/surfaceproxy.cxx
@@ -26,9 +26,9 @@
 
 namespace canvas
 {
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxy::SurfaceProxy
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     SurfaceProxy::SurfaceProxy( const canvas::IColorBufferSharedPtr& pBuffer,
                                 const PageManagerSharedPtr&          pPageManager ) :
@@ -82,9 +82,9 @@ namespace canvas
         }
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxy::setColorBufferDirty
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     void SurfaceProxy::setColorBufferDirty()
     {
@@ -93,9 +93,9 @@ namespace canvas
                          ::boost::mem_fn(&Surface::setColorBufferDirty));
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxy::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool SurfaceProxy::draw( double                         fAlpha,
                              const ::basegfx::B2DPoint&     rPos,
@@ -112,9 +112,9 @@ namespace canvas
         return true;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxy::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool SurfaceProxy::draw( double                         fAlpha,
                              const ::basegfx::B2DPoint&     rPos,
@@ -133,9 +133,9 @@ namespace canvas
         return true;
     }
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxy::draw
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     bool SurfaceProxy::draw( double                           fAlpha,
                              const ::basegfx::B2DPoint&       rPos,
diff --git a/canvas/source/tools/surfaceproxy.hxx b/canvas/source/tools/surfaceproxy.hxx
index fd3a79386a4d..d427807fb0f0 100644
--- a/canvas/source/tools/surfaceproxy.hxx
+++ b/canvas/source/tools/surfaceproxy.hxx
@@ -29,9 +29,9 @@
 namespace canvas
 {
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxy
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     /** Definition of the surface proxy class.
 
diff --git a/canvas/source/tools/surfaceproxymanager.cxx b/canvas/source/tools/surfaceproxymanager.cxx
index f13e8726fefa..b5fe33790c24 100644
--- a/canvas/source/tools/surfaceproxymanager.cxx
+++ b/canvas/source/tools/surfaceproxymanager.cxx
@@ -25,9 +25,9 @@
 namespace canvas
 {
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceProxyManager
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     class SurfaceProxyManager : public ISurfaceProxyManager
     {
@@ -63,9 +63,9 @@ namespace canvas
         PageManagerSharedPtr mpPageManager;
     };
 
-    //////////////////////////////////////////////////////////////////////////////////
+
     // createSurfaceProxyManager
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     ISurfaceProxyManagerSharedPtr createSurfaceProxyManager( const IRenderModuleSharedPtr& rRenderModule )
     {
diff --git a/canvas/source/tools/surfacerect.hxx b/canvas/source/tools/surfacerect.hxx
index 551bbc273d17..bc476bc534c2 100644
--- a/canvas/source/tools/surfacerect.hxx
+++ b/canvas/source/tools/surfacerect.hxx
@@ -25,9 +25,9 @@
 
 namespace canvas
 {
-    //////////////////////////////////////////////////////////////////////////////////
+
     // SurfaceRect
-    //////////////////////////////////////////////////////////////////////////////////
+
 
     struct SurfaceRect
     {
diff --git a/canvas/source/vcl/canvashelper_texturefill.cxx b/canvas/source/vcl/canvashelper_texturefill.cxx
index 1a68d423e1b8..8514f8a23473 100644
--- a/canvas/source/vcl/canvashelper_texturefill.cxx
+++ b/canvas/source/vcl/canvashelper_texturefill.cxx
@@ -347,12 +347,12 @@ namespace vclcanvas
             // innermost in rColor1. The innermost polygon will never
             // have zero area, thus, we must divide the interval into
             // nStepCount+1 steps. For example, to create 3 steps:
-            //
+
             // |                       |
             // |-------|-------|-------|
             // |                       |
             // 3       2       1       0
-            //
+
             // This yields 4 tick marks, where 0 is never attained (since
             // zero-area polygons typically don't display perceivable
             // color).
diff --git a/canvas/source/vcl/spritecanvashelper.hxx b/canvas/source/vcl/spritecanvashelper.hxx
index e1d64bd8e754..e40298a544c2 100644
--- a/canvas/source/vcl/spritecanvashelper.hxx
+++ b/canvas/source/vcl/spritecanvashelper.hxx
@@ -84,7 +84,7 @@ namespace vclcanvas
                                bool&    io_bSurfaceDirty );
 
         // SpriteRedrawManager functor calls
-        // -------------------------------------------------
+
 
         /** Gets called for simple background repaints
          */