vcl: migrate rest of clipping functions from clipping.hxx into clipmgr.hxx

Change-Id: If4646d96bafb113004dd6965d26f29e2194d237e

11 files changed, 689 insertions, 663 deletions

diff --git a/canvas/source/vcl/spritecanvashelper.cxx b/canvas/source/vcl/spritecanvashelper.cxx
index 13ae62900f2b..ed12fde5baa1 100644
--- a/canvas/source/vcl/spritecanvashelper.cxx
+++ b/canvas/source/vcl/spritecanvashelper.cxx
@@ -27,6 +27,7 @@
 #include <vcl/outdev.hxx>
 #include <vcl/window.hxx>
 #include <vcl/bitmapex.hxx>
+#include <vcl/clipmgr.hxx>
 
 #include <basegfx/range/b2drectangle.hxx>
 #include <basegfx/tools/canvastools.hxx>
@@ -244,6 +245,8 @@ namespace vclcanvas
     bool SpriteCanvasHelper::updateScreen( bool bUpdateAll,
                                            bool&    io_bSurfaceDirty )
     {
+        ClipManager *clipMgr = ClipManager::GetInstance();
+
         if( !mpRedrawManager ||
             !mpOwningSpriteCanvas ||
             !mpOwningSpriteCanvas->getFrontBuffer() ||
@@ -277,7 +280,7 @@ namespace vclcanvas
             // be redrawn otherwise)
             const Region aFullWindowRegion( Rectangle(aEmptyPoint,
                                                       aOutDevSize) );
-            pTargetWindow->ExpandPaintClipRegion(aFullWindowRegion);
+            clipMgr->ExpandPaintClipRegion( pTargetWindow, aFullWindowRegion);
         }
 
         // TODO(P1): Might be worthwile to track areas of background
diff --git a/include/vcl/clipmgr.hxx b/include/vcl/clipmgr.hxx
index 0cab25298422..de00306c6fac 100644
--- a/include/vcl/clipmgr.hxx
+++ b/include/vcl/clipmgr.hxx
@@ -35,28 +35,59 @@ private:
 
     void clipSiblings( Window* pWindow, Region& rRegion );
     void intersectClipRegion( Window* pWindow, Region& rRegion );
+    void intersectAndUnionOverlapWindows(Window* pWindow, const Region& rInterRegion, Region& rRegion);
     void excludeOverlapWindows( Window *pWindow, Region& rRegion );
     void initChildClipRegion( Window *pWindow );
 
+    bool clipSysObject( Window *pWindow, const Region* pOldRegion );
+    void updateSysObjChildrenClip( Window *pWindow );
+    void updateSysObjOverlapsClip( Window *pWindow );
+
 public:
     ~ClipManager() { instanceFlag = false; }
     static ClipManager *GetInstance();
 
+    void Init( Window *pWindow );
+    void InitClipRegion( Window *pWindow );
+
+    Region GetActiveClipRegion( const Window *pWindow ) const;
+    void ClipToPaintRegion( Window *pWindow, Rectangle& rDstRect );
+
+    bool SetClipFlag( Window *pWindow, bool bSysObjOnlySmaller = false );
+    bool SetClipFlagChildren( Window *pWindow, bool bSysObjOnlySmaller = false );
+    bool SetClipFlagOverlapWindows( Window *pWindow, bool bSysObjOnlySmaller = false );
+
     void EnableClipSiblings( Window *pWindow, bool bClipSiblings = true );
     void SetParentClipMode( Window* pWindow, sal_uInt16 nMode );
     sal_uInt16 GetParentClipMode( Window* pWindow ) const;
 
     bool IsOverlapWindow( Window* pWindow ) const;
+    void CalcOverlapRegionOverlaps( Window* pWindow, const Region& rInterRegion, Region& rRegion );
+    void CalcOverlapRegion( Window* pWindow, const Rectangle& rSourceRect, Region& rRegion,
+                            bool bChildren, bool bParent, bool bSiblings );
 
-    void InitClipRegion( Window *pWindow );
     void ClipBoundaries( Window* pWindow, Region& rRegion, bool bThis, bool bOverlaps );
     bool ClipChildren( Window *pWindow, Region& rRegion );
     void ClipAllChildren( Window *pWindow, Region& rRegion );
     Region* GetChildClipRegion( Window* pWindow );
     bool ClipCoversWholeWindow( Window *pWindow );
 
+    void SaveBackground( Window *pWindow, const Point& rPos, const Size& rSize,
+                         const Point& rDestOff, VirtualDevice& rSaveDevice );
+    void SaveOverlapBackground( Window *pWindow );
+    bool RestoreOverlapBackground( Window *pWindow, Region& rInvRegion );
+    void DeleteOverlapBackground( Window *pWindow );
+    void InvalidateAllOverlapBackgrounds( Window *pWindow );
+
+    void UpdateSysObjClip( Window *pWindow );
+
     void Intersect( Window* pWindow, Region& rRegion );
     void Exclude( Window *pWindow, Region& rRegion );
+
+    /** Adds the submitted region to the paint clip region so you can
+        paint additional parts of your window if necessary.
+     */
+    void ExpandPaintClipRegion( Window *pWindow, const Region& rRegion );
 };
 
 #endif
diff --git a/include/vcl/window.hxx b/include/vcl/window.hxx
index 3ab4fa7e670d..62517ed4f5c7 100644
--- a/include/vcl/window.hxx
+++ b/include/vcl/window.hxx
@@ -401,8 +401,6 @@ public:
     SAL_DLLPRIVATE void                 ImplInvalidateFrameRegion( const Region* pRegion, sal_uInt16 nFlags );
     SAL_DLLPRIVATE void                 ImplInvalidateOverlapFrameRegion( const Region& rRegion );
 
-    SAL_DLLPRIVATE bool                 ImplSetClipFlag( bool bSysObjOnlySmaller = false );
-
     SAL_DLLPRIVATE bool                 ImplIsWindowOrChild( const Window* pWindow, bool bSystemWindow = false ) const;
     SAL_DLLPRIVATE bool                 ImplIsChild( const Window* pWindow, bool bSystemWindow = false ) const;
     SAL_DLLPRIVATE bool                 ImplIsFloatingWindow() const;
@@ -429,8 +427,6 @@ public:
 
     SAL_DLLPRIVATE void                 ImplUpdateAll( bool bOverlapWindows = true );
 
-    SAL_DLLPRIVATE void                 ImplDeleteOverlapBackground();
-
     SAL_DLLPRIVATE void                 ImplControlFocus( sal_uInt16 nFlags = 0 );
 
     SAL_DLLPRIVATE void                 ImplMirrorFramePos( Point &pt ) const;
@@ -470,13 +466,6 @@ protected:
 
     SAL_DLLPRIVATE void                 ImplScroll( const Rectangle& rRect, long nHorzScroll, long nVertScroll, sal_uInt16 nFlags );
 
-    SAL_DLLPRIVATE void                 ImplSaveOverlapBackground();
-    SAL_DLLPRIVATE bool                 ImplRestoreOverlapBackground( Region& rInvRegion );
-    SAL_DLLPRIVATE void                 ImplInvalidateAllOverlapBackgrounds();
-
-    SAL_DLLPRIVATE bool                 ImplSetClipFlagChildren( bool bSysObjOnlySmaller = false );
-    SAL_DLLPRIVATE bool                 ImplSetClipFlagOverlapWindows( bool bSysObjOnlySmaller = false );
-
     SAL_DLLPRIVATE WinBits              ImplInitRes( const ResId& rResId );
     SAL_DLLPRIVATE WindowResHeader      ImplLoadResHeader( const ResId& rResId );
     SAL_DLLPRIVATE void                 ImplLoadRes( const ResId& rResId );
@@ -512,17 +501,6 @@ private:
     SAL_DLLPRIVATE void                 ImplPointToLogic( Font& rFont ) const;
     SAL_DLLPRIVATE void                 ImplLogicToPoint( Font& rFont ) const;
 
-    SAL_DLLPRIVATE bool                 ImplSysObjClip( const Region* pOldRegion );
-    SAL_DLLPRIVATE void                 ImplUpdateSysObjChildrenClip();
-    SAL_DLLPRIVATE void                 ImplUpdateSysObjOverlapsClip();
-    SAL_DLLPRIVATE void                 ImplUpdateSysObjClip();
-
-    SAL_DLLPRIVATE void                 ImplIntersectAndUnionOverlapWindows( const Region& rInterRegion, Region& rRegion );
-    SAL_DLLPRIVATE void                 ImplIntersectAndUnionOverlapWindows2( const Region& rInterRegion, Region& rRegion );
-    SAL_DLLPRIVATE void                 ImplCalcOverlapRegionOverlaps( const Region& rInterRegion, Region& rRegion );
-    SAL_DLLPRIVATE void                 ImplCalcOverlapRegion( const Rectangle& rSourceRect, Region& rRegion,
-                                                               bool bChildren, bool bParent, bool bSiblings );
-
     SAL_DLLPRIVATE void                 ImplCallPaint( const Region* pRegion, sal_uInt16 nPaintFlags );
     SAL_DLLPRIVATE void                 ImplCallOverlapPaint();
     SAL_DLLPRIVATE void                 ImplPostPaint();
@@ -772,10 +750,6 @@ public:
     bool                                ClipCoversWholeWindow();
     Region                              GetPaintRegion() const;
     bool                                IsInPaint() const;
-    // while IsInPaint returns true ExpandPaintClipRegion adds the
-    // submitted region to the paint clip region so you can
-    // paint additional parts of your window if necessary
-    void                                ExpandPaintClipRegion( const Region& rRegion );
 
     void                                SetParent( Window* pNewParent );
     Window*                             GetParent() const;
@@ -1037,9 +1011,6 @@ public:
                                                              ScrollBar* pHScrl = NULL,
                                                              ScrollBar* pVScrl = NULL );
 
