vcl/source/window/clipping.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <vcl/window.hxx>
  21 #include <vcl/virdev.hxx>
  22
  23 #include <sal/types.h>
  24
  25 #include <salobj.hxx>
  26 #include <window.h>
  27
  28 namespace vcl {
  29
  30 void Window::InitClipRegion()
  31 {
  32     DBG_TESTSOLARMUTEX();
  33
  34     vcl::Region  aRegion;
  35
  36     if ( mpWindowImpl->mbInPaint )
  37         aRegion = *(mpWindowImpl->mpPaintRegion);
  38     else
  39     {
  40         aRegion = *(ImplGetWinChildClipRegion());
  41         // --- RTL -- only this region is in frame coordinates, so re-mirror it
  42         // the mpWindowImpl->mpPaintRegion above is already correct (see ImplCallPaint()) !
  43         if( ImplIsAntiparallel() )
  44             ReMirror ( aRegion );
  45     }
  46     if ( mbClipRegion )
  47         aRegion.Intersect( ImplPixelToDevicePixel( maRegion ) );
  48     if ( aRegion.IsEmpty() )
  49         mbOutputClipped = true;
  50     else
  51     {
  52         mbOutputClipped = false;
  53         SelectClipRegion( aRegion );
  54     }
  55     mbClipRegionSet = true;
  56
  57     mbInitClipRegion = false;
  58 }
  59
  60 void Window::SetParentClipMode( ParentClipMode nMode )
  61 {
  62     if ( mpWindowImpl->mpBorderWindow )
  63         mpWindowImpl->mpBorderWindow->SetParentClipMode( nMode );
  64     else
  65     {
  66         if ( !ImplIsOverlapWindow() )
  67         {
  68             mpWindowImpl->mnParentClipMode = nMode;
  69             if ( nMode & ParentClipMode::Clip )
  70                 mpWindowImpl->mpParent->mpWindowImpl->mbClipChildren = true;
  71         }
  72     }
  73 }
  74
  75 ParentClipMode Window::GetParentClipMode() const
  76 {
  77     if ( mpWindowImpl->mpBorderWindow )
  78         return mpWindowImpl->mpBorderWindow->GetParentClipMode();
  79     else
  80         return mpWindowImpl->mnParentClipMode;
  81 }
  82
  83 void Window::ExpandPaintClipRegion( const vcl::Region& rRegion )
  84 {
  85     if( mpWindowImpl->mpPaintRegion )
  86     {
  87         vcl::Region aPixRegion = LogicToPixel( rRegion );
  88         vcl::Region aDevPixRegion = ImplPixelToDevicePixel( aPixRegion );
  89
  90         vcl::Region aWinChildRegion = *ImplGetWinChildClipRegion();
  91         // --- RTL -- only this region is in frame coordinates, so re-mirror it
  92         if( ImplIsAntiparallel() )
  93         {
  94             const OutputDevice *pOutDev = GetOutDev();
  95             pOutDev->ReMirror( aWinChildRegion );
  96         }
  97
  98         aDevPixRegion.Intersect( aWinChildRegion );
  99         if( ! aDevPixRegion.IsEmpty() )
 100         {
 101             mpWindowImpl->mpPaintRegion->Union( aDevPixRegion );
 102             mbInitClipRegion = true;
 103         }
 104     }
 105 }
 106
 107 vcl::Region Window::GetWindowClipRegionPixel() const
 108 {
 109     vcl::Region aWinClipRegion;
 110
 111     if ( mpWindowImpl->mbInitWinClipRegion )
 112         const_cast<vcl::Window*>(this)->ImplInitWinClipRegion();
 113     aWinClipRegion = mpWindowImpl->maWinClipRegion;
 114
 115     Rectangle     aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
 116     vcl::Region   aWinRegion( aWinRect );
 117
 118     if ( aWinRegion == aWinClipRegion )
 119         aWinClipRegion.SetNull();
 120
 121     aWinClipRegion.Move( -mnOutOffX, -mnOutOffY );
 122
 123     return aWinClipRegion;
 124 }
 125
 126
 127 vcl::Region Window::GetActiveClipRegion() const
 128 {
 129     vcl::Region aRegion(true);
 130
 131     if ( mpWindowImpl->mbInPaint )
 132     {
 133         aRegion = *(mpWindowImpl->mpPaintRegion);
 134         aRegion.Move( -mnOutOffX, -mnOutOffY );
 135     }
 136
 137     if ( mbClipRegion )
 138         aRegion.Intersect( maRegion );
 139
 140     return PixelToLogic( aRegion );
 141 }
 142
 143 void Window::ClipToPaintRegion(Rectangle& rDstRect)
 144 {
 145     const vcl::Region aPaintRgn(GetPaintRegion());
 146
 147     if (!aPaintRgn.IsNull())
 148         rDstRect.Intersection(LogicToPixel(aPaintRgn.GetBoundRect()));
 149 }
 150
 151 void Window::EnableClipSiblings( bool bClipSiblings )
 152 {
 153
 154     if ( mpWindowImpl->mpBorderWindow )
 155         mpWindowImpl->mpBorderWindow->EnableClipSiblings( bClipSiblings );
 156
 157     mpWindowImpl->mbClipSiblings = bClipSiblings;
 158 }
 159
 160 void Window::ImplClipBoundaries( vcl::Region& rRegion, bool bThis, bool bOverlaps )
 161 {
 162     if ( bThis )
 163         ImplIntersectWindowClipRegion( rRegion );
 164     else if ( ImplIsOverlapWindow() )
 165     {
 166         // clip to frame if required
 167         if ( !mpWindowImpl->mbFrame )
 168             rRegion.Intersect( Rectangle( Point( 0, 0 ), Size( mpWindowImpl->mpFrameWindow->mnOutWidth, mpWindowImpl->mpFrameWindow->mnOutHeight ) ) );
 169
 170         if ( bOverlaps && !rRegion.IsEmpty() )
 171         {
 172             // Clip Overlap Siblings
 173             vcl::Window* pStartOverlapWindow = this;
 174             while ( !pStartOverlapWindow->mpWindowImpl->mbFrame )
 175             {
 176                 vcl::Window* pOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
 177                 while ( pOverlapWindow && (pOverlapWindow != pStartOverlapWindow) )
 178                 {
 179                     pOverlapWindow->ImplExcludeOverlapWindows2( rRegion );
 180                     pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 181                 }
 182                 pStartOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow;
 183             }
 184
 185             // Clip Child Overlap Windows
 186             ImplExcludeOverlapWindows( rRegion );
 187         }
 188     }
 189     else
 190         ImplGetParent()->ImplIntersectWindowClipRegion( rRegion );
 191 }
 192
 193 bool Window::ImplClipChildren( vcl::Region& rRegion )
 194 {
 195     bool    bOtherClip = false;
 196     vcl::Window* pWindow = mpWindowImpl->mpFirstChild;
 197     while ( pWindow )
 198     {
 199         if ( pWindow->mpWindowImpl->mbReallyVisible )
 200         {
 201             // read-out ParentClipMode-Flags
 202             ParentClipMode nClipMode = pWindow->GetParentClipMode();
 203             if ( !(nClipMode & ParentClipMode::NoClip) &&
 204                  ((nClipMode & ParentClipMode::Clip) || (GetStyle() & WB_CLIPCHILDREN)) )
 205                 pWindow->ImplExcludeWindowRegion( rRegion );
 206             else
 207                 bOtherClip = true;
 208         }
 209
 210         pWindow = pWindow->mpWindowImpl->mpNext;
 211     }
 212
 213     return bOtherClip;
 214 }
 215
 216 void Window::ImplClipAllChildren( vcl::Region& rRegion )
 217 {
 218     vcl::Window* pWindow = mpWindowImpl->mpFirstChild;
 219     while ( pWindow )
 220     {
 221         if ( pWindow->mpWindowImpl->mbReallyVisible )
 222             pWindow->ImplExcludeWindowRegion( rRegion );
 223         pWindow = pWindow->mpWindowImpl->mpNext;
 224     }
 225 }
 226
 227 void Window::ImplClipSiblings( vcl::Region& rRegion )
 228 {
 229     vcl::Window* pWindow = ImplGetParent()->mpWindowImpl->mpFirstChild;
 230     while ( pWindow )
 231     {
 232         if ( pWindow == this )
 233             break;
 234
 235         if ( pWindow->mpWindowImpl->mbReallyVisible )
 236             pWindow->ImplExcludeWindowRegion( rRegion );
 237
 238         pWindow = pWindow->mpWindowImpl->mpNext;
 239     }
 240 }
 241
 242 void Window::ImplInitWinClipRegion()
 243 {
 244     // Build Window Region
 245     mpWindowImpl->maWinClipRegion = Rectangle( Point( mnOutOffX, mnOutOffY ),
 246                                  Size( mnOutWidth, mnOutHeight ) );
 247     if ( mpWindowImpl->mbWinRegion )
 248         mpWindowImpl->maWinClipRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
 249
 250     // ClipSiblings
 251     if ( mpWindowImpl->mbClipSiblings && !ImplIsOverlapWindow() )
 252         ImplClipSiblings( mpWindowImpl->maWinClipRegion );
 253
 254     // Clip Parent Boundaries
 255     ImplClipBoundaries( mpWindowImpl->maWinClipRegion, false, true );
 256
 257     // Clip Children
 258     if ( (GetStyle() & WB_CLIPCHILDREN) || mpWindowImpl->mbClipChildren )
 259         mpWindowImpl->mbInitChildRegion = true;
 260
 261     mpWindowImpl->mbInitWinClipRegion = false;
 262 }
 263
 264 void Window::ImplInitWinChildClipRegion()
 265 {
 266     if ( !mpWindowImpl->mpFirstChild )
 267     {
 268         if ( mpWindowImpl->mpChildClipRegion )
 269         {
 270             delete mpWindowImpl->mpChildClipRegion;
 271             mpWindowImpl->mpChildClipRegion = nullptr;
 272         }
 273     }
 274     else
 275     {
 276         if ( !mpWindowImpl->mpChildClipRegion )
 277             mpWindowImpl->mpChildClipRegion = new vcl::Region( mpWindowImpl->maWinClipRegion );
 278         else
 279             *mpWindowImpl->mpChildClipRegion = mpWindowImpl->maWinClipRegion;
 280
 281         ImplClipChildren( *mpWindowImpl->mpChildClipRegion );
 282     }
 283
 284     mpWindowImpl->mbInitChildRegion = false;
 285 }
 286
 287 Region* Window::ImplGetWinChildClipRegion()
 288 {
 289     if ( mpWindowImpl->mbInitWinClipRegion )
 290         ImplInitWinClipRegion();
 291     if ( mpWindowImpl->mbInitChildRegion )
 292         ImplInitWinChildClipRegion();
 293     if ( mpWindowImpl->mpChildClipRegion )
 294         return mpWindowImpl->mpChildClipRegion;
 295     else
 296         return &mpWindowImpl->maWinClipRegion;
 297 }
 298
 299
 300 bool Window::ImplSysObjClip( const vcl::Region* pOldRegion )
 301 {
 302     bool bUpdate = true;
 303
 304     if ( mpWindowImpl->mpSysObj )
 305     {
 306         bool bVisibleState = mpWindowImpl->mbReallyVisible;
 307
 308         if ( bVisibleState )
 309         {
 310             vcl::Region* pWinChildClipRegion = ImplGetWinChildClipRegion();
 311
 312             if ( !pWinChildClipRegion->IsEmpty() )
 313             {
 314                 if ( pOldRegion )
 315                 {
 316                     vcl::Region aNewRegion = *pWinChildClipRegion;
 317                     pWinChildClipRegion->Intersect( *pOldRegion );
 318                     bUpdate = aNewRegion == *pWinChildClipRegion;
 319                 }
 320
 321                 vcl::Region      aRegion = *pWinChildClipRegion;
 322                 Rectangle   aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
 323                 vcl::Region      aWinRectRegion( aWinRect );
 324
 325                 if ( aRegion == aWinRectRegion )
 326                     mpWindowImpl->mpSysObj->ResetClipRegion();
 327                 else
 328                 {
 329                     aRegion.Move( -mnOutOffX, -mnOutOffY );
 330
 331                     // set/update clip region
 332                     RectangleVector aRectangles;
 333                     aRegion.GetRegionRectangles(aRectangles);
 334                     mpWindowImpl->mpSysObj->BeginSetClipRegion(aRectangles.size());
 335
 336                     for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); ++aRectIter)
 337                     {
 338                         mpWindowImpl->mpSysObj->UnionClipRegion(
 339                             aRectIter->Left(),
 340                             aRectIter->Top(),
 341                             aRectIter->GetWidth(),   // orig nWidth was ((R - L) + 1), same as GetWidth does
 342                             aRectIter->GetHeight()); // same for height
 343                     }
 344
 345                     mpWindowImpl->mpSysObj->EndSetClipRegion();
 346                 }
 347             }
 348             else
 349                 bVisibleState = false;
 350         }
 351
 352         // update visible status
 353         mpWindowImpl->mpSysObj->Show( bVisibleState );
 354     }
 355
 356     return bUpdate;
 357 }
 358
 359 void Window::ImplUpdateSysObjChildrenClip()
 360 {
 361     if ( mpWindowImpl->mpSysObj && mpWindowImpl->mbInitWinClipRegion )
 362         ImplSysObjClip( nullptr );
 363
 364     vcl::Window* pWindow = mpWindowImpl->mpFirstChild;
 365     while ( pWindow )
 366     {
 367         pWindow->ImplUpdateSysObjChildrenClip();
 368         pWindow = pWindow->mpWindowImpl->mpNext;
 369     }
 370 }
 371
 372 void Window::ImplUpdateSysObjOverlapsClip()
 373 {
 374     ImplUpdateSysObjChildrenClip();
 375
 376     vcl::Window* pWindow = mpWindowImpl->mpFirstOverlap;
 377     while ( pWindow )
 378     {
 379         pWindow->ImplUpdateSysObjOverlapsClip();
 380         pWindow = pWindow->mpWindowImpl->mpNext;
 381     }
 382 }
 383
 384 void Window::ImplUpdateSysObjClip()
 385 {
 386     if ( !ImplIsOverlapWindow() )
 387     {
 388         ImplUpdateSysObjChildrenClip();
 389
 390         // siblings should recalculate their clip region
 391         if ( mpWindowImpl->mbClipSiblings )
 392         {
 393             vcl::Window* pWindow = mpWindowImpl->mpNext;
 394             while ( pWindow )
 395             {
 396                 pWindow->ImplUpdateSysObjChildrenClip();
 397                 pWindow = pWindow->mpWindowImpl->mpNext;
 398             }
 399         }
 400     }
 401     else
 402         mpWindowImpl->mpFrameWindow->ImplUpdateSysObjOverlapsClip();
 403 }
 404
 405 bool Window::ImplSetClipFlagChildren( bool bSysObjOnlySmaller )
 406 {
 407     bool bUpdate = true;
 408     if ( mpWindowImpl->mpSysObj )
 409     {
 410         vcl::Region* pOldRegion = nullptr;
 411         if ( bSysObjOnlySmaller && !mpWindowImpl->mbInitWinClipRegion )
 412             pOldRegion = new vcl::Region( mpWindowImpl->maWinClipRegion );
 413
 414         mbInitClipRegion = true;
 415         mpWindowImpl->mbInitWinClipRegion = true;
 416
 417         vcl::Window* pWindow = mpWindowImpl->mpFirstChild;
 418         while ( pWindow )
 419         {
 420             if ( !pWindow->ImplSetClipFlagChildren( bSysObjOnlySmaller ) )
 421                 bUpdate = false;
 422             pWindow = pWindow->mpWindowImpl->mpNext;
 423         }
 424
 425         if ( !ImplSysObjClip( pOldRegion ) )
 426         {
 427             mbInitClipRegion = true;
 428             mpWindowImpl->mbInitWinClipRegion = true;
 429             bUpdate = false;
 430         }
 431
 432         delete pOldRegion;
 433     }
 434     else
 435     {
 436     mbInitClipRegion = true;
 437     mpWindowImpl->mbInitWinClipRegion = true;
 438
 439     vcl::Window* pWindow = mpWindowImpl->mpFirstChild;
 440     while ( pWindow )
 441     {
 442         if ( !pWindow->ImplSetClipFlagChildren( bSysObjOnlySmaller ) )
 443             bUpdate = false;
 444         pWindow = pWindow->mpWindowImpl->mpNext;
 445     }
 446     }
 447     return bUpdate;
 448 }
 449
 450 bool Window::ImplSetClipFlagOverlapWindows( bool bSysObjOnlySmaller )
 451 {
 452     bool bUpdate = ImplSetClipFlagChildren( bSysObjOnlySmaller );
 453
 454     vcl::Window* pWindow = mpWindowImpl->mpFirstOverlap;
 455     while ( pWindow )
 456     {
 457         if ( !pWindow->ImplSetClipFlagOverlapWindows( bSysObjOnlySmaller ) )
 458             bUpdate = false;
 459         pWindow = pWindow->mpWindowImpl->mpNext;
 460     }
 461
 462     return bUpdate;
 463 }
 464
 465 bool Window::ImplSetClipFlag( bool bSysObjOnlySmaller )
 466 {
 467     if ( !ImplIsOverlapWindow() )
 468     {
 469         bool bUpdate = ImplSetClipFlagChildren( bSysObjOnlySmaller );
 470
 471         vcl::Window* pParent = ImplGetParent();
 472         if ( pParent &&
 473              ((pParent->GetStyle() & WB_CLIPCHILDREN) || (mpWindowImpl->mnParentClipMode & ParentClipMode::Clip)) )
 474         {
 475             pParent->mbInitClipRegion = true;
 476             pParent->mpWindowImpl->mbInitChildRegion = true;
 477         }
 478
 479         // siblings should recalculate their clip region
 480         if ( mpWindowImpl->mbClipSiblings )
 481         {
 482             vcl::Window* pWindow = mpWindowImpl->mpNext;
 483             while ( pWindow )
 484             {
 485                 if ( !pWindow->ImplSetClipFlagChildren( bSysObjOnlySmaller ) )
 486                     bUpdate = false;
 487                 pWindow = pWindow->mpWindowImpl->mpNext;
 488             }
 489         }
 490
 491         return bUpdate;
 492     }
 493     else
 494         return mpWindowImpl->mpFrameWindow->ImplSetClipFlagOverlapWindows( bSysObjOnlySmaller );
 495 }
 496
 497 void Window::ImplIntersectWindowClipRegion( vcl::Region& rRegion )
 498 {
 499     if ( mpWindowImpl->mbInitWinClipRegion )
 500         ImplInitWinClipRegion();
 501
 502     rRegion.Intersect( mpWindowImpl->maWinClipRegion );
 503 }
 504
 505 void Window::ImplIntersectWindowRegion( vcl::Region& rRegion )
 506 {
 507     rRegion.Intersect( Rectangle( Point( mnOutOffX, mnOutOffY ),
 508                                   Size( mnOutWidth, mnOutHeight ) ) );
 509     if ( mpWindowImpl->mbWinRegion )
 510         rRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
 511 }
 512
 513 void Window::ImplExcludeWindowRegion( vcl::Region& rRegion )
 514 {
 515     if ( mpWindowImpl->mbWinRegion )
 516     {
 517         Point aPoint( mnOutOffX, mnOutOffY );
 518         vcl::Region aRegion( Rectangle( aPoint,
 519                                    Size( mnOutWidth, mnOutHeight ) ) );
 520         aRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
 521         rRegion.Exclude( aRegion );
 522     }
 523     else
 524     {
 525         Point aPoint( mnOutOffX, mnOutOffY );
 526         rRegion.Exclude( Rectangle( aPoint,
 527                                     Size( mnOutWidth, mnOutHeight ) ) );
 528     }
 529 }
 530
 531 void Window::ImplExcludeOverlapWindows( vcl::Region& rRegion )
 532 {
 533     vcl::Window* pWindow = mpWindowImpl->mpFirstOverlap;
 534     while ( pWindow )
 535     {
 536         if ( pWindow->mpWindowImpl->mbReallyVisible )
 537         {
 538             pWindow->ImplExcludeWindowRegion( rRegion );
 539             pWindow->ImplExcludeOverlapWindows( rRegion );
 540         }
 541
 542         pWindow = pWindow->mpWindowImpl->mpNext;
 543     }
 544 }
 545
 546 void Window::ImplExcludeOverlapWindows2( vcl::Region& rRegion )
 547 {
 548     if ( mpWindowImpl->mbReallyVisible )
 549         ImplExcludeWindowRegion( rRegion );
 550
 551     ImplExcludeOverlapWindows( rRegion );
 552 }
 553
 554 void Window::ImplIntersectAndUnionOverlapWindows( const vcl::Region& rInterRegion, vcl::Region& rRegion )
 555 {
 556     vcl::Window* pWindow = mpWindowImpl->mpFirstOverlap;
 557     while ( pWindow )
 558     {
 559         if ( pWindow->mpWindowImpl->mbReallyVisible )
 560         {
 561             vcl::Region aTempRegion( rInterRegion );
 562             pWindow->ImplIntersectWindowRegion( aTempRegion );
 563             rRegion.Union( aTempRegion );
 564             pWindow->ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
 565         }
 566
 567         pWindow = pWindow->mpWindowImpl->mpNext;
 568     }
 569 }
 570
 571 void Window::ImplIntersectAndUnionOverlapWindows2( const vcl::Region& rInterRegion, vcl::Region& rRegion )
 572 {
 573     if ( mpWindowImpl->mbReallyVisible )
 574     {
 575         vcl::Region aTempRegion( rInterRegion );
 576         ImplIntersectWindowRegion( aTempRegion );
 577         rRegion.Union( aTempRegion );
 578     }
 579
 580     ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
 581 }
 582
 583 void Window::ImplCalcOverlapRegionOverlaps( const vcl::Region& rInterRegion, vcl::Region& rRegion )
 584 {
 585     // Clip Overlap Siblings
 586     vcl::Window* pStartOverlapWindow;
 587     if ( !ImplIsOverlapWindow() )
 588         pStartOverlapWindow = mpWindowImpl->mpOverlapWindow;
 589     else
 590         pStartOverlapWindow = this;
 591     while ( !pStartOverlapWindow->mpWindowImpl->mbFrame )
 592     {
 593         vcl::Window* pOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
 594         while ( pOverlapWindow && (pOverlapWindow != pStartOverlapWindow) )
 595         {
 596             pOverlapWindow->ImplIntersectAndUnionOverlapWindows2( rInterRegion, rRegion );
 597             pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 598         }
 599         pStartOverlapWindow = pStartOverlapWindow->mpWindowImpl->mpOverlapWindow;
 600     }
 601
 602     // Clip Child Overlap Windows
 603     if ( !ImplIsOverlapWindow() )
 604         mpWindowImpl->mpOverlapWindow->ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
 605     else
 606         ImplIntersectAndUnionOverlapWindows( rInterRegion, rRegion );
 607 }
 608
 609 void Window::ImplCalcOverlapRegion( const Rectangle& rSourceRect, vcl::Region& rRegion,
 610                                     bool bChildren, bool bSiblings )
 611 {
 612     vcl::Region  aRegion( rSourceRect );
 613     if ( mpWindowImpl->mbWinRegion )
 614         rRegion.Intersect( ImplPixelToDevicePixel( mpWindowImpl->maWinRegion ) );
 615     vcl::Region  aTempRegion;
 616     vcl::Window* pWindow;
 617
 618     ImplCalcOverlapRegionOverlaps( aRegion, rRegion );
 619
 620     // Parent-Boundaries
 621     pWindow = this;
 622     if ( !ImplIsOverlapWindow() )
 623     {
 624         pWindow = ImplGetParent();
 625         do
 626         {
 627             aTempRegion = aRegion;
 628             pWindow->ImplExcludeWindowRegion( aTempRegion );
 629             rRegion.Union( aTempRegion );
 630             if ( pWindow->ImplIsOverlapWindow() )
 631                 break;
 632             pWindow = pWindow->ImplGetParent();
 633         }
 634         while ( pWindow );
 635     }
 636     if ( pWindow && !pWindow->mpWindowImpl->mbFrame )
 637     {
 638         aTempRegion = aRegion;
 639         aTempRegion.Exclude( Rectangle( Point( 0, 0 ), Size( mpWindowImpl->mpFrameWindow->mnOutWidth, mpWindowImpl->mpFrameWindow->mnOutHeight ) ) );
 640         rRegion.Union( aTempRegion );
 641     }
 642
 643     // Siblings
 644     if ( bSiblings && !ImplIsOverlapWindow() )
 645     {
 646         pWindow = mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
 647         do
 648         {
 649             if ( pWindow->mpWindowImpl->mbReallyVisible && (pWindow != this) )
 650             {
 651                 aTempRegion = aRegion;
 652                 pWindow->ImplIntersectWindowRegion( aTempRegion );
 653                 rRegion.Union( aTempRegion );
 654             }
 655             pWindow = pWindow->mpWindowImpl->mpNext;
 656         }
 657         while ( pWindow );
 658     }
 659
 660     if ( bChildren )
 661     {
 662         pWindow = mpWindowImpl->mpFirstChild;
 663         while ( pWindow )
 664         {
 665             if ( pWindow->mpWindowImpl->mbReallyVisible )
 666             {
 667                 aTempRegion = aRegion;
 668                 pWindow->ImplIntersectWindowRegion( aTempRegion );
 669                 rRegion.Union( aTempRegion );
 670             }
 671             pWindow = pWindow->mpWindowImpl->mpNext;
 672         }
 673     }
 674 }
 675
 676 void Window::SaveBackground( const Point& rPos, const Size& rSize,
 677                              const Point& rDestOff, VirtualDevice& rSaveDevice )
 678 {
 679     if ( mpWindowImpl->mpPaintRegion )
 680     {
 681         vcl::Region      aClip( *mpWindowImpl->mpPaintRegion );
 682         const Point aPixPos( LogicToPixel( rPos ) );
 683
 684         aClip.Move( -mnOutOffX, -mnOutOffY );
 685         aClip.Intersect( Rectangle( aPixPos, LogicToPixel( rSize ) ) );
 686
 687         if ( !aClip.IsEmpty() )
 688         {
 689             const vcl::Region    aOldClip( rSaveDevice.GetClipRegion() );
 690             const Point     aPixOffset( rSaveDevice.LogicToPixel( rDestOff ) );
 691             const bool      bMap = rSaveDevice.IsMapModeEnabled();
 692
 693             // move clip region to have the same distance to DestOffset
 694             aClip.Move( aPixOffset.X() - aPixPos.X(), aPixOffset.Y() - aPixPos.Y() );
 695
 696             // set pixel clip region
 697             rSaveDevice.EnableMapMode( false );
 698             rSaveDevice.SetClipRegion( aClip );
 699             rSaveDevice.EnableMapMode( bMap );
 700             rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *this );
 701             rSaveDevice.SetClipRegion( aOldClip );
 702         }
 703     }
 704     else
 705         rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *this );
 706 }
 707
 708 } /* namespace vcl */
 709
 710 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */