Bin some pointless comments and ASCII graphics

Change-Id: Ib7b176eb1889ebd94d4b628899011de9ebbb3dbd

8 files changed, 9 insertions, 221 deletions

diff --git a/vcl/unx/generic/app/saldata.cxx b/vcl/unx/generic/app/saldata.cxx
index b7c7ee93cc36..c7f5351dc137 100644
--- a/vcl/unx/generic/app/saldata.cxx
+++ b/vcl/unx/generic/app/saldata.cxx
@@ -59,7 +59,6 @@
 #include <tools/debug.hxx>
 #include <vcl/svapp.hxx>
 
-// -=-= <signal.h> -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #ifndef UNX
 #ifndef SIGBUS
 #define SIGBUS 10
@@ -81,7 +80,6 @@ X11SalData* GetX11SalData()
     return p2;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 static const struct timeval noyield__ = { 0, 0 };
 static const struct timeval yield__   = { 0, 10000 };
 
@@ -217,9 +215,6 @@ static const char* XRequest[] = {
     "X_NoOperation"
 };
 
-// -=-= SalData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 X11SalData::X11SalData( SalGenericDataType t, SalInstance *pInstance )
     : SalGenericData( t, pInstance )
 {
@@ -301,9 +296,6 @@ void X11SalData::PopXErrorLevel()
     }
 }
 
-// -=-= C statics =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 int X11SalData::XErrorHdl( Display *pDisplay, XErrorEvent *pEvent )
 {
     GetX11SalData()->XError( pDisplay, pEvent );
@@ -341,9 +333,6 @@ int X11SalData::XIOErrorHdl( Display * )
 }
 
 
-
-// -=-= SalXLib =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalXLib::SalXLib()
 {
     m_aTimeout.tv_sec       = 0;
diff --git a/vcl/unx/generic/app/saldisp.cxx b/vcl/unx/generic/app/saldisp.cxx
index 6a3368577d5d..fe2a6a945d08 100644
--- a/vcl/unx/generic/app/saldisp.cxx
+++ b/vcl/unx/generic/app/saldisp.cxx
@@ -80,15 +80,9 @@ using namespace vcl_sal;
 
 using ::rtl::OUString;
 
-// -=-= #defines -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #define SALCOLOR_WHITE      MAKE_SALCOLOR( 0xFF, 0xFF, 0xFF )
 #define SALCOLOR_BLACK      MAKE_SALCOLOR( 0x00, 0x00, 0x00 )
 
-// -=-= Prototyps =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-= static variables -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 static const char* const EventNames[] =
 {
     NULL,
@@ -128,8 +122,6 @@ static const char* const EventNames[] =
     "MappingNotify"
 };
 
-// -=-= global inline =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline const char *Null( const char *p ) { return p ? p : ""; }
 inline const char *GetEnv( const char *p ) { return Null( getenv( p ) ); }
 inline const char *KeyStr( KeySym n ) { return Null( XKeysymToString( n ) ); }
@@ -148,8 +140,6 @@ inline int ColorDiff( SalColor c1, int r, int g, int b )
                     (int)SALCOLOR_GREEN(c1)-g,
                     (int)SALCOLOR_BLUE (c1)-b ); }
 
-// -=-= global functions -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 static int sal_Shift( Pixel nMask )
 {
     int i = 24;
@@ -174,7 +164,6 @@ static int sal_significantBits( Pixel nMask )
     return nBits;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 static sal_Bool sal_GetVisualInfo( Display *pDisplay, XID nVID, XVisualInfo &rVI )
 {
     int         nInfos;
@@ -224,8 +213,6 @@ sal_GetServerVendor( Display *p_display )
     return vendor_unknown;
 }
 
-// -=-= SalDisplay -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 sal_Bool SalDisplay::BestVisual( Display     *pDisplay,
                              int          nScreen,
                              XVisualInfo &rVI )