-    void                                SaveBackground( const Point& rPos, const Size& rSize,
-                                                        const Point& rDestOff, VirtualDevice& rSaveDevice );
-
     const SystemEnvData*                GetSystemData() const;
     ::com::sun::star::uno::Any          GetSystemDataAny() const;
 
diff --git a/vcl/source/gdi/impanmvw.cxx b/vcl/source/gdi/impanmvw.cxx
index bf870819c408..93e7a7069230 100644
--- a/vcl/source/gdi/impanmvw.cxx
+++ b/vcl/source/gdi/impanmvw.cxx
@@ -20,6 +20,8 @@
 #include "impanmvw.hxx"
 #include <vcl/virdev.hxx>
 #include <vcl/window.hxx>
+#include <vcl/clipmgr.hxx>
+
 #include <tools/helpers.hxx>
 #include <boost/scoped_ptr.hpp>
 
@@ -42,6 +44,8 @@ ImplAnimView::ImplAnimView( Animation* pParent, OutputDevice* pOut,
         mbHMirr         ( maSz.Width() < 0L ),
         mbVMirr         ( maSz.Height() < 0L )
 {
+    ClipManager *pClipMgr = ClipManager::GetInstance();
+
     Animation::ImplIncAnimCount();
 
     // Mirrored horizontally?
@@ -78,7 +82,7 @@ ImplAnimView::ImplAnimView( Animation* pParent, OutputDevice* pOut,
         MapMode aTempMap( mpOut->GetMapMode() );
         aTempMap.SetOrigin( Point() );
         mpBackground->SetMapMode( aTempMap );
-        ( (Window*) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
+        pClipMgr->SaveBackground( (Window*) mpOut, maDispPt, maDispSz, Point(), *mpBackground );
         mpBackground->SetMapMode( MapMode() );
     }
     else
@@ -289,6 +293,8 @@ void ImplAnimView::ImplDraw( sal_uLong nPos, VirtualDevice* pVDev )
 
 void ImplAnimView::ImplRepaint()
 {
+    ClipManager *pClipMgr = ClipManager::GetInstance();
+
     const bool bOldPause = mbPause;
 
     if( mpOut->GetOutDevType() == OUTDEV_WINDOW )
@@ -296,7 +302,7 @@ void ImplAnimView::ImplRepaint()
         MapMode aTempMap( mpOut->GetMapMode() );
         aTempMap.SetOrigin( Point() );
         mpBackground->SetMapMode( aTempMap );
-        ( (Window*) mpOut )->SaveBackground( maDispPt, maDispSz, Point(), *mpBackground );
+        pClipMgr->SaveBackground( (Window*) mpOut, maDispPt, maDispSz, Point(), *mpBackground );
         mpBackground->SetMapMode( MapMode() );
     }
     else
diff --git a/vcl/source/window/clipmgr.cxx b/vcl/source/window/clipmgr.cxx
index 487bb4036d4d..2b92cbeaee3f 100644
--- a/vcl/source/window/clipmgr.cxx
+++ b/vcl/source/window/clipmgr.cxx
@@ -27,6 +27,10 @@
 #include <salobj.hxx>
 #include <window.h>
 
+#define IMPL_MAXSAVEBACKSIZE    (640*480)
+#define IMPL_MAXALLSAVEBACKSIZE (800*600*2)
+
+
 bool ClipManager::instanceFlag = false;
 ClipManager* ClipManager::single = NULL;
 
@@ -68,6 +72,100 @@ sal_uInt16 ClipManager::GetParentClipMode( Window* pWindow ) const
         return pWindow->mpWindowImpl->mnParentClipMode;
 }
 
+bool ClipManager::SetClipFlagChildren( Window *pWindow, bool bSysObjOnlySmaller )
+{
+    bool bUpdate = true;
+    if ( pWindow->mpWindowImpl->mpSysObj )
+    {
+        Region* pOldRegion = NULL;
+        if ( bSysObjOnlySmaller && !pWindow->mpWindowImpl->mbInitWinClipRegion )
+            pOldRegion = new Region( pWindow->mpWindowImpl->maWinClipRegion );
+
+        pWindow->mbInitClipRegion = true;
+        pWindow->mpWindowImpl->mbInitWinClipRegion = true;
+
+        Window* pChildWindow = pWindow->mpWindowImpl->mpFirstChild;
+        while ( pChildWindow )
+        {
+            if ( !SetClipFlagChildren( pChildWindow, bSysObjOnlySmaller ) )
+                bUpdate = false;
+            pChildWindow = pChildWindow->mpWindowImpl->mpNext;
+        }
+
+        if ( !clipSysObject( pWindow, pOldRegion ) )
+        {
+            pWindow->mbInitClipRegion = true;
+            pWindow->mpWindowImpl->mbInitWinClipRegion = true;
+            bUpdate = false;
+        }
+
+        delete pOldRegion;
+    }
+    else
+    {
+        pWindow->mbInitClipRegion = true;
+        pWindow->mpWindowImpl->mbInitWinClipRegion = true;
+
+        Window* pChildWindow = pWindow->mpWindowImpl->mpFirstChild;
+        while ( pChildWindow )
+        {
+            if ( !SetClipFlagChildren( pChildWindow, bSysObjOnlySmaller ) )
+                bUpdate = false;
+            pChildWindow = pChildWindow->mpWindowImpl->mpNext;
+        }
+    }
+    return bUpdate;
+}
+
+bool ClipManager::SetClipFlagOverlapWindows( Window *pWindow, bool bSysObjOnlySmaller )
+{
+    bool bUpdate = SetClipFlagChildren( pWindow, bSysObjOnlySmaller );
+
+    Window* pOverlapWindow = pWindow->mpWindowImpl->mpFirstOverlap;
+    while ( pOverlapWindow )
+    {
+        if ( !SetClipFlagOverlapWindows( pOverlapWindow, bSysObjOnlySmaller ) )
+            bUpdate = false;
+        pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
+    }
+
+    return bUpdate;
+}
+
+bool ClipManager::SetClipFlag( Window *pWindow, bool bSysObjOnlySmaller )
+{
+    if ( !IsOverlapWindow( pWindow ) )
+    {
+        bool bUpdate = SetClipFlagChildren( pWindow, bSysObjOnlySmaller );
+
+        Window* pParent = pWindow->ImplGetParent();
+        if ( pParent &&
+             ((pParent->GetStyle() & WB_CLIPCHILDREN) || (pWindow->mpWindowImpl->mnParentClipMode & PARENTCLIPMODE_CLIP)) )
+        {
+            pParent->mbInitClipRegion = true;
+            pParent->mpWindowImpl->mbInitChildRegion = true;
+        }
+
+        // siblings should recalculate their clip region
+        if ( pWindow->mpWindowImpl->mbClipSiblings )
+        {
+            Window* pNextWindow = pWindow->mpWindowImpl->mpNext;
+            while ( pNextWindow )
+            {
+                if ( !SetClipFlagChildren( pNextWindow, bSysObjOnlySmaller ) )
+                    bUpdate = false;
+                pNextWindow = pNextWindow->mpWindowImpl->mpNext;
+            }
+        }
+
+        return bUpdate;
+    }
+    else
+    {
+        return SetClipFlagOverlapWindows( pWindow->mpWindowImpl->mpFrameWindow, bSysObjOnlySmaller );
+    }
+}
+
 void ClipManager::EnableClipSiblings( Window *pWindow, bool bClipSiblings )
 {
 
@@ -77,6 +175,37 @@ void ClipManager::EnableClipSiblings( Window *pWindow, bool bClipSiblings )
     pWindow->mpWindowImpl->mbClipSiblings = bClipSiblings;
 }
 
+void ClipManager::Init( Window *pWindow )
+{
+    Region  aRegion;
+
+    // Put back backed up background
+    if ( pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin )
+        InvalidateAllOverlapBackgrounds( pWindow );
+    if ( pWindow->mpWindowImpl->mbInPaint )
+        aRegion = *(pWindow->mpWindowImpl->mpPaintRegion);
+    else
+    {
+        aRegion = *(GetChildClipRegion( pWindow ));
+        // --- RTL -- only this region is in frame coordinates, so re-mirror it
+        // the mpWindowImpl->mpPaintRegion above is already correct (see ImplCallPaint()) !
+        if( pWindow->ImplIsAntiparallel() )
+            pWindow->ReMirror ( aRegion );
+    }
+    if ( pWindow->mbClipRegion )
+        aRegion.Intersect( pWindow->ImplPixelToDevicePixel( pWindow->maRegion ) );
+    if ( aRegion.IsEmpty() )
+        pWindow->mbOutputClipped = true;
+    else
+    {
+        pWindow->mbOutputClipped = false;
+        pWindow->SelectClipRegion( aRegion );
+    }
+    pWindow->mbClipRegionSet = true;
+
+    pWindow->mbInitClipRegion = false;
+}
+
 void ClipManager::InitClipRegion( Window *pWindow )
 {
     // Build Window region
@@ -106,7 +235,9 @@ bool ClipManager::IsOverlapWindow( Window* pWindow ) const
 void ClipManager::ClipBoundaries( Window* pWindow, Region& rRegion, bool bThis, bool bOverlaps )
 {
     if ( bThis )
+    {
         intersectClipRegion( pWindow, rRegion );
+    }
     else if ( IsOverlapWindow( pWindow ) )
     {
         // clip to frame if required
@@ -192,10 +323,289 @@ Region* ClipManager::GetChildClipRegion( Window* pWindow )
         return &pWindow->mpWindowImpl->maWinClipRegion;
 }
 
+void ClipManager::SaveBackground( Window *pWindow, const Point& rPos, const Size& rSize,
+                                  const Point& rDestOff, VirtualDevice& rSaveDevice )
+{
+    if ( pWindow->mpWindowImpl->mpPaintRegion )
+    {
+        Region aClip( *pWindow->mpWindowImpl->mpPaintRegion );
+        const Point aPixPos( pWindow->LogicToPixel( rPos ) );
+
+        aClip.Move( -pWindow->mnOutOffX, -pWindow->mnOutOffY );
+        aClip.Intersect( Rectangle( aPixPos, pWindow->LogicToPixel( rSize ) ) );
+
+        if ( !aClip.IsEmpty() )
+        {
+            const Region aOldClip( rSaveDevice.GetClipRegion() );
+            const Point aPixOffset( rSaveDevice.LogicToPixel( rDestOff ) );
+            const bool bMap = rSaveDevice.IsMapModeEnabled();
+
+            // move clip region to have the same distance to DestOffset
+            aClip.Move( aPixOffset.X() - aPixPos.X(), aPixOffset.Y() - aPixPos.Y() );
+
+            // set pixel clip region
+            rSaveDevice.EnableMapMode( false );
+            rSaveDevice.SetClipRegion( aClip );
+            rSaveDevice.EnableMapMode( bMap );
+            rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *pWindow );
+            rSaveDevice.SetClipRegion( aOldClip );
+        }
+    }
+    else
+    {
+        rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *pWindow );
+    }
+}
+
+void ClipManager::SaveOverlapBackground( Window *pWindow )
+{
+    DBG_ASSERT( !pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev, "ClipManger::SaveOverlapBackground() - Background already saved" );
+
+    if ( !pWindow->mpWindowImpl->mbFrame )
+    {
+        sal_uLong nSaveBackSize = pWindow->mnOutWidth * pWindow->mnOutHeight;
+        if ( nSaveBackSize <= IMPL_MAXSAVEBACKSIZE )
+        {
+            if ( nSaveBackSize + pWindow->mpWindowImpl->mpFrameData->mnAllSaveBackSize <= IMPL_MAXALLSAVEBACKSIZE )
+            {
+                Size aOutSize = pWindow->GetOutputSizePixel();
+
+                pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev = new VirtualDevice( *pWindow->mpWindowImpl->mpFrameWindow );
+                if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev->SetOutputSizePixel( aOutSize ) )
+                {
+                    pWindow->mpWindowImpl->mpFrameWindow->ImplUpdateAll();
+
+                    if ( pWindow->mpWindowImpl->mbInitWinClipRegion )
+                        InitClipRegion( pWindow );
+
+                    pWindow->mpWindowImpl->mpOverlapData->mnSaveBackSize = nSaveBackSize;
+                    pWindow->mpWindowImpl->mpFrameData->mnAllSaveBackSize += nSaveBackSize;
+
+                    Point aDevPt;
+                    OutputDevice *pOutDev = pWindow->mpWindowImpl->mpFrameWindow->GetOutDev();
+                    pOutDev->ImplGetFrameDev( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
+                                              aDevPt, aOutSize,
+                                              *(pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev) );
+                    pWindow->mpWindowImpl->mpOverlapData->mpNextBackWin = pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin;
+                    pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin = pWindow;
+                }
+                else
+                {
+                    delete pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev;
+                    pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL;
+                }
+            }
+        }
+    }
+}
+
+bool ClipManager::RestoreOverlapBackground( Window *pWindow, Region& rInvRegion )
+{
+    if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev )
+    {
+        if ( pWindow->mpWindowImpl->mbInitWinClipRegion )
+            InitClipRegion( pWindow );
+
+        if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev )
+        {
+            Point aDevPt;
+            Point aDestPt( pWindow->mnOutOffX, pWindow->mnOutOffY );
+            Size aDevSize = pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev->GetOutputSizePixel();
+
+            OutputDevice *pOutDev = pWindow->mpWindowImpl->mpFrameWindow->GetOutDev();
+
+            if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn )
+            {
+                pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->Intersect( pWindow->mpWindowImpl->maWinClipRegion );
+                rInvRegion = pWindow->mpWindowImpl->maWinClipRegion;
+                rInvRegion.Exclude( *pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn );
+                pOutDev->ImplDrawFrameDev( aDestPt, aDevPt, aDevSize,
+                                           *(pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev),
+                                           *pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn );
+            }
+            else
+            {
+                pOutDev->ImplDrawFrameDev( aDestPt, aDevPt, aDevSize,
+                                           *(pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev),
+                                           pWindow->mpWindowImpl->maWinClipRegion );
+            }
+            DeleteOverlapBackground( pWindow );
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+void ClipManager::DeleteOverlapBackground( Window *pWindow )
+{
+    if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev )
+    {
+        pWindow->mpWindowImpl->mpFrameData->mnAllSaveBackSize -= pWindow->mpWindowImpl->mpOverlapData->mnSaveBackSize;
+        delete pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev;
+        pWindow->mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL;
+        if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn )
+        {
+            delete pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn;
+            pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn = NULL;
+        }
+
+        // remove window from the list
+        if ( pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin == pWindow )
+            pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin = pWindow->mpWindowImpl->mpOverlapData->mpNextBackWin;
+        else
+        {
+            Window* pTemp = pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin;
+            while ( pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin != pWindow )
+                pTemp = pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin;
+            pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin = pWindow->mpWindowImpl->mpOverlapData->mpNextBackWin;
+        }
+        pWindow->mpWindowImpl->mpOverlapData->mpNextBackWin = NULL;
+    }
+}
+
+void ClipManager::InvalidateAllOverlapBackgrounds( Window *pWindow )
+{
+    Window* pBackWindow = pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin;
+    while ( pBackWindow )
+    {
+        // remember next window here already, as this window could
+        // be removed within the next if clause from the list
+        Window* pNext = pBackWindow->mpWindowImpl->mpOverlapData->mpNextBackWin;
+
+        if ( pWindow->ImplIsWindowInFront( pBackWindow ) )
+        {
+            Rectangle aRect1( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
+                              pWindow->GetOutputSizePixel() );
+            Rectangle aRect2( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
+                              pBackWindow->GetOutputSizePixel() );
+            aRect1.Intersection( aRect2 );
+            if ( !aRect1.IsEmpty() )
+            {
+                if ( !pBackWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn )
+                    pBackWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn = new Region( aRect2 );
+                pBackWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->Exclude( aRect1 );
+                if ( pBackWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->IsEmpty() )
+                    DeleteOverlapBackground( pBackWindow );
+            }
+
+        }
+
+        pBackWindow = pNext;
+    }
+}
+
+
+void ClipManager::CalcOverlapRegion( Window *pWindow,
+                                     const Rectangle& rSourceRect, Region& rRegion,
+                                     bool bChildren, bool bParent, bool bSiblings )
+{
+    Region aRegion( rSourceRect );
+
+    if ( pWindow->mpWindowImpl->mbWinRegion )
+        rRegion.Intersect( pWindow->ImplPixelToDevicePixel( pWindow->mpWindowImpl->maWinRegion ) );
+
+    CalcOverlapRegionOverlaps( pWindow, aRegion, rRegion );
+
+    // Parent-Boundaries
+    if ( bParent )
+    {
+        Window *pParentWindow = pWindow;
+        if ( !IsOverlapWindow( pWindow ) )
+        {
+            pParentWindow = pWindow->ImplGetParent();
+            do
+            {
+                Region aExcludedRegion = aRegion;
+                Exclude( pParentWindow, aExcludedRegion );
+                rRegion.Union( aExcludedRegion );
+                if ( IsOverlapWindow( pParentWindow ) )
+                    break;
+                pParentWindow = pParentWindow->ImplGetParent();
+            }
+            while ( pParentWindow );
+        }
+        if ( pParentWindow && !pParentWindow->mpWindowImpl->mbFrame )
+        {
+            Region aExcludedRegion( aRegion );
+            aExcludedRegion.Exclude( Rectangle( Point( 0, 0 ), pWindow->GetOutputSizePixel() ) );
+            rRegion.Union( aExcludedRegion );
+        }
+    }
+
+    // Siblings
+    if ( bSiblings && !IsOverlapWindow( pWindow ) )
+    {
+        Window *pNextWindow = pWindow->mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
+        do
+        {
+            if ( pNextWindow->mpWindowImpl->mbReallyVisible && (pNextWindow != pWindow) )
+            {
+                Region aIntersectRegion( aRegion );
+                Intersect( pNextWindow, aIntersectRegion );
+                rRegion.Union( aIntersectRegion );
+            }
+            pNextWindow = pNextWindow->mpWindowImpl->mpNext;
+        }
+        while ( pNextWindow );
+    }
+
+    if ( bChildren )
+    {
+        Window *pChildWindow = pWindow->mpWindowImpl->mpFirstChild;
+        while ( pChildWindow )
+        {
+            if ( pChildWindow->mpWindowImpl->mbReallyVisible )
+            {
+                Region aIntersectRegion( aRegion );
+                Intersect( pChildWindow, aIntersectRegion );
+                rRegion.Union( aIntersectRegion );
+            }
+            pChildWindow = pChildWindow->mpWindowImpl->mpNext;
+        }
+    }
+}
+
+void ClipManager::CalcOverlapRegionOverlaps( Window* pWindow, const Region& rInterRegion, Region& rRegion )
+{
+    // Clip Overlap Siblings
+    Window* pStartOverlapWindow;
+    if ( !IsOverlapWindow( pWindow ) )
+        pStartOverlapWindow = pWindow->mpWindowImpl->mpOverlapWindow;
+    else
+        pStartOverlapWindow = pWindow;
+    while ( !pStartOverlapWindow->mpWindowImpl->mbFrame )
+    {
+        Window* pOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
+        while ( pOverlapWindow && (pOverlapWindow != pStartOverlapWindow) )
+        {
+            if ( pOverlapWindow->mpWindowImpl->mbReallyVisible )
+            {
+                Region aIntersectRegion( rInterRegion );
+                Intersect( pWindow, aIntersectRegion );
+                rRegion.Union( aIntersectRegion );
+            }
+
+            intersectAndUnionOverlapWindows( pOverlapWindow, rInterRegion, rRegion );
+            pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
+        }
+        pStartOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow;
+    }
+
+    // Clip Child Overlap Windows
+    if ( !IsOverlapWindow( pWindow ) )
+        intersectAndUnionOverlapWindows( pWindow->mpWindowImpl->mpOverlapWindow, rInterRegion, rRegion );
+    else
+        intersectAndUnionOverlapWindows( pWindow, rInterRegion, rRegion );
+}
+
+
 void ClipManager::Intersect( Window* pWindow, Region& rRegion )
 {
     rRegion.Intersect( Rectangle( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
                                   pWindow->GetOutputSizePixel() ) );
+
     if ( pWindow->mpWindowImpl->mbWinRegion )
         rRegion.Intersect( pWindow->ImplPixelToDevicePixel( pWindow->mpWindowImpl->maWinRegion ) );
 }
