Bin some pointless comments and ASCII graphics

Change-Id: Ib7b176eb1889ebd94d4b628899011de9ebbb3dbd

37 files changed, 10 insertions, 482 deletions

diff --git a/vcl/inc/aqua/saldata.hxx b/vcl/inc/aqua/saldata.hxx
index 91d706eca8ee..b7f3ad745a38 100644
--- a/vcl/inc/aqua/saldata.hxx
+++ b/vcl/inc/aqua/saldata.hxx
@@ -48,19 +48,11 @@ class SalVirtualDevice;
 class SalPrinter;
 class SystemFontList;
 
-// ------------------
-// - Some constants -
-// ------------------
-
 #define SAL_CLIPRECT_COUNT 16
 
 #define VER_TIGER   0x1040
 #define VER_LEOPARD 0x1050
 
-// -----------
-// - SalData -
-// -----------
-
 class AquaSalFrame;
 struct FrameHash : public boost::hash<sal_IntPtr>
 {
@@ -121,8 +113,6 @@ public:
 inline void SetSalData( SalData* pData ) { ImplGetSVData()->mpSalData = pData; }
 inline SalData *GetSalData() { return ImplGetSVData()->mpSalData; }
 
-// --- Prototypes ---
-
 sal_Bool ImplSalYieldMutexTryToAcquire();
 void ImplSalYieldMutexAcquire();
 void ImplSalYieldMutexRelease();
diff --git a/vcl/inc/aqua/salinst.h b/vcl/inc/aqua/salinst.h
index c8d22665f7bc..a295e066df2b 100644
--- a/vcl/inc/aqua/salinst.h
+++ b/vcl/inc/aqua/salinst.h
@@ -35,10 +35,6 @@ class AquaSalFrame;
 class ApplicationEvent;
 class Image;
 
-// -----------------
-// - SalYieldMutex -
-// -----------------
-
 class SalYieldMutex : public vcl::SolarMutexObject
 {
     sal_uLong                                       mnCount;
@@ -56,19 +52,6 @@ public:
 #define YIELD_GUARD osl::SolarGuard aGuard( GetSalData()->mpFirstInstance->GetYieldMutex() )
 
 
-// -------------------
-// - SalInstanceData -
-// -------------------
-
-//struct SalInstanceData
-//{
-//public:
-//};
-
-// ------------------
-// - AquaSalInstance -
-// ------------------
-
 class AquaSalInstance : public SalInstance
 {
     struct SalUserEvent
@@ -184,7 +167,6 @@ class YieldMutexReleaser
     ~YieldMutexReleaser();
 };
 
-// helper class
 rtl::OUString GetOUString( CFStringRef );
 rtl::OUString GetOUString( NSString* );
 CFStringRef CreateCFString( const rtl::OUString& );
diff --git a/vcl/inc/headless/svpinst.hxx b/vcl/inc/headless/svpinst.hxx
index 894f1941f296..5f4a6e69a8d9 100644
--- a/vcl/inc/headless/svpinst.hxx
+++ b/vcl/inc/headless/svpinst.hxx
@@ -37,9 +37,6 @@
 #define VIRTUAL_DESKTOP_WIDTH 1024
 #define VIRTUAL_DESKTOP_HEIGHT 768
 
-// ---------------
-// - SalTimer -
-// ---------------
 class SvpSalInstance;
 class SvpSalTimer : public SalTimer
 {
@@ -53,9 +50,6 @@ public:
     virtual void Stop();
 };
 
-// ---------------
-// - SalInstance -
-// ---------------
 class SvpSalFrame;
 class GenPspGraphics;
 class SvpSalInstance : public SalGenericInstance
diff --git a/vcl/inc/ios/saldata.hxx b/vcl/inc/ios/saldata.hxx
index 9ab5e4bab2e5..d461899802be 100644
--- a/vcl/inc/ios/saldata.hxx
+++ b/vcl/inc/ios/saldata.hxx
@@ -46,16 +46,8 @@ class SalVirtualDevice;
 class SalPrinter;
 class SystemFontList;
 
-// ------------------
-// - Some constants -
-// ------------------
-
 #define SAL_CLIPRECT_COUNT 16
 
-// -----------
-// - SalData -
-// -----------
-
 class IosSalFrame;
 struct FrameHash : public boost::hash<sal_IntPtr>
 {
@@ -100,8 +92,6 @@ public:
 inline void SetSalData( SalData* pData ) { ImplGetSVData()->mpSalData = pData; }
 inline SalData *GetSalData() { return ImplGetSVData()->mpSalData; }
 
-// --- Prototypes ---
-
 sal_Bool ImplSalYieldMutexTryToAcquire();
 void ImplSalYieldMutexAcquire();
 void ImplSalYieldMutexRelease();
diff --git a/vcl/inc/ios/salinst.h b/vcl/inc/ios/salinst.h
index cb4d996a491e..f7ff822ebeb5 100644
--- a/vcl/inc/ios/salinst.h
+++ b/vcl/inc/ios/salinst.h
@@ -35,10 +35,6 @@ class IosSalFrame;
 class ApplicationEvent;
 class Image;
 
-// -----------------
-// - SalYieldMutex -
-// -----------------
-
 class SalYieldMutex : public vcl::SolarMutexObject
 {
     sal_uLong                                   mnCount;
@@ -56,19 +52,6 @@ public:
 #define YIELD_GUARD osl::SolarGuard aGuard( GetSalData()->mpFirstInstance->GetYieldMutex() )
 
 
-// -------------------
-// - SalInstanceData -
-// -------------------
-
-//struct SalInstanceData
-//{
-//public:
-//};
-
-// ------------------
-// - IosSalInstance -
-// ------------------
-
 class IosSalInstance : public SalInstance
 {
     struct SalUserEvent
@@ -176,7 +159,6 @@ class YieldMutexReleaser
     ~YieldMutexReleaser();
 };
 
-// helper class
 rtl::OUString GetOUString( CFStringRef );
 rtl::OUString GetOUString( NSString* );
 CFStringRef CreateCFString( const rtl::OUString& );
diff --git a/vcl/inc/saldatabasic.hxx b/vcl/inc/saldatabasic.hxx
index f97c03ff6d2b..e4ef22c03d35 100644
--- a/vcl/inc/saldatabasic.hxx
+++ b/vcl/inc/saldatabasic.hxx
@@ -42,7 +42,6 @@ public:
     virtual ~SalData();
 };
 
-// -=-= inlines =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline void SetSalData( SalData* pData )
 { ImplGetSVData()->mpSalData = pData; }
 
diff --git a/vcl/inc/salframe.hxx b/vcl/inc/salframe.hxx
index 2ae1121675a7..d85375b6e3f7 100644
--- a/vcl/inc/salframe.hxx
+++ b/vcl/inc/salframe.hxx
@@ -115,10 +115,6 @@ typedef sal_uInt64 SalExtStyle;
 using ::rtl::OUString;
 using ::rtl::OString;
 
-// ------------
-// - SalFrame -
-// ------------
-
 struct SystemParentData;
 
 class VCL_PLUGIN_PUBLIC SalFrame : public vcl::DeletionNotifier
@@ -263,8 +259,6 @@ public:
     { return m_pProc ? m_pProc( m_pWindow, const_cast<SalFrame*>(this), nEvent, pEvent ) : 0; }
 };
 
-
-
 #endif // __cplusplus
 
 #endif // _SV_SALFRAME_HXX
diff --git a/vcl/inc/salgdi.hxx b/vcl/inc/salgdi.hxx
index 9936c8651f05..7da7860edc68 100644
--- a/vcl/inc/salgdi.hxx
+++ b/vcl/inc/salgdi.hxx
@@ -79,10 +79,6 @@ typedef std::map< sal_Ucs, sal_uInt32 >   Ucs2UIntMap;
 typedef std::map< sal_Ucs, rtl::OString > Ucs2OStrMap;
 typedef std::vector< sal_Int32 > Int32Vector;
 
-// ---------------
-// - SalGraphics -
-// ---------------
-
 // note: if you add any new methods to class SalGraphics using coordinates
 //       make sure they have a corresponding protected pure virtual method
 //       which has to be implemented by the platform dependent part.
diff --git a/vcl/inc/salinst.hxx b/vcl/inc/salinst.hxx
index 19b5ec605c8f..fa74ae7c15c5 100644
--- a/vcl/inc/salinst.hxx
+++ b/vcl/inc/salinst.hxx
@@ -60,10 +60,6 @@ struct SystemGraphicsData;
 struct SystemWindowData;
 class Menu;
 
-// ---------------
-// - SalInstance -
-// ---------------
-
 class VCL_PLUGIN_PUBLIC SalInstance
 {
 private:
@@ -183,28 +179,15 @@ public:
 SalInstance* CreateSalInstance();
 void DestroySalInstance( SalInstance* pInst );
 
-// -------------------------
-// - SalInstance-Functions -
-// -------------------------
-
 void SalAbort( const OUString& rErrorText, bool bDumpCore );
 
 VCL_PLUGIN_PUBLIC const OUString& SalGetDesktopEnvironment();
 
-// -----------
-// - SalData -
-// -----------
-
 void InitSalData();                         // called from Application-Ctor
 void DeInitSalData();                       // called from Application-Dtor
 
 void InitSalMain();
 
-// ----------
-// - SVMain -
-// ----------
-
-// Callbacks (indepen in \sv\source\app\svmain.cxx)
 VCL_DLLPUBLIC int SVMain();
 
 #endif // _SV_SALINST_HXX
diff --git a/vcl/inc/sallayout.hxx b/vcl/inc/sallayout.hxx
index e0c13d65a165..afbaa5c629be 100644
--- a/vcl/inc/sallayout.hxx
+++ b/vcl/inc/sallayout.hxx
@@ -56,8 +56,6 @@ class PhysicalFontFace;
 #define SAL_LAYOUT_DISABLE_GLYPH_PROCESSING 0x1000
 #define SAL_LAYOUT_FOR_FALLBACK             0x2000
 
-// -----------------
-
 // used for managing runs e.g. for BiDi, glyph and script fallback
 class VCL_PLUGIN_PUBLIC ImplLayoutRuns
 {
@@ -81,7 +79,6 @@ public:
     bool    PosIsInAnyRun( int nCharPos ) const;
 };
 
-// -----------------
 
 class ImplLayoutArgs
 {
@@ -134,10 +131,6 @@ bool IsDiacritic( sal_UCS4 );
 int GetVerticalFlags( sal_UCS4 );
 sal_UCS4 GetVerticalChar( sal_UCS4 );
 
-// -------------
-// - SalLayout -
-// -------------
-
 typedef sal_uInt32 sal_GlyphId;
 
 // Glyph Flags
@@ -237,10 +230,6 @@ protected:
     Point           maDrawBase;
 };
 
-// ------------------
-// - MultiSalLayout -
-// ------------------
-
 class VCL_PLUGIN_PUBLIC MultiSalLayout : public SalLayout
 {
 public:
@@ -286,10 +275,6 @@ private:
     bool            mbInComplete;
 };
 
-// --------------------
-// - GenericSalLayout -
-// --------------------
-
 struct GlyphItem
 {
     int     mnFlags;
@@ -316,13 +301,9 @@ public:
     bool    IsDiacritic() const     { return ((mnFlags & IS_DIACRITIC) != 0); }
 };
 
-// ---------------
-
 typedef std::list<GlyphItem> GlyphList;
 typedef std::vector<GlyphItem> GlyphVector;
 
-// ---------------
-
 class VCL_PLUGIN_PUBLIC GenericSalLayout : public SalLayout
 {
 public:
diff --git a/vcl/inc/salobj.hxx b/vcl/inc/salobj.hxx
index 6753e10e009c..4e8f6b1af2f8 100644
--- a/vcl/inc/salobj.hxx
+++ b/vcl/inc/salobj.hxx
@@ -35,10 +35,6 @@ struct SystemEnvData;
 #define SAL_OBJECT_CLIP_EXCLUDERECTS            ((sal_uInt16)0x0002)
 #define SAL_OBJECT_CLIP_ABSOLUTE                ((sal_uInt16)0x0004)
 
-// -------------
-// - SalObject -
-// -------------
-
 class VCL_PLUGIN_PUBLIC SalObject
 {
     void*               m_pInst;
diff --git a/vcl/inc/salprn.hxx b/vcl/inc/salprn.hxx
index 2597e529e4bc..63fbbc494c9c 100644
--- a/vcl/inc/salprn.hxx
+++ b/vcl/inc/salprn.hxx
@@ -33,10 +33,6 @@ class SalFrame;
 struct ImplJobSetup;
 namespace vcl { class PrinterController; }
 
-// -----------------------
-// - SalPrinterQueueInfo -
-// -----------------------
-
 struct VCL_PLUGIN_PUBLIC SalPrinterQueueInfo
 {
     rtl::OUString               maPrinterName;
@@ -51,10 +47,6 @@ struct VCL_PLUGIN_PUBLIC SalPrinterQueueInfo
                             ~SalPrinterQueueInfo();
 };
 
-// ------------------
-// - SalInfoPrinter -
-// ------------------
-
 class VCL_PLUGIN_PUBLIC SalInfoPrinter
 {
 public:
@@ -93,10 +85,6 @@ public:
     virtual int                 GetLandscapeAngle( const ImplJobSetup* pSetupData ) = 0;
 };
 
-// --------------
-// - SalPrinter -
-// --------------
-
 class VCL_PLUGIN_PUBLIC SalPrinter
 {
 public:                     // public for Sal Implementation
diff --git a/vcl/inc/salsys.hxx b/vcl/inc/salsys.hxx
index 308c65e927f4..598b5513d9fb 100644
--- a/vcl/inc/salsys.hxx
+++ b/vcl/inc/salsys.hxx
@@ -44,9 +44,6 @@ const int SALSYSTEM_SHOWNATIVEMSGBOX_BTN_YES    = 6;
 const int SALSYSTEM_SHOWNATIVEMSGBOX_BTN_NO     = 7;
 
 
-// -------------
-// - SalSystem -
-// -------------
 class VCL_PLUGIN_PUBLIC SalSystem
 {
 public:
diff --git a/vcl/inc/saltimer.hxx b/vcl/inc/saltimer.hxx
index 0565604d7c8a..5bca38b330e6 100644
--- a/vcl/inc/saltimer.hxx
+++ b/vcl/inc/saltimer.hxx
@@ -24,10 +24,6 @@
 #include <vcl/dllapi.h>
 #include <salwtype.hxx>
 
-// ------------
-// - SalTimer -
-// ------------
-
 /*
  * note: there will be only a single instance of SalTimer
  * SalTimer originally had only static methods, but
diff --git a/vcl/inc/salvd.hxx b/vcl/inc/salvd.hxx
index cf736ac1cb9a..35084c746f4a 100644
--- a/vcl/inc/salvd.hxx
+++ b/vcl/inc/salvd.hxx
@@ -26,10 +26,6 @@
 
 class SalGraphics;
 
-// --------------------
-// - SalVirtualDevice -
-// --------------------
-
 class VCL_PLUGIN_PUBLIC SalVirtualDevice
 {
 public:                     // public for Sal Implementation
diff --git a/vcl/inc/salwtype.hxx b/vcl/inc/salwtype.hxx
index 5902a9882442..7196326a2367 100644
--- a/vcl/inc/salwtype.hxx
+++ b/vcl/inc/salwtype.hxx
@@ -329,10 +329,6 @@ struct SalInputContext
 
 #endif // __cplusplus
 
-// ------------------
-// - SalTimer-Types -
-// ------------------
-
 typedef void (*SALTIMERPROC)();
 
 #endif // _SV_SALWTYPE_HXX
diff --git a/vcl/inc/svdata.hxx b/vcl/inc/svdata.hxx
index ba3791770828..484205d223e9 100644
--- a/vcl/inc/svdata.hxx
+++ b/vcl/inc/svdata.hxx
@@ -96,9 +96,6 @@ class SalData;
 namespace vcl { class DisplayConnection; class SettingsConfigItem; class DeleteOnDeinitBase; }
 namespace utl { class DefaultFontConfiguration; class FontSubstConfiguration; }
 
-// -----------------
-// - ImplSVAppData -
-// -----------------
 class LocaleConfigurationListener : public utl::ConfigurationListener
 {
 public:
@@ -159,10 +156,6 @@ struct ImplSVAppData
 };
 
 
-// -----------------
-// - ImplSVGDIData -
-// -----------------
-
 struct ImplSVGDIData
 {
     OutputDevice*           mpFirstWinGraphics; // First OutputDevice with a Frame Graphics
@@ -191,10 +184,6 @@ struct ImplSVGDIData
 };
 
 
-// -----------------
-// - ImplSVWinData -
-// -----------------
-
 struct ImplSVWinData
 {
     Window*                 mpFirstFrame;       // First FrameWindow
@@ -220,10 +209,6 @@ struct ImplSVWinData
 };
 
 
-// ------------------
-// - ImplSVCtrlData -
-// ------------------
-
 typedef std::vector< std::pair< OUString, FieldUnit > > FieldUnitStringList;
 
 struct ImplSVCtrlData
@@ -252,10 +237,6 @@ struct ImplSVCtrlData
 };
 
 
-// ------------------
-// - ImplSVHelpData -
-// ------------------
-
 struct ImplSVHelpData
 {
     sal_Bool                    mbContextHelp       : 1;    // is ContextHelp enabled
@@ -304,10 +285,6 @@ struct ImplSVNWFData
 };
 
 
-// --------------
-// - ImplSVData -
-// --------------
-
 struct ImplSVData
 {
     SalData*                mpSalData;
@@ -375,22 +352,9 @@ FieldUnitStringList* ImplGetFieldUnits();
 FieldUnitStringList* ImplGetCleanedFieldUnits();
 
 
-// -----------------------------------------------------------------------
-
-// -----------------
-// - ImplSVEmpyStr -
-// -----------------
-
-// Empty-SV-String
-
 inline const String& ImplGetSVEmptyStr()
     { return String::EmptyString(); }
 
-// -----------------------------------------------------------------------
-
-// ----------------------
-// - struct ImplDelData -
-// ----------------------
 // ImplDelData is used as a "dog tag" by a window when it
 // does something that could indirectly destroy the window
 // TODO: wild destruction of a window should not be possible
@@ -417,10 +381,6 @@ private:
     void            AttachToWindow( const Window* );
 };
 
-// ---------------
-// - ImplSVEvent -
-// ---------------
-
 struct ImplSVEvent
 {
     sal_uLong               mnEvent;
diff --git a/vcl/inc/unx/saldata.hxx b/vcl/inc/unx/saldata.hxx
index c84ae020584f..c148b63ba36b 100644
--- a/vcl/inc/unx/saldata.hxx
+++ b/vcl/inc/unx/saldata.hxx
@@ -29,13 +29,10 @@
 #include <osl/module.h>
 #include <vclpluginapi.h>
 
-// -=-= forwards -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class SalXLib;
 class SalDisplay;
 class SalPrinter;
 
-// -=-= typedefs -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 #if defined LINUX || defined NETBSD || defined AIX || \
     defined FREEBSD || defined OPENBSD || defined DRAGONFLY || \
     defined ANDROID
@@ -44,7 +41,6 @@ class SalPrinter;
 typedef unsigned int pthread_t;
 #endif
 
-// -=-= SalData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class VCLPLUG_GEN_PUBLIC X11SalData : public SalGenericData
 {
     static int XErrorHdl( Display*, XErrorEvent* );
diff --git a/vcl/inc/unx/saldisp.hxx b/vcl/inc/unx/saldisp.hxx
index 2bfddda72523..b20684e5ac39 100644
--- a/vcl/inc/unx/saldisp.hxx
+++ b/vcl/inc/unx/saldisp.hxx
@@ -20,7 +20,6 @@
 #ifndef _SV_SALDISP_HXX
 #define _SV_SALDISP_HXX
 
-// -=-= exports =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class   SalDisplay;
 class   SalColormap;
 class   SalVisual;
@@ -41,14 +40,12 @@ class   SalXLib;
 
 #include <vclpluginapi.h>
 
-// -=-= forwards -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class   BitmapPalette;
 class   SalFrame;
 class   ColorMask;
 
 namespace vcl_sal { class WMAdaptor; }
 
-// -=-= #defines -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #define PROPERTY_SUPPORT_WM_Parent_Pixmap_None  0x00000004
 #define PROPERTY_SUPPORT_WM_ClientPos           0x00000008
 #define PROPERTY_SUPPORT_3ButtonMouse           0x00000020
@@ -76,7 +73,6 @@ typedef enum  {
 
 extern "C" srv_vendor_t sal_GetServerVendor( Display *p_display );
 
-// -=-= SalRGB -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 // MSB/Bigendian view (SalColor == RGB, r=0xFF0000, g=0xFF00, b=0xFF)
 
 enum SalRGB { RGB,  RBG,
@@ -87,7 +83,6 @@ enum SalRGB { RGB,  RBG,
               BGRA, BRGA,
               otherSalRGB };
 
-// -=-= SalVisual =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class SalVisual : public XVisualInfo
 {
     SalRGB          eRGBMode_;
@@ -112,7 +107,6 @@ public:
             SalColor        GetTCColor( Pixel nPixel ) const;
 };
 
-// -=-= SalColormap =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class SalColormap
 {
     const SalDisplay*       m_pDisplay;
@@ -157,7 +151,6 @@ public:
     SalColor        GetColor( Pixel nPixel ) const;
 };
 
-// -=-= SalXLib =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 typedef int(*YieldFunc)(int fd, void* data);
 
 class VCLPLUG_GEN_PUBLIC SalXLib
@@ -192,8 +185,6 @@ public:
     bool            CheckTimeout( bool bExecuteTimers = true );
 };
 
-// -=-= SalDisplay -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 class SalI18N_InputMethod;
 class SalI18N_KeyboardExtension;
 class AttributeProvider;
@@ -390,8 +381,6 @@ public:
     virtual void    PostUserEvent() = 0;
 };
 
-// -=-= inlines =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 inline GC SalDisplay::GetGC( sal_uInt16 nDepth, SalX11Screen nXScreen ) const
 { return 1 == nDepth
          ? GetMonoGC( nXScreen )
diff --git a/vcl/inc/unx/salframe.h b/vcl/inc/unx/salframe.h
index c6a8cc30d100..a88686478376 100644
--- a/vcl/inc/unx/salframe.h
+++ b/vcl/inc/unx/salframe.h
@@ -34,14 +34,13 @@
 
 #include <list>
 
-// -=-= forwards -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class   SalDisplay;
 class   X11SalGraphics;
 class   SalI18N_InputContext;
 
 namespace vcl_sal { class WMAdaptor; class NetWMAdaptor; class GnomeWMAdaptor; }
 
-// -=-= X11SalFrame =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+// X11SalFrame
 #define SHOWSTATE_UNKNOWN       -1
 #define SHOWSTATE_MINIMIZED     0
 #define SHOWSTATE_NORMAL        1
diff --git a/vcl/inc/unx/salgdi.h b/vcl/inc/unx/salgdi.h
index 3684dd0c2a32..503872f973ad 100644
--- a/vcl/inc/unx/salgdi.h
+++ b/vcl/inc/unx/salgdi.h
@@ -32,7 +32,6 @@
 
 #include <deque>
 
-// -=-= forwards -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class ImplFontMetricData;
 class FontSelectPattern;
 class SalBitmap;
@@ -51,8 +50,6 @@ namespace basegfx {
     class B2DTrapezoid;
 }
 
-// -=-= SalGraphicsData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 typedef struct FT_FaceRec_* FT_Face;
 
 class CairoFontsCache
@@ -370,8 +367,6 @@ inline Pixel X11SalGraphics::GetPixel( SalColor nSalColor ) const
 { return GetColormap().GetPixel( nSalColor ); }
 
 
-// -=-= Shortcuts =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
 #ifdef DBG_UTIL
 #define stderr0( s )            fprintf( stderr, s )
 #else
diff --git a/vcl/inc/unx/salinst.h b/vcl/inc/unx/salinst.h
index 83ba4b87fa3f..ea41c55ccb5e 100644
--- a/vcl/inc/unx/salinst.h
+++ b/vcl/inc/unx/salinst.h
@@ -28,7 +28,6 @@
 #include "generic/geninst.h"
 
 
-// -=-= SalInstanceData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class SalXLib;
 class VCLPLUG_GEN_PUBLIC X11SalInstance : public SalGenericInstance
 {
diff --git a/vcl/inc/unx/salstd.hxx b/vcl/inc/unx/salstd.hxx
index 73a2868836ce..dd37938c6834 100644
--- a/vcl/inc/unx/salstd.hxx
+++ b/vcl/inc/unx/salstd.hxx
@@ -22,7 +22,6 @@
 
 #include <tools/solar.h>
 
-// -=-= X-Lib forwards -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #ifndef _SVUNX_H
 typedef unsigned long       Pixel;
 typedef unsigned long       XID;
diff --git a/vcl/inc/unx/salunx.h b/vcl/inc/unx/salunx.h
index 36de29b7014f..5061ad919e16 100644
--- a/vcl/inc/unx/salunx.h
+++ b/vcl/inc/unx/salunx.h
@@ -24,7 +24,6 @@
 #include <unx/svunx.h>
 #include <unx/salstd.hxx>
 
-// -=-= inlines =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline long Divide( long nDividend, long nDivisor )
 { return (nDividend + nDivisor/2) / nDivisor; }
 
diff --git a/vcl/inc/unx/salunxtime.h b/vcl/inc/unx/salunxtime.h
index d2d49165e791..a10033b3ee06 100644
--- a/vcl/inc/unx/salunxtime.h
+++ b/vcl/inc/unx/salunxtime.h
@@ -30,7 +30,6 @@
 #endif
 #include <sal/types.h>
 
-// -=-= timeval =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 inline int operator >= ( const timeval &t1, const timeval &t2 )
 {
     if( t1.tv_sec == t2.tv_sec )
diff --git a/vcl/inc/unx/salvd.h b/vcl/inc/unx/salvd.h
index edebd52ebcd6..50e2cd4700f6 100644
--- a/vcl/inc/unx/salvd.h
+++ b/vcl/inc/unx/salvd.h
@@ -24,11 +24,9 @@
 #include <unx/saltype.h>
 #include <salvd.hxx>
 
-// -=-= forwards -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 class SalDisplay;
 class X11SalGraphics;
 
-// -=-= SalVirDevData -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 class X11SalVirtualDevice : public SalVirtualDevice
 {
     SalDisplay      *pDisplay_;
diff --git a/vcl/inc/vcl/svapp.hxx b/vcl/inc/vcl/svapp.hxx
index b2c52ec41c1c..e605f57e993c 100644
--- a/vcl/inc/vcl/svapp.hxx
+++ b/vcl/inc/vcl/svapp.hxx
@@ -78,25 +78,11 @@ namespace awt {
 VCL_DLLPUBLIC sal_UCS4 GetMirroredChar( sal_UCS4 );
 VCL_DLLPUBLIC sal_UCS4 GetLocalizedChar( sal_UCS4, LanguageType );
 
-// --------------------
-// - SystemWindowMode -
-// --------------------
-
 #define SYSTEMWINDOW_MODE_NOAUTOMODE    ((sal_uInt16)0x0001)
 #define SYSTEMWINDOW_MODE_DIALOG        ((sal_uInt16)0x0002)
 
-// -------------
-// - EventHook -
-// -------------
-
 typedef long (*VCLEventHookProc)( NotifyEvent& rEvt, void* pData );
 
-// --------------------
-// - ApplicationEvent -
-// --------------------
-
-// Build in again, in order to make AppEvents work on MACs
-
 // ATTENTION: ENUM duplicate in daemon.cxx under Unix!
 
 #ifdef UNX
@@ -128,9 +114,6 @@ private:
     rtl::OUString aData;
 };
 
-// ---------------
-// - Application -
-// ---------------
 
 class VCL_DLLPUBLIC Application
 {
diff --git a/vcl/inc/win/saldata.hxx b/vcl/inc/win/saldata.hxx
index d6f60e459b00..b35e3be60044 100644
--- a/vcl/inc/win/saldata.hxx
+++ b/vcl/inc/win/saldata.hxx
@@ -42,18 +42,10 @@ struct TempFontItem;
 
 typedef HRESULT (WINAPI  *DwmIsCompositionEnabled_ptr)(BOOL*);
 
-// --------------------
-// - Standard-Defines -
-// --------------------
-
 #define MAX_STOCKPEN            4
 #define MAX_STOCKBRUSH          4
 #define SAL_CLIPRECT_COUNT      16
 
-// --------------------
-// - Icon cache       -
-// --------------------
-
 struct SalIcon
 {
     int     nId;
@@ -62,10 +54,6 @@ struct SalIcon
     SalIcon *pNext;
 };
 
-// -----------
-// - SalData -
-// -----------
-
 class SalData
 {
 public:
@@ -141,10 +129,6 @@ public:
 inline void SetSalData( SalData* pData ) { ImplGetSVData()->mpSalData = pData; }
 inline SalData* GetSalData() { return ImplGetSVData()->mpSalData; }
 
-// --------------
-// - SalShlData -
-// --------------
-
 struct SalShlData
 {
     HINSTANCE               mhInst;                 // Instance of SAL-DLL
@@ -157,10 +141,6 @@ struct SalShlData
 
 extern SalShlData aSalShlData;
 
-// ------------
-// - GDICache -
-// ------------
-
 #define CACHESIZE_HDC       3
 #define CACHED_HDC_1        0
 #define CACHED_HDC_2        1
@@ -219,10 +199,6 @@ rtl_TextEncoding ImplSalGetSystemEncoding();
 OUString ImplSalGetUniString( const sal_Char* pStr, xub_StrLen nLen = STRING_LEN );
 int ImplSalWICompareAscii( const wchar_t* pStr1, const char* pStr2 );
 
-// -----------
-// - Defines -
-// -----------
-
 #define SAL_FRAME_WNDEXTRA          sizeof( DWORD )
 #define SAL_FRAME_THIS              0
 #define SAL_FRAME_CLASSNAMEA        "SALFRAME"
@@ -309,10 +285,6 @@ int ImplSalWICompareAscii( const wchar_t* pStr1, const char* pStr2 );
 #define SALOBJ_MSG_POSTFOCUS        (WM_USER+161)
 
 
-// -----------------
-// - Helpfunctions -
-// -----------------
-
 // A/W-Wrapper
 BOOL    ImplPostMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam );
 BOOL    ImplSendMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam );
diff --git a/vcl/inc/win/salinst.h b/vcl/inc/win/salinst.h
index 8055103c2946..e73070020b8c 100644
--- a/vcl/inc/win/salinst.h
+++ b/vcl/inc/win/salinst.h
@@ -22,10 +22,6 @@
 
 #include <salinst.hxx>
 
-// -------------------
-// - SalInstanceData -
-// -------------------
-
 class SalYieldMutex;
 
 class WinSalInstance : public SalInstance
@@ -81,10 +77,6 @@ public:
     static int WorkaroundExceptionHandlingInUSER32Lib(int nExcept, LPEXCEPTION_POINTERS pExceptionInfo);
 };
 
-// --------------
-// - Prototypen -
-// --------------
-
 SalFrame* ImplSalCreateFrame( WinSalInstance* pInst, HWND hWndParent, sal_uIntPtr nSalFrameStyle );
 SalObject* ImplSalCreateObject( WinSalInstance* pInst, WinSalFrame* pParent );
 HWND ImplSalReCreateHWND( HWND hWndParent, HWND oldhWnd, sal_Bool bAsChild );
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 )