@@ -289,8 +276,6 @@ sal_Bool SalDisplay::BestVisual( Display     *pDisplay,
     return rVI.visualid == nDefVID;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 SalDisplay::SalDisplay( Display *display ) :
         mpInputMethod( NULL ),
         pDisp_( display ),
@@ -311,7 +296,6 @@ SalDisplay::SalDisplay( Display *display ) :
     m_nXDefaultScreen = SalX11Screen( DefaultScreen( pDisp_ ) );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalDisplay::~SalDisplay()
 {
 #if OSL_DEBUG_LEVEL > 1
@@ -584,7 +568,6 @@ SalDisplay::initScreen( SalX11Screen nXScreen ) const
     return pSD;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void SalDisplay::Init()
 {
     for( size_t i = 0; i < POINTER_COUNT; i++ )
@@ -663,7 +646,6 @@ void SalX11Display::SetupInput( SalI18N_InputMethod *pInputMethod )
 }
 
 // Keyboard
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 namespace {
 
@@ -802,7 +784,6 @@ void SalDisplay::ModifierMapping()
     XFreeModifiermap( pXModMap );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 rtl::OUString SalDisplay::GetKeyName( sal_uInt16 nKeyCode ) const
 {
     String aStrMap;
@@ -999,7 +980,6 @@ rtl::OUString SalDisplay::GetKeyName( sal_uInt16 nKeyCode ) const
     return aStrMap;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #ifndef IsISOKey
 #define IsISOKey( n ) (0x0000FE00==((n)&0xFFFFFF00))
 #endif
@@ -1390,7 +1370,6 @@ sal_uInt16 SalDisplay::GetKeyCode( KeySym keysym, char*pcPrintable ) const
     return nKey;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 KeySym SalDisplay::GetKeySym( XKeyEvent        *pEvent,
                                     unsigned char    *pPrintable,
                                     int              *pLen,
@@ -1475,7 +1454,6 @@ KeySym SalDisplay::GetKeySym( XKeyEvent        *pEvent,
 }
 
 // Pointer
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #define MAKE_BITMAP( name ) \
     XCreateBitmapFromData( pDisp_, \
                            DefaultRootWindow( pDisp_ ), \
@@ -1878,7 +1856,6 @@ int SalDisplay::CaptureMouse( SalFrame *pCapture )
 }
 
 // Events
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 sal_Bool SalX11Display::IsEvent()
 {
@@ -2160,7 +2137,6 @@ void SalDisplay::DbgPrintDisplayEvent(const char *pComment, XEvent *pEvent) cons
 }
 #endif
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void SalDisplay::PrintInfo() const
 {
     if( IsDisplay() )
@@ -2358,8 +2334,6 @@ bool SalDisplay::XIfEventWithTimeout( XEvent* o_pEvent, XPointer i_pPredicateDat
     return bRet;
 }
 
-// -=-= SalVisual -=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalVisual::SalVisual()
 {
     memset( this, 0, sizeof( SalVisual ) );
@@ -2425,7 +2399,6 @@ SalVisual::SalVisual( const XVisualInfo* pXVI )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalVisual::~SalVisual()
 {
     if( -1 == screen && VisualID(-1) == visualid ) delete visual;
@@ -2433,13 +2406,12 @@ SalVisual::~SalVisual()
 
 // Konvertiert die Reihenfolge der Bytes eines Pixel in Bytes eines SalColors
 // fuer die 6 XXXA ist das nicht reversibel
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 // SalColor is RGB (ABGR) a=0xFF000000, r=0xFF0000, g=0xFF00, b=0xFF
 
 #define SALCOLOR        RGB
 #define SALCOLORREVERSE BGR
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalColor SalVisual::GetTCColor( Pixel nPixel ) const
 {
     if( SALCOLOR == eRGBMode_ )
@@ -2495,8 +2467,6 @@ Pixel SalVisual::GetTCPixel( SalColor nSalColor ) const
     return (r&red_mask) | (g&green_mask) | (b&blue_mask);
 }
 
-// -=-= SalColormap -=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalColormap::SalColormap( const SalDisplay *pDisplay, Colormap hColormap,
                           SalX11Screen nXScreen )
     : m_pDisplay( pDisplay ),
@@ -2697,7 +2667,6 @@ void SalColormap::GetPalette()
     delete [] aColor;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 static sal_uInt16 sal_Lookup( const std::vector<SalColor>& rPalette,
                                 int r, int g, int b,
                                 Pixel nUsed )
@@ -2732,7 +2701,6 @@ void SalColormap::GetLookupTable()
                 m_aLookupTable[i++] = sal_Lookup( m_aPalette, r, g, b, m_nUsed );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalColor SalColormap::GetColor( Pixel nPixel ) const
 {
     if( m_nBlackPixel == nPixel ) return SALCOLOR_BLACK;
diff --git a/vcl/unx/generic/app/salinst.cxx b/vcl/unx/generic/app/salinst.cxx
index af958fb9570a..27d10456b726 100644
--- a/vcl/unx/generic/app/salinst.cxx
+++ b/vcl/unx/generic/app/salinst.cxx
@@ -39,11 +39,6 @@
 #include "salwtype.hxx"
 #include <sal/macros.h>
 
-//----------------------------------------------------------------------------
-
-// -=-= SalInstance =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 // plugin factory function
 extern "C"
 {
diff --git a/vcl/unx/generic/app/saltimer.cxx b/vcl/unx/generic/app/saltimer.cxx
index 9d182bd3f32e..c337510daafe 100644
--- a/vcl/unx/generic/app/saltimer.cxx
+++ b/vcl/unx/generic/app/saltimer.cxx
@@ -30,8 +30,6 @@
 #include <unx/saltimer.h>
 #include <unx/salinst.h>
 
-// -=-= SalData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalData::Timeout() const
 {
     ImplSVData* pSVData = ImplGetSVData();
@@ -39,8 +37,6 @@ void X11SalData::Timeout() const
         pSVData->mpSalTimer->CallCallback();
 }
 
-// -=-= SalXLib =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void SalXLib::StopTimer()
 {
     m_aTimeout.tv_sec   = 0;
@@ -63,8 +59,6 @@ void SalXLib::StartTimer( sal_uLong nMS )
     }
 }
 
-// -=-= SalTimer -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalTimer* X11SalInstance::CreateSalTimer()
 {
     return new X11SalTimer( mpXLib );
diff --git a/vcl/unx/generic/gdi/salgdi.cxx b/vcl/unx/generic/gdi/salgdi.cxx
index da7023bbf70f..f4cba0ea199a 100644
--- a/vcl/unx/generic/gdi/salgdi.cxx
+++ b/vcl/unx/generic/gdi/salgdi.cxx
@@ -51,8 +51,6 @@
 
 #include <config_graphite.h>
 
-// -=-= SalPolyLine =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #define STATIC_POINTS 64
 
 class SalPolyLine
@@ -86,8 +84,7 @@ inline SalPolyLine::~SalPolyLine()
 { if( pFirst_ != Points_ ) delete [] pFirst_; }
 
 #undef STATIC_POINTS
-// -=-= X11SalGraphics =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 X11SalGraphics::X11SalGraphics()
     : m_nXScreen( 0 )
 {
@@ -147,15 +144,12 @@ X11SalGraphics::X11SalGraphics()
     bDitherBrush_       = sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 X11SalGraphics::~X11SalGraphics()
 {
     ReleaseFonts();
     freeResources();
 }
 
-// -=-= SalGraphics / X11SalGraphics =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalGraphics::freeResources()
 {
     Display *pDisplay = GetXDisplay();
@@ -225,13 +219,11 @@ void X11SalGraphics::Init( SalFrame *pFrame, Drawable aTarget,
     m_pVDev     = NULL;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::DeInit()
 {
     SetDrawable( None, m_nXScreen );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetClipRegion( GC pGC, XLIB_Region pXReg ) const
 {
     Display *pDisplay = GetXDisplay();
@@ -259,7 +251,6 @@ void X11SalGraphics::SetClipRegion( GC pGC, XLIB_Region pXReg ) const
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 GC X11SalGraphics::SelectPen()
 {
     Display *pDisplay = GetXDisplay();
@@ -288,7 +279,6 @@ GC X11SalGraphics::SelectPen()
     return pPenGC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 GC X11SalGraphics::SelectBrush()
 {
     Display *pDisplay = GetXDisplay();
@@ -335,7 +325,6 @@ GC X11SalGraphics::SelectBrush()
     return pBrushGC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 GC X11SalGraphics::GetTrackingGC()
 {
     const char    dash_list[2] = {2, 2};
@@ -367,7 +356,6 @@ GC X11SalGraphics::GetTrackingGC()
     return pTrackingGC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::DrawLines( sal_uLong              nPoints,
                                 const SalPolyLine &rPoints,
                                 GC                 pGC,
@@ -403,7 +391,6 @@ void X11SalGraphics::DrawLines( sal_uLong              nPoints,
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 // Dithern: Calculate a dither-pixmap and make a brush of it
 #define P_DELTA         51
 #define DMAP( v, m )    ((v % P_DELTA) > m ? (v / P_DELTA) + 1 : (v / P_DELTA))
@@ -483,7 +470,6 @@ BOOL X11SalGraphics::GetDitherPixmap( SalColor nSalColor )
     return sal_True;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::GetResolution( sal_Int32 &rDPIX, sal_Int32 &rDPIY ) // const
 {
     const SalDisplay *pDisplay = GetDisplay();
@@ -520,13 +506,11 @@ void X11SalGraphics::GetResolution( sal_Int32 &rDPIX, sal_Int32 &rDPIY ) // cons
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 sal_uInt16 X11SalGraphics::GetBitCount() const
 {
     return GetVisual().GetDepth();
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalGraphics::GetGraphicsWidth() const
 {
     if( m_pFrame )
@@ -537,7 +521,6 @@ long X11SalGraphics::GetGraphicsWidth() const
         return 0;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalGraphics::GetGraphicsHeight() const
 {
     if( m_pFrame )
@@ -548,7 +531,6 @@ long X11SalGraphics::GetGraphicsHeight() const
         return 0;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::ResetClipRegion()
 {
     if( mpClipRegion )
@@ -611,7 +593,6 @@ bool X11SalGraphics::setClipRegion( const Region& i_rClip )
     return true;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetLineColor()
 {
     if( nPenColor_ != SALCOLOR_NONE )
@@ -621,7 +602,6 @@ void X11SalGraphics::SetLineColor()
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetLineColor( SalColor nSalColor )
 {
     if( nPenColor_ != nSalColor )
@@ -632,7 +612,6 @@ void X11SalGraphics::SetLineColor( SalColor nSalColor )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetFillColor()
 {
     if( nBrushColor_ != SALCOLOR_NONE )
@@ -643,7 +622,6 @@ void X11SalGraphics::SetFillColor()
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetFillColor( SalColor nSalColor )
 {
     if( nBrushColor_ != nSalColor )
@@ -674,7 +652,6 @@ void X11SalGraphics::SetFillColor( SalColor nSalColor )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetROPLineColor( SalROPColor nROPColor )
 {
     switch( nROPColor )
@@ -693,7 +670,6 @@ void X11SalGraphics::SetROPLineColor( SalROPColor nROPColor )
     bPenGC_     = sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetROPFillColor( SalROPColor nROPColor )
 {
     switch( nROPColor )
@@ -713,7 +689,6 @@ void X11SalGraphics::SetROPFillColor( SalROPColor nROPColor )
     bBrushGC_       = sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::SetXORMode( bool bSet, bool )
 {
     if( !bXORMode_ == bSet )
@@ -731,7 +706,6 @@ void X11SalGraphics::SetXORMode( bool bSet, bool )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawPixel( long nX, long nY )
 {
     if( nPenColor_ !=  SALCOLOR_NONE )
@@ -766,7 +740,6 @@ void X11SalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
 {
     if( nPenColor_ != SALCOLOR_NONE )
@@ -784,7 +757,6 @@ void X11SalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawRect( long nX, long nY, long nDX, long nDY )
 {
     if( nBrushColor_ != SALCOLOR_NONE )
@@ -802,13 +774,11 @@ void X11SalGraphics::drawRect( long nX, long nY, long nDX, long nDY )
                         nX, nY, nDX-1, nDY-1 );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawPolyLine( sal_uLong nPoints, const SalPoint *pPtAry )
 {
     drawPolyLine( nPoints, pPtAry, false );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawPolyLine( sal_uLong nPoints, const SalPoint *pPtAry, bool bClose )
 {
     if( nPenColor_ != SALCOLOR_NONE )
@@ -819,7 +789,6 @@ void X11SalGraphics::drawPolyLine( sal_uLong nPoints, const SalPoint *pPtAry, bo
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawPolygon( sal_uLong nPoints, const SalPoint* pPtAry )
 {
     if( nPoints == 0 )
@@ -886,7 +855,6 @@ void X11SalGraphics::drawPolygon( sal_uLong nPoints, const SalPoint* pPtAry )
         DrawLines( nPoints, Points, SelectPen(), true );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawPolyPolygon( sal_uInt32        nPoly,
                                    const sal_uInt32    *pPoints,
                                    PCONSTSALPOINT  *pPtAry )
@@ -934,30 +902,22 @@ void X11SalGraphics::drawPolyPolygon( sal_uInt32        nPoly,
            drawPolyLine( pPoints[i], pPtAry[i], true );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 sal_Bool X11SalGraphics::drawPolyLineBezier( sal_uLong, const SalPoint*, const BYTE* )
 {
     return sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 sal_Bool X11SalGraphics::drawPolygonBezier( sal_uLong, const SalPoint*, const BYTE* )
 {
     return sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 sal_Bool X11SalGraphics::drawPolyPolygonBezier( sal_uInt32, const sal_uInt32*,
                                                 const SalPoint* const*, const BYTE* const* )
 {
     return sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalGraphics::invert( sal_uLong nPoints,
                              const SalPoint* pPtAry,
                              SalInvert nFlags )
@@ -983,15 +943,11 @@ void X11SalGraphics::invert( sal_uLong nPoints,
                       Complex, CoordModeOrigin );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 BOOL X11SalGraphics::drawEPS( long,long,long,long,void*,sal_uLong )
 {
     return sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 XID X11SalGraphics::GetXRenderPicture()
 {
     XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();
@@ -1024,8 +980,6 @@ XRenderPictFormat* X11SalGraphics::GetXRenderFormat() const
     return m_pXRenderFormat;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 SystemGraphicsData X11SalGraphics::GetGraphicsData() const
 {
     SystemGraphicsData aRes;
@@ -1041,8 +995,6 @@ SystemGraphicsData X11SalGraphics::GetGraphicsData() const
     return aRes;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 // draw a poly-polygon
 bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency )
 {
@@ -1088,8 +1040,6 @@ bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPoly
     return bDrawn;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 bool X11SalGraphics::drawFilledTrapezoids( const ::basegfx::B2DTrapezoid* pB2DTraps, int nTrapCount, double fTransparency )
 {
     if( nTrapCount <= 0 )
@@ -1158,8 +1108,6 @@ bool X11SalGraphics::drawFilledTrapezoids( const ::basegfx::B2DTrapezoid* pB2DTr
     return true;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 bool X11SalGraphics::drawPolyLine(
     const ::basegfx::B2DPolygon& rPolygon,
     double fTransparency,
@@ -1244,6 +1192,4 @@ bool X11SalGraphics::drawPolyLine(
     return bDrawnOk;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/unx/generic/gdi/salgdi2.cxx b/vcl/unx/generic/gdi/salgdi2.cxx
index 67eee82eedec..29ea8ec8ff8f 100644
--- a/vcl/unx/generic/gdi/salgdi2.cxx
+++ b/vcl/unx/generic/gdi/salgdi2.cxx
@@ -40,11 +40,6 @@
 
 #undef SALGDI2_TESTTRANS
 
-// -=-= debugging =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-// -----------------------------------------------------------------------------
-
 #if (OSL_DEBUG_LEVEL > 1) && defined SALGDI2_TESTTRANS
 #define DBG_TESTTRANS( _def_drawable )                              \
 {                                                                   \
@@ -57,8 +52,6 @@
 #define DBG_TESTTRANS( _def_drawable )
 #endif // (OSL_DEBUG_LEVEL > 1) && defined SALGDI2_TESTTRANS
 
-// -=-= X11SalGraphics =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::CopyScreenArea( Display* pDisplay,
                                      Drawable aSrc, SalX11Screen nXScreenSrc, int nSrcDepth,
                                      Drawable aDest, SalX11Screen nXScreenDest, int nDestDepth,
@@ -117,7 +110,6 @@ GC X11SalGraphics::CreateGC( Drawable hDrawable, unsigned long nMask )
     return XCreateGC( GetXDisplay(), hDrawable, nMask | GCSubwindowMode, &values );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline GC X11SalGraphics::GetMonoGC( Pixmap hPixmap )
 {
     if( !pMonoGC_ )
@@ -132,7 +124,6 @@ inline GC X11SalGraphics::GetMonoGC( Pixmap hPixmap )
     return pMonoGC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline GC X11SalGraphics::GetCopyGC()
 {
     if( bXORMode_ ) return GetInvertGC();
@@ -148,7 +139,6 @@ inline GC X11SalGraphics::GetCopyGC()
     return pCopyGC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 GC X11SalGraphics::GetInvertGC()
 {
     if( !pInvertGC_ )
@@ -166,7 +156,6 @@ GC X11SalGraphics::GetInvertGC()
     return pInvertGC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 GC X11SalGraphics::GetInvert50GC()
 {
     if( !pInvert50GC_ )
@@ -214,7 +203,6 @@ GC X11SalGraphics::GetInvert50GC()
     return pInvert50GC_;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline GC X11SalGraphics::GetStippleGC()
 {
     if( !pStippleGC_ )
@@ -233,9 +221,6 @@ inline GC X11SalGraphics::GetStippleGC()
     return pStippleGC_;
 }
 
-// -=-= SalGraphics =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 extern "C"
 {
     static Bool GraphicsExposePredicate( Display*, XEvent* pEvent, XPointer pFrameWindow )
@@ -460,7 +445,6 @@ void X11SalGraphics::copyArea ( long nDestX,    long nDestY,
     copyBits ( &aPosAry, 0 );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSalBitmap )
 {
     const SalDisplay*   pSalDisp = GetDisplay();
@@ -505,8 +489,6 @@ void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry, const SalBitmap& rSa
     XFlush( pXDisp );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry,
                                  const SalBitmap& rSrcBitmap,
                                  const SalBitmap& rMaskBitmap )
@@ -526,8 +508,6 @@ void X11SalGraphics::drawBitmap( const SalTwoRect* pPosAry,
     drawMaskedBitmap( pPosAry, rSrcBitmap, rMaskBitmap );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalGraphics::drawMaskedBitmap( const SalTwoRect* pPosAry,
                                        const SalBitmap& rSalBitmap,
                                        const SalBitmap& rTransBitmap )
@@ -624,14 +604,12 @@ void X11SalGraphics::drawMaskedBitmap( const SalTwoRect* pPosAry,
         XFreePixmap( pXDisp, aBG );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 bool X11SalGraphics::drawAlphaBitmap( const SalTwoRect& rTR,
                                       const SalBitmap& rSrcBitmap, const SalBitmap& rAlphaBmp )
 {
     return drawAlphaBitmapOpt( rTR, rSrcBitmap, rAlphaBmp );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 bool X11SalGraphics::drawAlphaBitmapOpt( const SalTwoRect& rTR,
                                          const SalBitmap& rSrcBitmap, const SalBitmap& rAlphaBmp, bool bUseAlphaBitmap )
 {
@@ -768,7 +746,6 @@ bool X11SalGraphics::drawAlphaBitmapOpt( const SalTwoRect& rTR,
     return true;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 bool X11SalGraphics::drawAlphaRect( long nX, long nY, long nWidth,
                                     long nHeight, sal_uInt8 nTransparency )
 {
@@ -798,7 +775,6 @@ bool X11SalGraphics::drawAlphaRect( long nX, long nY, long nWidth,
     return true;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawBitmap( const SalTwoRect*,
                                  const SalBitmap&,
                                  SalColor )
@@ -806,7 +782,6 @@ void X11SalGraphics::drawBitmap( const SalTwoRect*,
     OSL_FAIL( "::DrawBitmap with transparent color not supported" );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::drawMask( const SalTwoRect* pPosAry,
                                const SalBitmap &rSalBitmap,
                                SalColor nMaskColor )
@@ -849,7 +824,6 @@ void X11SalGraphics::drawMask( const SalTwoRect* pPosAry,
         drawBitmap( pPosAry, rSalBitmap );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalBitmap *X11SalGraphics::getBitmap( long nX, long nY, long nDX, long nDY )
 {
     if( bPrinter_ && !bVirDev_ )
@@ -920,7 +894,6 @@ SalBitmap *X11SalGraphics::getBitmap( long nX, long nY, long nDX, long nDY )
     return pSalBitmap;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalColor X11SalGraphics::getPixel( long nX, long nY )
 {
     if( bWindow_ && !bVirDev_ )
@@ -955,7 +928,6 @@ SalColor X11SalGraphics::getPixel( long nX, long nY )
     return GetColormap().GetColor( aXColor.pixel );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::invert( long       nX,
                                 long        nY,
                                 long        nDX,
diff --git a/vcl/unx/generic/gdi/salvd.cxx b/vcl/unx/generic/gdi/salvd.cxx
index 80b1e64985b8..6304ca673a67 100644
--- a/vcl/unx/generic/gdi/salvd.cxx
+++ b/vcl/unx/generic/gdi/salvd.cxx
@@ -33,8 +33,6 @@
 
 #include <salinst.hxx>
 
-// -=-= SalInstance =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 SalVirtualDevice* X11SalInstance::CreateVirtualDevice( SalGraphics* pGraphics,
                                                        long nDX, long nDY,
                                                        sal_uInt16 nBitCount, const SystemGraphicsData *pData )
@@ -85,8 +83,6 @@ void X11SalInstance::DestroyVirtualDevice( SalVirtualDevice* pDevice )
     delete pDevice;
 }
 
-// -=-= SalGraphicsData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalGraphics::Init( X11SalVirtualDevice *pDevice, SalColormap* pColormap,
                            bool bDeleteColormap )
 {
@@ -122,8 +118,6 @@ void X11SalGraphics::Init( X11SalVirtualDevice *pDevice, SalColormap* pColormap,
     bVirDev_     = sal_True;
 }
 
-// -=-= SalVirDevData / SalVirtualDevice -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 sal_Bool X11SalVirtualDevice::Init( SalDisplay *pDisplay,
                                     long nDX, long nDY,
                                     sal_uInt16 nBitCount,
@@ -171,7 +165,6 @@ sal_Bool X11SalVirtualDevice::Init( SalDisplay *pDisplay,
     return hDrawable_ != None ? sal_True : sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 X11SalVirtualDevice::X11SalVirtualDevice() :
     m_nXScreen( 0 )
 {
@@ -185,7 +178,6 @@ X11SalVirtualDevice::X11SalVirtualDevice() :
     bExternPixmap_          = sal_False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 X11SalVirtualDevice::~X11SalVirtualDevice()
 {
     if( pGraphics_ )
diff --git a/vcl/unx/generic/window/salframe.cxx b/vcl/unx/generic/window/salframe.cxx
index 50f2aef1d185..524717b558c1 100644
--- a/vcl/unx/generic/window/salframe.cxx
+++ b/vcl/unx/generic/window/salframe.cxx
@@ -78,7 +78,6 @@
 using namespace vcl_sal;
 using namespace vcl;
 
-// -=-= #defines -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #define CLIENT_EVENTS           StructureNotifyMask \
                                 | SubstructureNotifyMask \
                                 | KeyPressMask \
@@ -94,14 +93,10 @@ using namespace vcl;
                                 | PropertyChangeMask \
                                 | ColormapChangeMask
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 static XLIB_Window  hPresentationWindow = None, hPresFocusWindow = None;
 static ::std::list< XLIB_Window > aPresentationReparentList;
 static int          nVisibleFloats      = 0;
 
-// -=-= C++ statics =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 static void doReparentPresentationDialogues( SalDisplay* pDisplay )
 {
     GetGenericData()->ErrorTrapPush();
@@ -132,9 +127,6 @@ static void doReparentPresentationDialogues( SalDisplay* pDisplay )
     GetGenericData()->ErrorTrapPop();
 }
 
-// -=-= SalFrame / X11SalFrame =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 bool X11SalFrame::IsOverrideRedirect() const
 {
     return
@@ -199,9 +191,6 @@ void X11SalFrame::askForXEmbedFocus( sal_Int32 i_nTimeCode )
     GetGenericData()->ErrorTrapPop();
 }
 
-
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::Init( sal_uLong nSalFrameStyle, SalX11Screen nXScreen, SystemParentData* pParentData, bool bUseGeometry )
 {
     if( nXScreen.getXScreen() >= GetDisplay()->GetXScreenCount() )
@@ -622,7 +611,6 @@ void X11SalFrame::Init( sal_uLong nSalFrameStyle, SalX11Screen nXScreen, SystemP
     SetPointer( POINTER_ARROW );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 X11SalFrame::X11SalFrame( SalFrame *pParent, sal_uLong nSalFrameStyle,
                           SystemParentData* pSystemParent ) :
     m_nXScreen( 0 )
@@ -784,8 +772,6 @@ X11SalFrame::~X11SalFrame()
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::SetExtendedFrameStyle( SalExtStyle nStyle )
 {
     if( nStyle != mnExtStyle && ! IsChildWindow() )
@@ -795,8 +781,6 @@ void X11SalFrame::SetExtendedFrameStyle( SalExtStyle nStyle )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 const SystemChildData* X11SalFrame::GetSystemData() const
 {
     X11SalFrame *pFrame = const_cast<X11SalFrame*>(this);
@@ -854,15 +838,11 @@ void X11SalFrame::updateGraphics( bool bClear )
         pFreeGraphics_->SetDrawable( aDrawable, m_nXScreen );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::Enable( sal_Bool /*bEnable*/ )
 {
     // NYI: enable/disable frame
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::SetIcon( sal_uInt16 nIcon )
 {
     if ( ! IsChildWindow() )
@@ -972,8 +952,6 @@ void X11SalFrame::SetIcon( sal_uInt16 nIcon )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::SetMaxClientSize( long nWidth, long nHeight )
 {
     if( ! IsChildWindow() )
@@ -1023,7 +1001,7 @@ void X11SalFrame::SetMinClientSize( long nWidth, long nHeight )
 }
 
 // Show + Pos (x,y,z) + Size (width,height)
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 void X11SalFrame::Show( sal_Bool bVisible, sal_Bool bNoActivate )
 {
     if( ( bVisible && bMapped_ )
@@ -1248,7 +1226,6 @@ void X11SalFrame::Show( sal_Bool bVisible, sal_Bool bNoActivate )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::ToTop( sal_uInt16 nFlags )
 {
     if( ( nFlags & SAL_FRAME_TOTOP_RESTOREWHENMIN )
@@ -1282,12 +1259,12 @@ void X11SalFrame::ToTop( sal_uInt16 nFlags )
             XSetInputFocus( GetXDisplay(), aToTopWindow, RevertToParent, CurrentTime );
     }
 }
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 void X11SalFrame::GetWorkArea( Rectangle& rWorkArea )
 {
     rWorkArea = pDisplay_->getWMAdaptor()->getWorkArea( 0 );
 }
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 void X11SalFrame::GetClientSize( long &rWidth, long &rHeight )
 {
     if( ! bViewable_  )
@@ -1310,8 +1287,6 @@ void X11SalFrame::GetClientSize( long &rWidth, long &rHeight )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::Center( )
 {
     int             nX, nY, nScreenWidth, nScreenHeight;
@@ -1427,7 +1402,6 @@ void X11SalFrame::Center( )
     SetPosSize( Rectangle( aPoint, Size( maGeometry.nWidth, maGeometry.nHeight ) ) );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::updateScreenNumber()
 {
     if( GetDisplay()->IsXinerama() && GetDisplay()->GetXineramaScreens().size() > 1 )
@@ -1448,7 +1422,6 @@ void X11SalFrame::updateScreenNumber()
         maGeometry.nDisplayScreenNumber = m_nXScreen.getXScreen();
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::SetPosSize( long nX, long nY, long nWidth, long nHeight, sal_uInt16 nFlags )
 {
     if( nStyle_ & SAL_FRAME_STYLE_PLUG )
@@ -1494,7 +1467,6 @@ void X11SalFrame::SetPosSize( long nX, long nY, long nWidth, long nHeight, sal_u
     bDefaultPosition_ = False;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::SetAlwaysOnTop( sal_Bool bOnTop )
 {
     if( ! IsOverrideRedirect() )
@@ -1504,8 +1476,6 @@ void X11SalFrame::SetAlwaysOnTop( sal_Bool bOnTop )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 #define _FRAMESTATE_MASK_GEOMETRY \
      (SAL_FRAMESTATE_MASK_X     | SAL_FRAMESTATE_MASK_Y |   \
       SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT)
@@ -1664,7 +1634,6 @@ void X11SalFrame::SetWindowState( const SalFrameState *pState )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 sal_Bool X11SalFrame::GetWindowState( SalFrameState* pState )
 {
     if( SHOWSTATE_MINIMIZED == nShowState_ )
@@ -1707,8 +1676,6 @@ sal_Bool X11SalFrame::GetWindowState( SalFrameState* pState )
     return sal_True;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 // native menu implementation - currently empty
 void X11SalFrame::DrawMenuBar()
 {
@@ -1718,7 +1685,6 @@ void X11SalFrame::SetMenu( SalMenu* )
 {
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::GetPosSize( Rectangle &rPosSize )
 {
     if( maGeometry.nWidth < 1 || maGeometry.nHeight < 1 )
@@ -1734,7 +1700,6 @@ void X11SalFrame::GetPosSize( Rectangle &rPosSize )
                               Size( maGeometry.nWidth, maGeometry.nHeight ) );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::SetSize( const Size &rSize )
 {
     if( rSize.Width() > 0 && rSize.Height() > 0 )
@@ -1778,10 +1743,6 @@ void X11SalFrame::SetSize( const Size &rSize )
     }
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::SetPosSize( const Rectangle &rPosSize )
 {
     XWindowChanges values;
@@ -1903,7 +1864,6 @@ void X11SalFrame::SetPosSize( const Rectangle &rPosSize )
         mpInputContext->SetICFocus ( this );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::Minimize()
 {
     if( IsSysChildWindow() )
@@ -1921,7 +1881,6 @@ void X11SalFrame::Minimize()
         nShowState_ = SHOWSTATE_MINIMIZED;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::Maximize()
 {
     if( IsSysChildWindow() )
@@ -1937,7 +1896,6 @@ void X11SalFrame::Maximize()
     pDisplay_->getWMAdaptor()->maximizeFrame( this, true, true );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::Restore()
 {
     if( IsSysChildWindow() )
@@ -1959,8 +1917,6 @@ void X11SalFrame::Restore()
     pDisplay_->getWMAdaptor()->maximizeFrame( this, false, false );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::SetScreenNumber( unsigned int nNewScreen )
 {
     if( nNewScreen == maGeometry.nDisplayScreenNumber )
@@ -2022,9 +1978,6 @@ void X11SalFrame::updateWMClass()
     XFree( pClass );
 }
 
-
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::ShowFullScreen( sal_Bool bFullScreen, sal_Int32 nScreen )
 {
     if( GetDisplay()->IsXinerama() && GetDisplay()->GetXineramaScreens().size() > 1 )
@@ -2176,7 +2129,6 @@ MessageToXAutoLock( Display *p_display, int n_message )
     return True;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 void X11SalFrame::StartPresentation( sal_Bool bStart )
 {
     I18NStatus::get().show( !bStart, I18NStatus::presentation );
@@ -2288,7 +2240,7 @@ void X11SalFrame::StartPresentation( sal_Bool bStart )
 }
 
 // Pointer
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 void X11SalFrame::SetPointer( PointerStyle ePointerStyle )
 {
     hCursor_ = pDisplay_->GetPointer( ePointerStyle );
@@ -2344,7 +2296,7 @@ X11SalFrame::HandleExtTextEvent (XClientMessageEvent *pEvent)
 #endif /* defined(__synchronous_extinput__) */
 
 // PostEvent
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 sal_Bool X11SalFrame::PostEvent( void *pData )
 {
     GetDisplay()->SendInternalEvent( this, pData );
@@ -2352,7 +2304,7 @@ sal_Bool X11SalFrame::PostEvent( void *pData )
 }
 
 // Title
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 void X11SalFrame::SetTitle( const rtl::OUString& rTitle )
 {
     if( ! ( IsChildWindow() || (nStyle_ & SAL_FRAME_STYLE_FLOAT ) ) )
@@ -2377,9 +2329,6 @@ void X11SalFrame::Sync()
 }
 
 // Keyboard
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-// -----------------------------------------------------------------------
 
 void X11SalFrame::SetInputContext( SalInputContext* pContext )
 {
@@ -2446,7 +2395,6 @@ LanguageType X11SalFrame::GetInputLanguage()
 }
 
 // Settings
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 inline Color getColorFromLong( long nColor )
 {
@@ -2465,8 +2413,6 @@ void X11SalFrame::CaptureMouse( sal_Bool bCapture )
     nCaptured_ = pDisplay_->CaptureMouse( bCapture ? this : NULL );
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 void X11SalFrame::SetParent( SalFrame* pNewParent )
 {
     if( mpParent != pNewParent )
@@ -2577,7 +2523,7 @@ bool X11SalFrame::SetPluginParent( SystemParentData* pNewParent )
 }
 
 // Event Handling
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
 static sal_uInt16 sal_GetCode( int state )
 {
     sal_uInt16 nCode = 0;
@@ -2604,8 +2550,6 @@ static sal_uInt16 sal_GetCode( int state )
     return nCode;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 SalFrame::SalPointerState X11SalFrame::GetPointerState()
 {
     SalPointerState aState;
@@ -3024,7 +2968,6 @@ bool X11SalFrame::endUnicodeSequence()
     return bWasInput;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleKeyEvent( XKeyEvent *pEvent )
 {
     KeySym          nKeySym;
@@ -3305,8 +3248,6 @@ long X11SalFrame::HandleKeyEvent( XKeyEvent *pEvent )
     return True;
 }
 
-
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleFocusEvent( XFocusChangeEvent *pEvent )
 {
     // ReflectionX in Windows mode changes focus while mouse is grabbed
@@ -3376,8 +3317,6 @@ long X11SalFrame::HandleFocusEvent( XFocusChangeEvent *pEvent )
     return 0;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 long X11SalFrame::HandleExposeEvent( XEvent *pEvent )
 {
     XRectangle  aRect = { 0, 0, 0, 0 };
@@ -3508,7 +3447,6 @@ void X11SalFrame::setPendingSizeEvent()
     mPendingSizeEvent = true;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleSizeEvent( XConfigureEvent *pEvent )
 {
     // NOTE: if you add more tests in this function, make sure to update size_event_predicate()
@@ -3603,7 +3541,6 @@ IMPL_LINK_NOARG(X11SalFrame, HandleAlwaysOnTopRaise)
     return 0;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleReparentEvent( XReparentEvent *pEvent )
 {
     Display        *pDisplay   = pEvent->display;
@@ -3797,13 +3734,11 @@ long X11SalFrame::HandleReparentEvent( XReparentEvent *pEvent )
     return 1;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleColormapEvent( XColormapEvent* )
 {
     return 0;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleStateEvent( XPropertyEvent *pEvent )
 {
     Atom          actual_type;
@@ -3841,7 +3776,6 @@ long X11SalFrame::HandleStateEvent( XPropertyEvent *pEvent )
     return 1;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 long X11SalFrame::HandleClientMessage( XClientMessageEvent *pEvent )
 {
     const WMAdaptor& rWMAdaptor( *pDisplay_->getWMAdaptor() );
@@ -3903,8 +3837,6 @@ long X11SalFrame::HandleClientMessage( XClientMessageEvent *pEvent )
     return 0;
 }
 
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 extern "C"
 {
 Bool call_checkKeyReleaseForRepeat( Display* pDisplay, XEvent* pCheck, XPointer pX11SalFrame )