@@ -216,14 +626,59 @@ void ClipManager::Exclude( Window *pWindow, Region& rRegion )
     }
 }
 
-bool ClipManager::ClipCoversWholeWindow( Window *pWindow )
+Region ClipManager::GetActiveClipRegion( const Window *pWindow ) const
 {
-    ClipManager *clipMgr = ClipManager::GetInstance();
+    Region aRegion(true);
+
+    if ( pWindow->mpWindowImpl->mbInPaint )
+    {
+        aRegion = *(pWindow->mpWindowImpl->mpPaintRegion);
+        aRegion.Move( -pWindow->mnOutOffX, -pWindow->mnOutOffY );
+    }
+
+    if ( pWindow->mbClipRegion )
+        aRegion.Intersect( pWindow->maRegion );
+
+    return pWindow->PixelToLogic( aRegion );
+}
+
+void ClipManager::ClipToPaintRegion( Window *pWindow, Rectangle& rDstRect )
+{
+    const Region aPaintRgn( pWindow->GetPaintRegion() );
+
+    if (!aPaintRgn.IsNull())
+        rDstRect.Intersection( pWindow->LogicToPixel( aPaintRgn.GetBoundRect() ) );
+}
+
+void ClipManager::ExpandPaintClipRegion( Window *pWindow, const Region& rRegion )
+{
+    if( pWindow->mpWindowImpl->mpPaintRegion )
+    {
+        Region aPixRegion = pWindow->LogicToPixel( rRegion );
+        Region aDevPixRegion = pWindow->ImplPixelToDevicePixel( aPixRegion );
+
+        Region aWinChildRegion = *GetChildClipRegion( pWindow );
+        // --- RTL -- only this region is in frame coordinates, so re-mirror it
+        if( pWindow->ImplIsAntiparallel() )
+        {
+            pWindow->ReMirror( aWinChildRegion );
+        }
+
+        aDevPixRegion.Intersect( aWinChildRegion );
+        if( ! aDevPixRegion.IsEmpty() )
+        {
+            pWindow->mpWindowImpl->mpPaintRegion->Union( aDevPixRegion );
+            pWindow->mbInitClipRegion = true;
+        }
+    }
+}
 
+bool ClipManager::ClipCoversWholeWindow( Window *pWindow )
+{
     bool bCoversWholeWindow = false;
 
     if ( pWindow->mpWindowImpl->mbInitWinClipRegion )
-        clipMgr->InitClipRegion( pWindow );
+        InitClipRegion( pWindow );
 
     Region aWinClipRegion = pWindow->mpWindowImpl->maWinClipRegion;
     Region aWinRegion( Rectangle ( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ), pWindow->GetOutputSizePixel() ) );
@@ -234,6 +689,29 @@ bool ClipManager::ClipCoversWholeWindow( Window *pWindow )
     return bCoversWholeWindow;
 }
 
+void ClipManager::UpdateSysObjClip( Window *pWindow )
+{
+    if ( !IsOverlapWindow( pWindow ) )
+    {
+        updateSysObjChildrenClip( pWindow );
+
+        // siblings should recalculate their clip region
+        if ( pWindow->mpWindowImpl->mbClipSiblings )
+        {
+            Window* pNextWindow = pWindow->mpWindowImpl->mpNext;
+            while ( pNextWindow )
+            {
+                updateSysObjChildrenClip( pNextWindow );
+                pNextWindow = pNextWindow->mpWindowImpl->mpNext;
+            }
+        }
+    }
+    else
+    {
+        updateSysObjOverlapsClip( pWindow->mpWindowImpl->mpFrameWindow );
+    }
+}
+
 void ClipManager::initChildClipRegion( Window *pWindow )
 {
     if ( !pWindow->mpWindowImpl->mpFirstChild )
@@ -274,14 +752,30 @@ void ClipManager::excludeOverlapWindows( Window *pWindow, Region& rRegion )
 
 void ClipManager::intersectClipRegion( Window* pWindow, Region& rRegion )
 {
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
     if ( pWindow->mpWindowImpl->mbInitWinClipRegion )
-        clipMgr->InitClipRegion(pWindow);
+        InitClipRegion(pWindow);
 
     rRegion.Intersect( pWindow->mpWindowImpl->maWinClipRegion );
 }
 
+void ClipManager::intersectAndUnionOverlapWindows( Window *pWindow, const Region& rInterRegion, Region& rRegion )
+{
+    Window* pChildWindow = pWindow->mpWindowImpl->mpFirstOverlap;
+    while ( pChildWindow )
+    {
+        if ( pChildWindow->mpWindowImpl->mbReallyVisible )
+        {
+            Region aIntersectRegion( rInterRegion );
+            Intersect( pChildWindow, aIntersectRegion );
+            rRegion.Union( aIntersectRegion );
+            intersectAndUnionOverlapWindows( pChildWindow, rInterRegion, rRegion );
+        }
+
+        pChildWindow = pChildWindow->mpWindowImpl->mpNext;
+    }
+}
+
+
 void ClipManager::clipSiblings( Window* pWindow, Region& rRegion )
 {
     Window* pChildWindow = pWindow->ImplGetParent()->mpWindowImpl->mpFirstChild;
@@ -298,4 +792,98 @@ void ClipManager::clipSiblings( Window* pWindow, Region& rRegion )
     }
 }
 
+bool ClipManager::clipSysObject( Window *pWindow, const Region* pOldRegion )
+{
+    bool bUpdate = true;
+
+    if ( pWindow->mpWindowImpl->mpSysObj )
+    {
+        bool bVisibleState = pWindow->mpWindowImpl->mbReallyVisible;
+
+        if ( bVisibleState )
+        {
+            Region* pWinChildClipRegion = GetChildClipRegion( pWindow );
+
+            if ( !pWinChildClipRegion->IsEmpty() )
+            {
+                if ( pOldRegion )
+                {
+                    Region aNewRegion = *pWinChildClipRegion;
+                    pWinChildClipRegion->Intersect( *pOldRegion );
+                    bUpdate = (aNewRegion == *pWinChildClipRegion);
+                }
+
+                if ( pWindow->mpWindowImpl->mpFrameData->mpFirstBackWin )
+                    InvalidateAllOverlapBackgrounds( pWindow );
+
+                Region      aRegion = *pWinChildClipRegion;
+                Rectangle   aWinRect( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ), pWindow->GetOutputSizePixel() );
+                Region      aWinRectRegion( aWinRect );
+                sal_uInt16      nClipFlags = pWindow->mpWindowImpl->mpSysObj->GetClipRegionType();
+
+                if ( aRegion == aWinRectRegion )
+                    pWindow->mpWindowImpl->mpSysObj->ResetClipRegion();
+                else
+                {
+                    if ( nClipFlags & SAL_OBJECT_CLIP_EXCLUDERECTS )
+                    {
+                        aWinRectRegion.Exclude( aRegion );
+                        aRegion = aWinRectRegion;
+                    }
+                    if ( !(nClipFlags & SAL_OBJECT_CLIP_ABSOLUTE) )
+                        aRegion.Move( -pWindow->mnOutOffX, -pWindow->mnOutOffY );
+
+                    // set/update clip region
+                    RectangleVector aRectangles;
+                    aRegion.GetRegionRectangles(aRectangles);
+                    pWindow->mpWindowImpl->mpSysObj->BeginSetClipRegion(aRectangles.size());
+
+                    for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); ++aRectIter)
+                    {
+                        pWindow->mpWindowImpl->mpSysObj->UnionClipRegion(
+                            aRectIter->Left(),
+                            aRectIter->Top(),
+                            aRectIter->GetWidth(),   // orig nWidth was ((R - L) + 1), same as GetWidth does
+                            aRectIter->GetHeight()); // same for height
+                    }
+
+                    pWindow->mpWindowImpl->mpSysObj->EndSetClipRegion();
+                }
+            }
+            else
+                bVisibleState = false;
+        }
+
+        // update visible status
+        pWindow->mpWindowImpl->mpSysObj->Show( bVisibleState );
+    }
+
+    return bUpdate;
+}
+
+void ClipManager::updateSysObjChildrenClip( Window *pWindow )
+{
+    if ( pWindow->mpWindowImpl->mpSysObj && pWindow->mpWindowImpl->mbInitWinClipRegion )
+        clipSysObject( pWindow, NULL );
+
+    Window* pChildWindow = pWindow->mpWindowImpl->mpFirstChild;
+    while ( pChildWindow )
+    {
+        updateSysObjChildrenClip( pChildWindow );
+        pChildWindow = pChildWindow->mpWindowImpl->mpNext;
+    }
+}
+
+void ClipManager::updateSysObjOverlapsClip( Window *pWindow )
+{
+    updateSysObjChildrenClip( pWindow );
+
+    Window* pNextWindow = pWindow->mpWindowImpl->mpFirstOverlap;
+    while ( pNextWindow )
+    {
+        updateSysObjOverlapsClip( pNextWindow );
+        pNextWindow = pNextWindow->mpWindowImpl->mpNext;
+    }
+}
+
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/window/clipping.cxx b/vcl/source/window/clipping.cxx
index 2792496bed12..c01a91427ab6 100644
--- a/vcl/source/window/clipping.cxx
+++ b/vcl/source/window/clipping.cxx
@@ -26,42 +26,12 @@
 #include <salobj.hxx>
 #include <window.h>
 
-#define IMPL_MAXSAVEBACKSIZE    (640*480)
-#define IMPL_MAXALLSAVEBACKSIZE (800*600*2)
-
 void Window::InitClipRegion()
 {
     DBG_TESTSOLARMUTEX();
 
     ClipManager *clipMgr = ClipManager::GetInstance();
-
-    Region  aRegion;
-
-    // Put back backed up background
-    if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-        ImplInvalidateAllOverlapBackgrounds();
-    if ( mpWindowImpl->mbInPaint )
-        aRegion = *(mpWindowImpl->mpPaintRegion);
-    else
-    {
-        aRegion = *(clipMgr->GetChildClipRegion(this));
-        // --- RTL -- only this region is in frame coordinates, so re-mirror it
-        // the mpWindowImpl->mpPaintRegion above is already correct (see ImplCallPaint()) !
-        if( ImplIsAntiparallel() )
-            ReMirror ( aRegion );
-    }
-    if ( mbClipRegion )
-        aRegion.Intersect( ImplPixelToDevicePixel( maRegion ) );
-    if ( aRegion.IsEmpty() )
-        mbOutputClipped = true;
-    else
-    {
-        mbOutputClipped = false;
-        SelectClipRegion( aRegion );
-    }
-    mbClipRegionSet = true;
-
-    mbInitClipRegion = false;
+    clipMgr->Init( this );
 }
 
 void Window::SetParentClipMode( sal_uInt16 nMode )
@@ -76,46 +46,10 @@ sal_uInt16 Window::GetParentClipMode() const
     return clipMgr->GetParentClipMode( const_cast<Window*>(this) );
 }
 
-void Window::ExpandPaintClipRegion( const Region& rRegion )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    if( mpWindowImpl->mpPaintRegion )
-    {
-        Region aPixRegion = LogicToPixel( rRegion );
-        Region aDevPixRegion = ImplPixelToDevicePixel( aPixRegion );
-
-        Region aWinChildRegion = *clipMgr->GetChildClipRegion(this);
-        // --- RTL -- only this region is in frame coordinates, so re-mirror it
-        if( ImplIsAntiparallel() )
-        {
-            const OutputDevice *pOutDev = GetOutDev();
-            pOutDev->ReMirror( aWinChildRegion );
-        }
-
-        aDevPixRegion.Intersect( aWinChildRegion );
-        if( ! aDevPixRegion.IsEmpty() )
-        {
-            mpWindowImpl->mpPaintRegion->Union( aDevPixRegion );
-            mbInitClipRegion = true;
-        }
-    }
-}
-
 Region Window::GetActiveClipRegion() const
 {
-    Region aRegion(true);
-
-    if ( mpWindowImpl->mbInPaint )
-    {
-        aRegion = *(mpWindowImpl->mpPaintRegion);
-        aRegion.Move( -mnOutOffX, -mnOutOffY );
-    }
-
-    if ( mbClipRegion )
-        aRegion.Intersect( maRegion );
-
-    return PixelToLogic( aRegion );
+    ClipManager *clipMgr = ClipManager::GetInstance();
+    return clipMgr->GetActiveClipRegion( this );
 }
 
 void Window::ClipToPaintRegion(Rectangle& rDstRect)
@@ -126,352 +60,6 @@ void Window::ClipToPaintRegion(Rectangle& rDstRect)
         rDstRect.Intersection(LogicToPixel(aPaintRgn.GetBoundRect()));
 }
 
-bool Window::ImplSysObjClip( const Region* pOldRegion )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    bool bUpdate = true;
-
-    if ( mpWindowImpl->mpSysObj )
-    {
-        bool bVisibleState = mpWindowImpl->mbReallyVisible;
-
-        if ( bVisibleState )
-        {
-            Region* pWinChildClipRegion = clipMgr->GetChildClipRegion(this);
-
-            if ( !pWinChildClipRegion->IsEmpty() )
-            {
-                if ( pOldRegion )
-                {
-                    Region aNewRegion = *pWinChildClipRegion;
-                    pWinChildClipRegion->Intersect( *pOldRegion );
-                    bUpdate = aNewRegion == *pWinChildClipRegion;
-                }
-
-                if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-                    ImplInvalidateAllOverlapBackgrounds();
-
-                Region      aRegion = *pWinChildClipRegion;
-                Rectangle   aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
-                Region      aWinRectRegion( aWinRect );
-                sal_uInt16      nClipFlags = mpWindowImpl->mpSysObj->GetClipRegionType();
-
-                if ( aRegion == aWinRectRegion )
-                    mpWindowImpl->mpSysObj->ResetClipRegion();
-                else
-                {
-                    if ( nClipFlags & SAL_OBJECT_CLIP_EXCLUDERECTS )
-                    {
-                        aWinRectRegion.Exclude( aRegion );
-                        aRegion = aWinRectRegion;
-                    }
-                    if ( !(nClipFlags & SAL_OBJECT_CLIP_ABSOLUTE) )
-                        aRegion.Move( -mnOutOffX, -mnOutOffY );
-
-                    // set/update clip region
-                    RectangleVector aRectangles;
-                    aRegion.GetRegionRectangles(aRectangles);
-                    mpWindowImpl->mpSysObj->BeginSetClipRegion(aRectangles.size());
-
-                    for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); ++aRectIter)
-                    {
-                        mpWindowImpl->mpSysObj->UnionClipRegion(
-                            aRectIter->Left(),
-                            aRectIter->Top(),
-                            aRectIter->GetWidth(),   // orig nWidth was ((R - L) + 1), same as GetWidth does
-                            aRectIter->GetHeight()); // same for height
-                    }
-
-                    mpWindowImpl->mpSysObj->EndSetClipRegion();
-                }
-            }
-            else
-                bVisibleState = false;
-        }
-
-        // update visible status
-        mpWindowImpl->mpSysObj->Show( bVisibleState );
-    }
-
-    return bUpdate;
-}
-
-void Window::ImplUpdateSysObjChildrenClip()
-{
-    if ( mpWindowImpl->mpSysObj && mpWindowImpl->mbInitWinClipRegion )
-        ImplSysObjClip( NULL );
-
-    Window* pWindow = mpWindowImpl->mpFirstChild;
-    while ( pWindow )
-    {
-        pWindow->ImplUpdateSysObjChildrenClip();
-        pWindow = pWindow->mpWindowImpl->mpNext;
-    }
-}
-
-void Window::ImplUpdateSysObjOverlapsClip()
-{
-    ImplUpdateSysObjChildrenClip();
-
-    Window* pWindow = mpWindowImpl->mpFirstOverlap;
-    while ( pWindow )
-    {
-        pWindow->ImplUpdateSysObjOverlapsClip();
-        pWindow = pWindow->mpWindowImpl->mpNext;
-    }
-}
-
-void Window::ImplUpdateSysObjClip()
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    if ( !clipMgr->IsOverlapWindow( this ) )
-    {
-        ImplUpdateSysObjChildrenClip();
-
-        // siblings should recalculate their clip region
-        if ( mpWindowImpl->mbClipSiblings )
-        {
-            Window* pWindow = mpWindowImpl->mpNext;
-            while ( pWindow )
-            {
-                pWindow->ImplUpdateSysObjChildrenClip();
-                pWindow = pWindow->mpWindowImpl->mpNext;
-            }
-        }
-    }
-    else
-        mpWindowImpl->mpFrameWindow->ImplUpdateSysObjOverlapsClip();
-}
-
-bool Window::ImplSetClipFlagChildren( bool bSysObjOnlySmaller )
-{
-    bool bUpdate = true;
-    if ( mpWindowImpl->mpSysObj )
-    {
-        Region* pOldRegion = NULL;
-        if ( bSysObjOnlySmaller && !mpWindowImpl->mbInitWinClipRegion )
-            pOldRegion = new Region( mpWindowImpl->maWinClipRegion );
-
-        mbInitClipRegion = true;
-        mpWindowImpl->mbInitWinClipRegion = true;
-
-        Window* pWindow = mpWindowImpl->mpFirstChild;
-        while ( pWindow )
-        {
-            if ( !pWindow->ImplSetClipFlagChildren( bSysObjOnlySmaller ) )
-                bUpdate = false;
-            pWindow = pWindow->mpWindowImpl->mpNext;
-        }
-
-        if ( !ImplSysObjClip( pOldRegion ) )
-        {
-            mbInitClipRegion = true;
-            mpWindowImpl->mbInitWinClipRegion = true;
-            bUpdate = false;
-        }
-
-        delete pOldRegion;
-    }
-    else
-    {
-    mbInitClipRegion = true;
-    mpWindowImpl->mbInitWinClipRegion = true;
-
-    Window* pWindow = mpWindowImpl->mpFirstChild;
-    while ( pWindow )
-    {
-        if ( !pWindow->ImplSetClipFlagChildren( bSysObjOnlySmaller ) )
-            bUpdate = false;
-        pWindow = pWindow->mpWindowImpl->mpNext;
-    }
-    }
-    return bUpdate;
-}
-
-bool Window::ImplSetClipFlagOverlapWindows( bool bSysObjOnlySmaller )
-{
-    bool bUpdate = ImplSetClipFlagChildren( bSysObjOnlySmaller );
-
-    Window* pWindow = mpWindowImpl->mpFirstOverlap;
-    while ( pWindow )
-    {
-        if ( !pWindow->ImplSetClipFlagOverlapWindows( bSysObjOnlySmaller ) )
-            bUpdate = false;
-        pWindow = pWindow->mpWindowImpl->mpNext;
-    }
-
-    return bUpdate;
-}
-
-bool Window::ImplSetClipFlag( bool bSysObjOnlySmaller )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    if ( !clipMgr->IsOverlapWindow( this ) )
-    {
-        bool bUpdate = ImplSetClipFlagChildren( bSysObjOnlySmaller );
-
-        Window* pParent = ImplGetParent();
-        if ( pParent &&
-             ((pParent->GetStyle() & WB_CLIPCHILDREN) || (mpWindowImpl->mnParentClipMode & PARENTCLIPMODE_CLIP)) )
-        {
-            pParent->mbInitClipRegion = true;
-            pParent->mpWindowImpl->mbInitChildRegion = true;
-        }
-
-        // siblings should recalculate their clip region
-        if ( mpWindowImpl->mbClipSiblings )
-        {
-            Window* pWindow = mpWindowImpl->mpNext;
-            while ( pWindow )
-            {
-                if ( !pWindow->ImplSetClipFlagChildren( bSysObjOnlySmaller ) )
-                    bUpdate = false;
-                pWindow = pWindow->mpWindowImpl->mpNext;
-            }
-        }
-
-        return bUpdate;
-    }
-    else
-        return mpWindowImpl->mpFrameWindow->ImplSetClipFlagOverlapWindows( bSysObjOnlySmaller );
-}
-
-void Window::ImplIntersectAndUnionOverlapWindows( const Region& rInterRegion, Region& rRegion )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    Window* pWindow = mpWindowImpl->mpFirstOverlap;
-    while ( pWindow )
-    {
-        if ( pWindow->mpWindowImpl->mbReallyVisible )
-        {
-            Region aTempRegion( rInterRegion );
-            clipMgr->Intersect( pWindow, aTempRegion );
-            rRegion.Union( aTempRegion );
-            pWindow->ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
-        }
-
-        pWindow = pWindow->mpWindowImpl->mpNext;
-    }
-}
-
-void Window::ImplIntersectAndUnionOverlapWindows2( const Region& rInterRegion, Region& rRegion )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    if ( mpWindowImpl->mbReallyVisible )
-    {
-        Region aTempRegion( rInterRegion );
-        clipMgr->Intersect( this, aTempRegion );
-        rRegion.Union( aTempRegion );
-    }
-
-    ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
-}
-
-void Window::ImplCalcOverlapRegionOverlaps( const Region& rInterRegion, Region& rRegion )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    // Clip Overlap Siblings
-    Window* pStartOverlapWindow;
-    if ( !clipMgr->IsOverlapWindow( this ) )
-        pStartOverlapWindow = mpWindowImpl->mpOverlapWindow;
-    else
-        pStartOverlapWindow = this;
-    while ( !pStartOverlapWindow->mpWindowImpl->mbFrame )
-    {
-        Window* pOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
-        while ( pOverlapWindow && (pOverlapWindow != pStartOverlapWindow) )
-        {
-            pOverlapWindow->ImplIntersectAndUnionOverlapWindows2( rInterRegion, rRegion );
-            pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
-        }
-        pStartOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow;
-    }
-
-    // Clip Child Overlap Windows
-    if ( !clipMgr->IsOverlapWindow( this ) )
-        mpWindowImpl->mpOverlapWindow->ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
-    else
-        ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
-}
-
-void Window::ImplCalcOverlapRegion( const Rectangle& rSourceRect, Region& rRegion,
-                                    bool bChildren, bool bParent, bool bSiblings )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    Region  aRegion( rSourceRect );
-    if ( mpWindowImpl->mbWinRegion )
-        rRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
-    Region  aTempRegion;
-    Window* pWindow;
-
-    ImplCalcOverlapRegionOverlaps( aRegion, rRegion );
-
-    // Parent-Boundaries
-    if ( bParent )
-    {
-        pWindow = this;
-        if ( !clipMgr->IsOverlapWindow( this ) )
-        {
-            pWindow = ImplGetParent();
-            do
-            {
-                aTempRegion = aRegion;
-                clipMgr->Exclude( pWindow, aTempRegion );
-                rRegion.Union( aTempRegion );
-                if ( clipMgr->IsOverlapWindow( pWindow ) )
-                    break;
-                pWindow = pWindow->ImplGetParent();
-            }
-            while ( pWindow );
-        }
-        if ( pWindow && !pWindow->mpWindowImpl->mbFrame )
-        {
-            aTempRegion = aRegion;
-            aTempRegion.Exclude( Rectangle( Point( 0, 0 ), Size( mpWindowImpl->mpFrameWindow->mnOutWidth, mpWindowImpl->mpFrameWindow->mnOutHeight ) ) );
-            rRegion.Union( aTempRegion );
-        }
-    }
-
-    // Siblings
-    if ( bSiblings && !clipMgr->IsOverlapWindow( this ) )
-    {
-        pWindow = mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
-        do
-        {
-            if ( pWindow->mpWindowImpl->mbReallyVisible && (pWindow != this) )
-            {
-                aTempRegion = aRegion;
-                clipMgr->Intersect( pWindow, aTempRegion );
-                rRegion.Union( aTempRegion );
-            }
-            pWindow = pWindow->mpWindowImpl->mpNext;
-        }
-        while ( pWindow );
-    }
-
-    if ( bChildren )
-    {
-        pWindow = mpWindowImpl->mpFirstChild;
-        while ( pWindow )
-        {
-            if ( pWindow->mpWindowImpl->mbReallyVisible )
-            {
-                aTempRegion = aRegion;
-                clipMgr->Intersect( pWindow, aTempRegion );
-                rRegion.Union( aTempRegion );
-            }
-            pWindow = pWindow->mpWindowImpl->mpNext;
-        }
-    }
-}
-
 bool Window::ImplIsWindowInFront( const Window* pTestWindow ) const
 {
     // check for overlapping window
@@ -558,179 +146,4 @@ bool Window::ImplIsWindowInFront( const Window* pTestWindow ) const
     return false;
 }
 
-void Window::SaveBackground( const Point& rPos, const Size& rSize,
-                             const Point& rDestOff, VirtualDevice& rSaveDevice )
-{
-    if ( mpWindowImpl->mpPaintRegion )
-    {
-        Region      aClip( *mpWindowImpl->mpPaintRegion );
-        const Point aPixPos( LogicToPixel( rPos ) );
-
-        aClip.Move( -mnOutOffX, -mnOutOffY );
-        aClip.Intersect( Rectangle( aPixPos, LogicToPixel( rSize ) ) );
-
-        if ( !aClip.IsEmpty() )
-        {
-            const Region    aOldClip( rSaveDevice.GetClipRegion() );
-            const Point     aPixOffset( rSaveDevice.LogicToPixel( rDestOff ) );
-            const bool      bMap = rSaveDevice.IsMapModeEnabled();
-
-            // move clip region to have the same distance to DestOffset
-            aClip.Move( aPixOffset.X() - aPixPos.X(), aPixOffset.Y() - aPixPos.Y() );
-
-            // set pixel clip region
-            rSaveDevice.EnableMapMode( false );
-            rSaveDevice.SetClipRegion( aClip );
-            rSaveDevice.EnableMapMode( bMap );
-            rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *this );
-            rSaveDevice.SetClipRegion( aOldClip );
-        }
-    }
-    else
-        rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *this );
-}
-
-void Window::ImplSaveOverlapBackground()
-{
-    DBG_ASSERT( !mpWindowImpl->mpOverlapData->mpSaveBackDev, "Window::ImplSaveOverlapBackground() - Background already saved" );
-
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    if ( !mpWindowImpl->mbFrame )
-    {
-        sal_uLong nSaveBackSize = mnOutWidth*mnOutHeight;
-        if ( nSaveBackSize <= IMPL_MAXSAVEBACKSIZE )
-        {
-            if ( nSaveBackSize+mpWindowImpl->mpFrameData->mnAllSaveBackSize <= IMPL_MAXALLSAVEBACKSIZE )
-            {
-                Size aOutSize( mnOutWidth, mnOutHeight );
-                mpWindowImpl->mpOverlapData->mpSaveBackDev = new VirtualDevice( *mpWindowImpl->mpFrameWindow );
-                if ( mpWindowImpl->mpOverlapData->mpSaveBackDev->SetOutputSizePixel( aOutSize ) )
-                {
-                    mpWindowImpl->mpFrameWindow->ImplUpdateAll();
-
-                    if ( mpWindowImpl->mbInitWinClipRegion )
-                        clipMgr->InitClipRegion(this);
-
-                    mpWindowImpl->mpOverlapData->mnSaveBackSize = nSaveBackSize;
-                    mpWindowImpl->mpFrameData->mnAllSaveBackSize += nSaveBackSize;
-                    Point aDevPt;
-
-                    OutputDevice *pOutDev = mpWindowImpl->mpFrameWindow->GetOutDev();
-                    pOutDev->ImplGetFrameDev( Point( mnOutOffX, mnOutOffY ),
-                                              aDevPt, aOutSize,
-                                              *(mpWindowImpl->mpOverlapData->mpSaveBackDev) );
-                    mpWindowImpl->mpOverlapData->mpNextBackWin = mpWindowImpl->mpFrameData->mpFirstBackWin;
-                    mpWindowImpl->mpFrameData->mpFirstBackWin = this;
-                }
-                else
-                {
-                    delete mpWindowImpl->mpOverlapData->mpSaveBackDev;
-                    mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL;
-                }
-            }
-        }
-    }
-}
-
-bool Window::ImplRestoreOverlapBackground( Region& rInvRegion )
-{
-    ClipManager *clipMgr = ClipManager::GetInstance();
-
-    if ( mpWindowImpl->mpOverlapData->mpSaveBackDev )
-    {
-        if ( mpWindowImpl->mbInitWinClipRegion )
-            clipMgr->InitClipRegion(this);
-
-        if ( mpWindowImpl->mpOverlapData->mpSaveBackDev )
-        {
-            Point   aDevPt;
-            Point   aDestPt( mnOutOffX, mnOutOffY );
-            Size    aDevSize = mpWindowImpl->mpOverlapData->mpSaveBackDev->GetOutputSizePixel();
-
-            OutputDevice *pOutDev = mpWindowImpl->mpFrameWindow->GetOutDev();
-
-            if ( mpWindowImpl->mpOverlapData->mpSaveBackRgn )
-            {
-                mpWindowImpl->mpOverlapData->mpSaveBackRgn->Intersect( mpWindowImpl->maWinClipRegion );
-                rInvRegion = mpWindowImpl->maWinClipRegion;
-                rInvRegion.Exclude( *mpWindowImpl->mpOverlapData->mpSaveBackRgn );
-                pOutDev->ImplDrawFrameDev( aDestPt, aDevPt, aDevSize,
-                                           *(mpWindowImpl->mpOverlapData->mpSaveBackDev),
-                                           *mpWindowImpl->mpOverlapData->mpSaveBackRgn );
-            }
-            else
-            {
-                pOutDev->ImplDrawFrameDev( aDestPt, aDevPt, aDevSize,
-                                           *(mpWindowImpl->mpOverlapData->mpSaveBackDev),
-                                           mpWindowImpl->maWinClipRegion );
-            }
-            ImplDeleteOverlapBackground();
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-void Window::ImplDeleteOverlapBackground()
-{
-    if ( mpWindowImpl->mpOverlapData->mpSaveBackDev )
-    {
-        mpWindowImpl->mpFrameData->mnAllSaveBackSize -= mpWindowImpl->mpOverlapData->mnSaveBackSize;
-        delete mpWindowImpl->mpOverlapData->mpSaveBackDev;
-        mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL;
-        if ( mpWindowImpl->mpOverlapData->mpSaveBackRgn )
-        {
-            delete mpWindowImpl->mpOverlapData->mpSaveBackRgn;
-            mpWindowImpl->mpOverlapData->mpSaveBackRgn = NULL;
-        }
-
-        // remove window from the list
-        if ( mpWindowImpl->mpFrameData->mpFirstBackWin == this )
-            mpWindowImpl->mpFrameData->mpFirstBackWin = mpWindowImpl->mpOverlapData->mpNextBackWin;
-        else
-        {
-            Window* pTemp = mpWindowImpl->mpFrameData->mpFirstBackWin;
-            while ( pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin != this )
-                pTemp = pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin;
-            pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin = mpWindowImpl->mpOverlapData->mpNextBackWin;
-        }
-        mpWindowImpl->mpOverlapData->mpNextBackWin = NULL;
-    }
-}
-
-void Window::ImplInvalidateAllOverlapBackgrounds()
-{
-    Window* pWindow = mpWindowImpl->mpFrameData->mpFirstBackWin;
-    while ( pWindow )
-    {
-        // remember next window here already, as this window could
-        // be removed within the next if clause from the list
-        Window* pNext = pWindow->mpWindowImpl->mpOverlapData->mpNextBackWin;
-
-        if ( ImplIsWindowInFront( pWindow ) )
-        {
-            Rectangle aRect1( Point( mnOutOffX, mnOutOffY ),
-                              Size( mnOutWidth, mnOutHeight ) );
-            Rectangle aRect2( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
-                              Size( pWindow->mnOutWidth, pWindow->mnOutHeight ) );
-            aRect1.Intersection( aRect2 );
-            if ( !aRect1.IsEmpty() )
-            {
-                if ( !pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn )
-                    pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn = new Region( aRect2 );
-                pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->Exclude( aRect1 );
-                if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->IsEmpty() )
-                    pWindow->ImplDeleteOverlapBackground();
-            }
-
-        }
-
-        pWindow = pNext;
-    }
-}
-
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/window/paint.cxx b/vcl/source/window/paint.cxx
index b1efe638a78a..6218a546cc7c 100644
--- a/vcl/source/window/paint.cxx
+++ b/vcl/source/window/paint.cxx
@@ -417,7 +417,7 @@ void Window::ImplInvalidate( const Region* pRegion, sal_uInt16 nFlags )
 
     // reset background storage
     if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-        ImplInvalidateAllOverlapBackgrounds();
+        clipMgr->InvalidateAllOverlapBackgrounds( this );
 
     // check what has to be redrawn
     bool bInvalidateAll = !pRegion;
@@ -701,6 +701,7 @@ void Window::SetPaintTransparent( bool bTransparent )
 
 void Window::SetWindowRegionPixel()
 {
+    ClipManager *clipMgr = ClipManager::GetInstance();
 
     if ( mpWindowImpl->mpBorderWindow )
         mpWindowImpl->mpBorderWindow->SetWindowRegionPixel();
@@ -716,15 +717,15 @@ void Window::SetWindowRegionPixel()
         {
             mpWindowImpl->maWinRegion = Region(true);
             mpWindowImpl->mbWinRegion = false;
-            ImplSetClipFlag();
+            clipMgr->SetClipFlag( this );
 
             if ( IsReallyVisible() )
             {
                 // restore background storage
                 if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mpSaveBackDev )
-                    ImplDeleteOverlapBackground();
+                    clipMgr->DeleteOverlapBackground( this );
                 if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-                    ImplInvalidateAllOverlapBackgrounds();
+                    clipMgr->InvalidateAllOverlapBackgrounds( this );
                 Rectangle   aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
                 Region      aRegion( aRect );
                 ImplInvalidateParentFrameRegion( aRegion );
@@ -735,6 +736,7 @@ void Window::SetWindowRegionPixel()
 
 void Window::SetWindowRegionPixel( const Region& rRegion )
 {
+    ClipManager *clipMgr = ClipManager::GetInstance();
 
     if ( mpWindowImpl->mpBorderWindow )
         mpWindowImpl->mpBorderWindow->SetWindowRegionPixel( rRegion );
@@ -795,23 +797,23 @@ void Window::SetWindowRegionPixel( const Region& rRegion )
             {
                 mpWindowImpl->maWinRegion = Region(true);
                 mpWindowImpl->mbWinRegion = false;
-                ImplSetClipFlag();
+                clipMgr->SetClipFlag( this );
             }
         }
         else
         {
             mpWindowImpl->maWinRegion = rRegion;
             mpWindowImpl->mbWinRegion = true;
-            ImplSetClipFlag();
+            clipMgr->SetClipFlag( this );
         }
 
         if ( IsReallyVisible() )
         {
             // restore background storage
             if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mpSaveBackDev )
-                ImplDeleteOverlapBackground();
+                clipMgr->DeleteOverlapBackground( this );
             if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-                ImplInvalidateAllOverlapBackgrounds();
+                clipMgr->InvalidateAllOverlapBackgrounds( this );
             Rectangle   aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
             Region      aRegion( aRect );
             ImplInvalidateParentFrameRegion( aRegion );
@@ -1209,7 +1211,7 @@ void Window::ImplScroll( const Rectangle& rRect,
 
     // restore background storage
     if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-        ImplInvalidateAllOverlapBackgrounds();
+        clipMgr->InvalidateAllOverlapBackgrounds( this );
 
     if ( mpWindowImpl->mpCursor )
         mpWindowImpl->mpCursor->ImplSuspend();
@@ -1248,7 +1250,7 @@ void Window::ImplScroll( const Rectangle& rRect,
 
     if ( !(nFlags & SCROLL_NOINVALIDATE) )
     {
-        ImplCalcOverlapRegion( aRectMirror, aInvalidateRegion, !bScrollChildren, true, false );
+        clipMgr->CalcOverlapRegion( this, aRectMirror, aInvalidateRegion, !bScrollChildren, true, false );
 
         // --- RTL ---
         // if the scrolling on the device is performed in the opposite direction
diff --git a/vcl/source/window/stacking.cxx b/vcl/source/window/stacking.cxx
index 66cab1377d73..cc85232344d7 100644
--- a/vcl/source/window/stacking.cxx
+++ b/vcl/source/window/stacking.cxx
@@ -216,7 +216,9 @@ void Window::ImplToBottomChild()
 
 void Window::ImplCalcToTop( ImplCalcToTopData* pPrevData )
 {
-    DBG_ASSERT( ClipManager::GetInstance()->IsOverlapWindow(this), "Window::ImplCalcToTop(): Is not a OverlapWindow" );
+    ClipManager *clipMgr = ClipManager::GetInstance();
+
+    DBG_ASSERT( clipMgr->IsOverlapWindow(this), "Window::ImplCalcToTop(): Is not a OverlapWindow" );
 
     if ( !mpWindowImpl->mbFrame )
     {
@@ -227,7 +229,7 @@ void Window::ImplCalcToTop( ImplCalcToTopData* pPrevData )
             Region  aRegion( Rectangle( aPoint,
                                         Size( mnOutWidth, mnOutHeight ) ) );
             Region  aInvalidateRegion;
-            ImplCalcOverlapRegionOverlaps( aRegion, aInvalidateRegion );
+            clipMgr->CalcOverlapRegionOverlaps( this, aRegion, aInvalidateRegion );
 
             if ( !aInvalidateRegion.IsEmpty() )
             {
@@ -243,7 +245,9 @@ void Window::ImplCalcToTop( ImplCalcToTopData* pPrevData )
 
 void Window::ImplToTop( sal_uInt16 nFlags )
 {
-    DBG_ASSERT( ClipManager::GetInstance()->IsOverlapWindow(this), "Window::ImplToTop(): Is not a OverlapWindow" );
+    ClipManager *clipMgr = ClipManager::GetInstance();
+
+    DBG_ASSERT( clipMgr->IsOverlapWindow(this), "Window::ImplToTop(): Is not a OverlapWindow" );
 
     if ( mpWindowImpl->mbFrame )
     {
@@ -324,8 +328,8 @@ void Window::ImplToTop( sal_uInt16 nFlags )
             {
                 // reset background storage
                 if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-                    ImplInvalidateAllOverlapBackgrounds();
-                mpWindowImpl->mpOverlapWindow->ImplSetClipFlagOverlapWindows();
+                    clipMgr->InvalidateAllOverlapBackgrounds( this );
+                clipMgr->SetClipFlagOverlapWindows( mpWindowImpl->mpOverlapWindow );
             }
         }
     }
@@ -566,12 +570,12 @@ void Window::SetZOrder( Window* pRefWindow, sal_uInt16 nFlags )
     {
         // restore background storage
         if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-            ImplInvalidateAllOverlapBackgrounds();
+            clipMgr->InvalidateAllOverlapBackgrounds( this );
 
         if ( mpWindowImpl->mbInitWinClipRegion || !mpWindowImpl->maWinClipRegion.IsEmpty() )
         {
             bool bInitWinClipRegion = mpWindowImpl->mbInitWinClipRegion;
-            ImplSetClipFlag();
+            clipMgr->SetClipFlag( this );
 
             // When ClipRegion was not initialised, assume
             // the window has not been sent, therefore do not
diff --git a/vcl/source/window/syswin.cxx b/vcl/source/window/syswin.cxx
index c4077a199afc..309cab41fcf5 100644
--- a/vcl/source/window/syswin.cxx
+++ b/vcl/source/window/syswin.cxx
@@ -29,6 +29,7 @@
 #include <vcl/syswin.hxx>
 #include <vcl/taskpanelist.hxx>
 #include <vcl/unowrap.hxx>
+#include <vcl/clipmgr.hxx>
 
 #include <rtl/strbuf.hxx>
 
@@ -247,6 +248,8 @@ void SystemWindow::SetIcon( sal_uInt16 nIcon )
 
 void SystemWindow::EnableSaveBackground( bool bSave )
 {
+    ClipManager *pClipMgr = ClipManager::GetInstance();
+
     if( ImplGetSVData()->maWinData.mbNoSaveBackground )
         bSave = false;
 
@@ -257,7 +260,7 @@ void SystemWindow::EnableSaveBackground( bool bSave )
     {
         pWindow->mpWindowImpl->mpOverlapData->mbSaveBack = bSave;
         if ( !bSave )
-            pWindow->ImplDeleteOverlapBackground();
+            pClipMgr->DeleteOverlapBackground( pWindow );
     }
 }
 
diff --git a/vcl/source/window/window.cxx b/vcl/source/window/window.cxx
index f22d84e1b1de..3e6670f3e561 100644
--- a/vcl/source/window/window.cxx
+++ b/vcl/source/window/window.cxx
@@ -1525,7 +1525,7 @@ void Window::ImplPosSizeWindow( long nX, long nY,
     if ( IsReallyVisible() )
     {
         if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-            ImplInvalidateAllOverlapBackgrounds();
+            clipMgr->InvalidateAllOverlapBackgrounds( this );
 
         Rectangle aOldWinRect( Point( nOldOutOffX, nOldOutOffY ),
                                Size( nOldOutWidth, nOldOutHeight ) );
@@ -1615,9 +1615,9 @@ void Window::ImplPosSizeWindow( long nX, long nY,
             if ( bCopyBits && !pOverlapRegion )
             {
                 pOverlapRegion = new Region();
-                ImplCalcOverlapRegion( Rectangle( Point( mnOutOffX, mnOutOffY ),
+                clipMgr->CalcOverlapRegion( this, Rectangle( Point( mnOutOffX, mnOutOffY ),
                                                   Size( mnOutWidth, mnOutHeight ) ),
-                                       *pOverlapRegion, false, true, true );
+                                            *pOverlapRegion, false, true, true );
             }
             mpWindowImpl->mnX = nX;
             mpWindowImpl->maPos.X() = nOrgX;
@@ -1633,9 +1633,9 @@ void Window::ImplPosSizeWindow( long nX, long nY,
             if ( bCopyBits && !pOverlapRegion )
             {
                 pOverlapRegion = new Region();
-                ImplCalcOverlapRegion( Rectangle( Point( mnOutOffX, mnOutOffY ),
+                clipMgr->CalcOverlapRegion( this, Rectangle( Point( mnOutOffX, mnOutOffY ),
                                                   Size( mnOutWidth, mnOutHeight ) ),
-                                       *pOverlapRegion, false, true, true );
+                                            *pOverlapRegion, false, true, true );
             }
             mpWindowImpl->mnY = nY;
             mpWindowImpl->maPos.Y() = nY;
@@ -1705,11 +1705,11 @@ void Window::ImplPosSizeWindow( long nX, long nY,
             {
                 // reset background storage
                 if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mpSaveBackDev )
-                    ImplDeleteOverlapBackground();
+                    clipMgr->DeleteOverlapBackground( this );
                 if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-                    ImplInvalidateAllOverlapBackgrounds();
+                    clipMgr->InvalidateAllOverlapBackgrounds( this );
                 // set Clip-Flag
-                bUpdateSysObjClip = !ImplSetClipFlag( true );
+                bUpdateSysObjClip = !clipMgr->SetClipFlag( this, true );
             }
 
             // invalidate window content ?
@@ -1802,7 +1802,7 @@ void Window::ImplPosSizeWindow( long nX, long nY,
 
         // adapt system objects
         if ( bUpdateSysObjClip )
-            ImplUpdateSysObjClip();
+            clipMgr->UpdateSysObjClip( this );
         if ( bUpdateSysObjPos )
             ImplUpdateSysObjPos();
         if ( bNewSize && mpWindowImpl->mpSysObj )
@@ -2291,7 +2291,7 @@ void Window::Show( bool bVisible, sal_uInt16 nFlags )
 
             if ( clipMgr->IsOverlapWindow( this ) && !mpWindowImpl->mbFrame )
             {
-                if ( ImplRestoreOverlapBackground( aInvRegion ) )
+                if ( clipMgr->RestoreOverlapBackground( this, aInvRegion ) )
                     bSaveBack = true;
             }
 
@@ -2307,7 +2307,7 @@ void Window::Show( bool bVisible, sal_uInt16 nFlags )
 
             bRealVisibilityChanged = mpWindowImpl->mbReallyVisible;
             ImplResetReallyVisible();
-            ImplSetClipFlag();
+            clipMgr->SetClipFlag( this );
 
             if ( clipMgr->IsOverlapWindow( this ) && !mpWindowImpl->mbFrame )
             {
@@ -2393,13 +2393,13 @@ void Window::Show( bool bVisible, sal_uInt16 nFlags )
 
             // save background
             if ( mpWindowImpl->mpOverlapData && mpWindowImpl->mpOverlapData->mbSaveBack )
-                ImplSaveOverlapBackground();
+                clipMgr->SaveOverlapBackground( this );
             // adjust mpWindowImpl->mbReallyVisible
             bRealVisibilityChanged = !mpWindowImpl->mbReallyVisible;
             ImplSetReallyVisible();
 
             // assure clip rectangles will be recalculated
-            ImplSetClipFlag();
+            clipMgr->SetClipFlag( this );
 
             if ( !mpWindowImpl->mbFrame )
             {
@@ -2469,7 +2469,7 @@ void Window::Show( bool bVisible, sal_uInt16 nFlags )
         return;
     // invalidate all saved backgrounds
     if ( mpWindowImpl->mpFrameData->mpFirstBackWin )
-        ImplInvalidateAllOverlapBackgrounds();
+        clipMgr->InvalidateAllOverlapBackgrounds( this );
 
     // the SHOW/HIDE events also serve as indicators to send child creation/destroy events to the access bridge
     // However, the access bridge only uses this event if the data member is not NULL (it's kind of a hack that
diff --git a/vcl/source/window/winproc.cxx b/vcl/source/window/winproc.cxx
index 0763780b4a65..35f4459269b4 100644
--- a/vcl/source/window/winproc.cxx
+++ b/vcl/source/window/winproc.cxx
@@ -35,6 +35,8 @@
 #include <vcl/help.hxx>
 #include <vcl/dockwin.hxx>
 #include <vcl/menu.hxx>
+#include <vcl/clipmgr.hxx>
+
 #include <touch/touch.h>
 
 #include <svdata.hxx>
@@ -1508,6 +1510,7 @@ static bool ImplHandleWheelEvent( Window* pWindow, const SalWheelMouseEvent& rEv
 
 static void ImplHandlePaint( Window* pWindow, const Rectangle& rBoundRect, bool bImmediateUpdate )
 {
+    ClipManager *clipMgr = ClipManager::GetInstance();
     // give up background save when system paints arrive
     Window* pSaveBackWin = pWindow->ImplGetWindowImpl()->mpFrameData->mpFirstBackWin;
     while ( pSaveBackWin )
@@ -1516,7 +1519,7 @@ static void ImplHandlePaint( Window* pWindow, const Rectangle& rBoundRect, bool
         Rectangle aRect( Point( pSaveBackWin->GetOutOffXPixel(), pSaveBackWin->GetOutOffYPixel() ),
                          Size( pSaveBackWin->GetOutputWidthPixel(), pSaveBackWin->GetOutputHeightPixel() ) );
         if ( aRect.IsOver( rBoundRect ) )
-            pSaveBackWin->ImplDeleteOverlapBackground();
+            clipMgr->DeleteOverlapBackground( pSaveBackWin );
         pSaveBackWin = pNext;
     }
 
@@ -1550,6 +1553,8 @@ static void KillOwnPopups( Window* pWindow )
 
 void ImplHandleResize( Window* pWindow, long nNewWidth, long nNewHeight )
 {
+    ClipManager *clipMgr = ClipManager::GetInstance();
+
     if( pWindow->GetStyle() & (WB_MOVEABLE|WB_SIZEABLE) )
     {
         KillOwnPopups( pWindow );
@@ -1568,7 +1573,7 @@ void ImplHandleResize( Window* pWindow, long nNewWidth, long nNewHeight )
             pWindow->mnOutHeight = nNewHeight;
             pWindow->ImplGetWindowImpl()->mbWaitSystemResize = false;
             if ( pWindow->IsReallyVisible() )
-                pWindow->ImplSetClipFlag();
+                clipMgr->SetClipFlag( pWindow );
             if ( pWindow->IsVisible() || pWindow->ImplGetWindow()->ImplGetWindowImpl()->mbAllResize ||
                 ( pWindow->ImplGetWindowImpl()->mbFrame && pWindow->ImplGetWindowImpl()->mpClientWindow ) )   // propagate resize for system border windows
             {