vcl/source/window/stacking.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/syswin.hxx>
  21 #include <vcl/window.hxx>
  22 #include <vcl/taskpanelist.hxx>
  23 #include <sal/log.hxx>
  24
  25 #include <salframe.hxx>
  26 #include <salobj.hxx>
  27 #include <svdata.hxx>
  28 #include <window.h>
  29 #include <brdwin.hxx>
  30
  31 #include <com/sun/star/awt/XTopWindow.hpp>
  32
  33 using namespace ::com::sun::star::uno;
  34 using namespace ::com::sun::star::lang;
  35 using namespace ::com::sun::star::datatransfer::clipboard;
  36 using namespace ::com::sun::star::datatransfer::dnd;
  37 using namespace ::com::sun::star;
  38
  39 using ::com::sun::star::awt::XTopWindow;
  40
  41 struct ImplCalcToTopData
  42 {
  43     std::unique_ptr<ImplCalcToTopData> mpNext;
  44     VclPtr<vcl::Window>                mpWindow;
  45     std::unique_ptr<vcl::Region>       mpInvalidateRegion;
  46 };
  47
  48 namespace vcl {
  49
  50 vcl::Window* Window::ImplGetTopmostFrameWindow()
  51 {
  52     vcl::Window *pTopmostParent = this;
  53     while( pTopmostParent->ImplGetParent() )
  54         pTopmostParent = pTopmostParent->ImplGetParent();
  55     return pTopmostParent->mpWindowImpl->mpFrameWindow;
  56 }
  57
  58 void Window::ImplInsertWindow( vcl::Window* pParent )
  59 {
  60     mpWindowImpl->mpParent            = pParent;
  61     mpWindowImpl->mpRealParent        = pParent;
  62
  63     if ( !pParent || mpWindowImpl->mbFrame )
  64         return;
  65
  66     // search frame window and set window frame data
  67     vcl::Window* pFrameParent = pParent->mpWindowImpl->mpFrameWindow;
  68     mpWindowImpl->mpFrameData = pFrameParent->mpWindowImpl->mpFrameData;
  69     if (mpWindowImpl->mpFrame != pFrameParent->mpWindowImpl->mpFrame)
  70     {
  71         mpWindowImpl->mpFrame = pFrameParent->mpWindowImpl->mpFrame;
  72         if (mpWindowImpl->mpSysObj)
  73             mpWindowImpl->mpSysObj->Reparent(mpWindowImpl->mpFrame);
  74     }
  75     mpWindowImpl->mpFrameWindow   = pFrameParent;
  76     mpWindowImpl->mbFrame         = false;
  77
  78     // search overlap window and insert window in list
  79     if ( ImplIsOverlapWindow() )
  80     {
  81         vcl::Window* pFirstOverlapParent = pParent;
  82         while ( !pFirstOverlapParent->ImplIsOverlapWindow() )
  83             pFirstOverlapParent = pFirstOverlapParent->ImplGetParent();
  84         mpWindowImpl->mpOverlapWindow = pFirstOverlapParent;
  85
  86         mpWindowImpl->mpNextOverlap = mpWindowImpl->mpFrameData->mpFirstOverlap;
  87         mpWindowImpl->mpFrameData->mpFirstOverlap = this;
  88
  89         // Overlap-Windows are by default the uppermost
  90         mpWindowImpl->mpNext = pFirstOverlapParent->mpWindowImpl->mpFirstOverlap;
  91         pFirstOverlapParent->mpWindowImpl->mpFirstOverlap = this;
  92         if ( !pFirstOverlapParent->mpWindowImpl->mpLastOverlap )
  93             pFirstOverlapParent->mpWindowImpl->mpLastOverlap = this;
  94         else
  95             mpWindowImpl->mpNext->mpWindowImpl->mpPrev = this;
  96     }
  97     else
  98     {
  99         if ( pParent->ImplIsOverlapWindow() )
 100             mpWindowImpl->mpOverlapWindow = pParent;
 101         else
 102             mpWindowImpl->mpOverlapWindow = pParent->mpWindowImpl->mpOverlapWindow;
 103         mpWindowImpl->mpPrev = pParent->mpWindowImpl->mpLastChild;
 104         pParent->mpWindowImpl->mpLastChild = this;
 105         if ( !pParent->mpWindowImpl->mpFirstChild )
 106             pParent->mpWindowImpl->mpFirstChild = this;
 107         else
 108             mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
 109     }
 110 }
 111
 112 void Window::ImplRemoveWindow( bool bRemoveFrameData )
 113 {
 114     // remove window from the lists
 115     if ( !mpWindowImpl->mbFrame )
 116     {
 117         if ( ImplIsOverlapWindow() )
 118         {
 119             if ( mpWindowImpl->mpFrameData->mpFirstOverlap.get() == this )
 120                 mpWindowImpl->mpFrameData->mpFirstOverlap = mpWindowImpl->mpNextOverlap;
 121             else
 122             {
 123                 vcl::Window* pTempWin = mpWindowImpl->mpFrameData->mpFirstOverlap;
 124                 while ( pTempWin->mpWindowImpl->mpNextOverlap.get() != this )
 125                     pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
 126                 pTempWin->mpWindowImpl->mpNextOverlap = mpWindowImpl->mpNextOverlap;
 127             }
 128
 129             if ( mpWindowImpl->mpPrev )
 130                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 131             else
 132                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = mpWindowImpl->mpNext;
 133             if ( mpWindowImpl->mpNext )
 134                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 135             else
 136                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
 137         }
 138         else
 139         {
 140             if ( mpWindowImpl->mpPrev )
 141                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 142             else if ( mpWindowImpl->mpParent )
 143                 mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
 144             if ( mpWindowImpl->mpNext )
 145                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 146             else if ( mpWindowImpl->mpParent )
 147                 mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = mpWindowImpl->mpPrev;
 148         }
 149
 150         mpWindowImpl->mpPrev = nullptr;
 151         mpWindowImpl->mpNext = nullptr;
 152     }
 153
 154     if ( bRemoveFrameData )
 155     {
 156         // release the graphic
 157         OutputDevice *pOutDev = GetOutDev();
 158         pOutDev->ReleaseGraphics();
 159     }
 160 }
 161
 162 void Window::reorderWithinParent(sal_uInt16 nNewPosition)
 163 {
 164     sal_uInt16 nChildCount = 0;
 165     vcl::Window *pSource = mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
 166     while (pSource)
 167     {
 168         if (nChildCount == nNewPosition)
 169             break;
 170         pSource = pSource->mpWindowImpl->mpNext;
 171         nChildCount++;
 172     }
 173
 174     if (pSource == this) //already at the right place
 175         return;
 176
 177     ImplRemoveWindow(false);
 178
 179     if (pSource)
 180     {
 181         mpWindowImpl->mpNext = pSource;
 182         mpWindowImpl->mpPrev = pSource->mpWindowImpl->mpPrev;
 183         pSource->mpWindowImpl->mpPrev = this;
 184     }
 185     else
 186         mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = this;
 187
 188     if (mpWindowImpl->mpPrev)
 189         mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
 190     else
 191         mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = this;
 192 }
 193
 194 void Window::ImplToBottomChild()
 195 {
 196     if ( ImplIsOverlapWindow() || mpWindowImpl->mbReallyVisible || (mpWindowImpl->mpParent->mpWindowImpl->mpLastChild.get() == this) )
 197         return;
 198
 199     // put the window to the end of the list
 200     if ( mpWindowImpl->mpPrev )
 201         mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 202     else
 203         mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
 204     mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 205     mpWindowImpl->mpPrev = mpWindowImpl->mpParent->mpWindowImpl->mpLastChild;
 206     mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = this;
 207     mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
 208     mpWindowImpl->mpNext = nullptr;
 209 }
 210
 211 void Window::ImplCalcToTop( ImplCalcToTopData* pPrevData )
 212 {
 213     SAL_WARN_IF( !ImplIsOverlapWindow(), "vcl", "Window::ImplCalcToTop(): Is not an OverlapWindow" );
 214
 215     if ( mpWindowImpl->mbFrame )
 216         return;
 217
 218     if ( !IsReallyVisible() )
 219         return;
 220
 221     // calculate region, where the window overlaps with other windows
 222     Point aPoint( mnOutOffX, mnOutOffY );
 223     vcl::Region  aRegion( tools::Rectangle( aPoint,
 224                                 Size( mnOutWidth, mnOutHeight ) ) );
 225     vcl::Region  aInvalidateRegion;
 226     ImplCalcOverlapRegionOverlaps( aRegion, aInvalidateRegion );
 227
 228     if ( !aInvalidateRegion.IsEmpty() )
 229     {
 230         ImplCalcToTopData* pData    = new ImplCalcToTopData;
 231         pPrevData->mpNext.reset(pData);
 232         pData->mpWindow             = this;
 233         pData->mpInvalidateRegion.reset(new vcl::Region( aInvalidateRegion ));
 234     }
 235 }
 236
 237 void Window::ImplToTop( ToTopFlags nFlags )
 238 {
 239     SAL_WARN_IF( !ImplIsOverlapWindow(), "vcl", "Window::ImplToTop(): Is not an OverlapWindow" );
 240
 241     if ( mpWindowImpl->mbFrame )
 242     {
 243         // on a mouse click in the external window, it is the latter's
 244         // responsibility to assure our frame is put in front
 245         if ( !mpWindowImpl->mpFrameData->mbHasFocus &&
 246              !mpWindowImpl->mpFrameData->mbSysObjFocus &&
 247              !mpWindowImpl->mpFrameData->mbInSysObjFocusHdl &&
 248              !mpWindowImpl->mpFrameData->mbInSysObjToTopHdl )
 249         {
 250             // do not bring floating windows on the client to top
 251             if( !ImplGetClientWindow() || !(ImplGetClientWindow()->GetStyle() & WB_SYSTEMFLOATWIN) )
 252             {
 253                 SalFrameToTop nSysFlags = SalFrameToTop::NONE;
 254                 if ( nFlags & ToTopFlags::RestoreWhenMin )
 255                     nSysFlags |= SalFrameToTop::RestoreWhenMin;
 256                 if ( nFlags & ToTopFlags::ForegroundTask )
 257                     nSysFlags |= SalFrameToTop::ForegroundTask;
 258                 if ( nFlags & ToTopFlags::GrabFocusOnly )
 259                     nSysFlags |= SalFrameToTop::GrabFocusOnly;
 260                 mpWindowImpl->mpFrame->ToTop( nSysFlags );
 261             }
 262         }
 263     }
 264     else
 265     {
 266         if ( mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap.get() != this )
 267         {
 268             // remove window from the list
 269             mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 270             if ( mpWindowImpl->mpNext )
 271                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 272             else
 273                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
 274
 275             // take AlwaysOnTop into account
 276             bool    bOnTop = IsAlwaysOnTopEnabled();
 277             vcl::Window* pNextWin = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
 278             if ( !bOnTop )
 279             {
 280                 while ( pNextWin )
 281                 {
 282                     if ( !pNextWin->IsAlwaysOnTopEnabled() )
 283                         break;
 284                     pNextWin = pNextWin->mpWindowImpl->mpNext;
 285                 }
 286             }
 287
 288             // add the window to the list again
 289             mpWindowImpl->mpNext = pNextWin;
 290             if ( pNextWin )
 291             {
 292                 mpWindowImpl->mpPrev = pNextWin->mpWindowImpl->mpPrev;
 293                 pNextWin->mpWindowImpl->mpPrev = this;
 294             }
 295             else
 296             {
 297                 mpWindowImpl->mpPrev = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap;
 298                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = this;
 299             }
 300             if ( mpWindowImpl->mpPrev )
 301                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
 302             else
 303                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = this;
 304
 305             // recalculate ClipRegion of this and all overlapping windows
 306             if ( IsReallyVisible() )
 307             {
 308                 mpWindowImpl->mpOverlapWindow->ImplSetClipFlagOverlapWindows();
 309             }
 310         }
 311     }
 312 }
 313
 314 void Window::ImplStartToTop( ToTopFlags nFlags )
 315 {
 316     ImplCalcToTopData   aStartData;
 317     ImplCalcToTopData*  pCurData;
 318     vcl::Window* pOverlapWindow;
 319     if ( ImplIsOverlapWindow() )
 320         pOverlapWindow = this;
 321     else
 322         pOverlapWindow = mpWindowImpl->mpOverlapWindow;
 323
 324     // first calculate paint areas
 325     vcl::Window* pTempOverlapWindow = pOverlapWindow;
 326     aStartData.mpNext = nullptr;
 327     pCurData = &aStartData;
 328     do
 329     {
 330         pTempOverlapWindow->ImplCalcToTop( pCurData );
 331         if ( pCurData->mpNext )
 332             pCurData = pCurData->mpNext.get();
 333         pTempOverlapWindow = pTempOverlapWindow->mpWindowImpl->mpOverlapWindow;
 334     }
 335     while ( !pTempOverlapWindow->mpWindowImpl->mbFrame );
 336     // next calculate the paint areas of the ChildOverlap windows
 337     pTempOverlapWindow = mpWindowImpl->mpFirstOverlap;
 338     while ( pTempOverlapWindow )
 339     {
 340         pTempOverlapWindow->ImplCalcToTop( pCurData );
 341         if ( pCurData->mpNext )
 342             pCurData = pCurData->mpNext.get();
 343         pTempOverlapWindow = pTempOverlapWindow->mpWindowImpl->mpNext;
 344     }
 345
 346     // and next change the windows list
 347     pTempOverlapWindow = pOverlapWindow;
 348     do
 349     {
 350         pTempOverlapWindow->ImplToTop( nFlags );
 351         pTempOverlapWindow = pTempOverlapWindow->mpWindowImpl->mpOverlapWindow;
 352     }
 353     while ( !pTempOverlapWindow->mpWindowImpl->mbFrame );
 354     // as last step invalidate the invalid areas
 355     pCurData = aStartData.mpNext.get();
 356     while ( pCurData )
 357     {
 358         pCurData->mpWindow->ImplInvalidateFrameRegion( pCurData->mpInvalidateRegion.get(), InvalidateFlags::Children );
 359         pCurData = pCurData->mpNext.get();
 360     }
 361 }
 362
 363 void Window::ImplFocusToTop( ToTopFlags nFlags, bool bReallyVisible )
 364 {
 365     // do we need to fetch the focus?
 366     if ( !(nFlags & ToTopFlags::NoGrabFocus) )
 367     {
 368         // first window with GrabFocus-Activate gets the focus
 369         vcl::Window* pFocusWindow = this;
 370         while ( !pFocusWindow->ImplIsOverlapWindow() )
 371         {
 372             // if the window has no BorderWindow, we
 373             // should always find the belonging BorderWindow
 374             if ( !pFocusWindow->mpWindowImpl->mpBorderWindow )
 375             {
 376                 if ( pFocusWindow->mpWindowImpl->mnActivateMode & ActivateModeFlags::GrabFocus )
 377                     break;
 378             }
 379             pFocusWindow = pFocusWindow->ImplGetParent();
 380         }
 381         if ( (pFocusWindow->mpWindowImpl->mnActivateMode & ActivateModeFlags::GrabFocus) &&
 382              !pFocusWindow->HasChildPathFocus( true ) )
 383             pFocusWindow->GrabFocus();
 384     }
 385
 386     if ( bReallyVisible )
 387         ImplGenerateMouseMove();
 388 }
 389
 390 void Window::ImplShowAllOverlaps()
 391 {
 392     vcl::Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
 393     while ( pOverlapWindow )
 394     {
 395         if ( pOverlapWindow->mpWindowImpl->mbOverlapVisible )
 396         {
 397             pOverlapWindow->Show( true, ShowFlags::NoActivate );
 398             pOverlapWindow->mpWindowImpl->mbOverlapVisible = false;
 399         }
 400
 401         pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 402     }
 403 }
 404
 405 void Window::ImplHideAllOverlaps()
 406 {
 407     vcl::Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
 408     while ( pOverlapWindow )
 409     {
 410         if ( pOverlapWindow->IsVisible() )
 411         {
 412             pOverlapWindow->mpWindowImpl->mbOverlapVisible = true;
 413             pOverlapWindow->Show( false );
 414         }
 415
 416         pOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 417     }
 418 }
 419
 420 void Window::ToTop( ToTopFlags nFlags )
 421 {
 422     if (!mpWindowImpl)
 423         return;
 424
 425     ImplStartToTop( nFlags );
 426     ImplFocusToTop( nFlags, IsReallyVisible() );
 427 }
 428
 429 void Window::SetZOrder( vcl::Window* pRefWindow, ZOrderFlags nFlags )
 430 {
 431
 432     if ( mpWindowImpl->mpBorderWindow )
 433     {
 434         mpWindowImpl->mpBorderWindow->SetZOrder( pRefWindow, nFlags );
 435         return;
 436     }
 437
 438     if ( nFlags & ZOrderFlags::First )
 439     {
 440         if ( ImplIsOverlapWindow() )
 441             pRefWindow = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
 442         else
 443             pRefWindow = mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild;
 444         nFlags |= ZOrderFlags::Before;
 445     }
 446     else if ( nFlags & ZOrderFlags::Last )
 447     {
 448         if ( ImplIsOverlapWindow() )
 449             pRefWindow = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap;
 450         else
 451             pRefWindow = mpWindowImpl->mpParent->mpWindowImpl->mpLastChild;
 452         nFlags |= ZOrderFlags::Behind;
 453     }
 454
 455     while ( pRefWindow && pRefWindow->mpWindowImpl->mpBorderWindow )
 456         pRefWindow = pRefWindow->mpWindowImpl->mpBorderWindow;
 457     if (!pRefWindow || pRefWindow == this || mpWindowImpl->mbFrame)
 458         return;
 459
 460     SAL_WARN_IF( pRefWindow->mpWindowImpl->mpParent != mpWindowImpl->mpParent, "vcl", "Window::SetZOrder() - pRefWindow has other parent" );
 461     if ( nFlags & ZOrderFlags::Before )
 462     {
 463         if ( pRefWindow->mpWindowImpl->mpPrev.get() == this )
 464             return;
 465
 466         if ( ImplIsOverlapWindow() )
 467         {
 468             if ( mpWindowImpl->mpPrev )
 469                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 470             else
 471                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = mpWindowImpl->mpNext;
 472             if ( mpWindowImpl->mpNext )
 473                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 474             else
 475                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
 476             if ( !pRefWindow->mpWindowImpl->mpPrev )
 477                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = this;
 478         }
 479         else
 480         {
 481             if ( mpWindowImpl->mpPrev )
 482                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 483             else
 484                 mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
 485             if ( mpWindowImpl->mpNext )
 486                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 487             else
 488                 mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = mpWindowImpl->mpPrev;
 489             if ( !pRefWindow->mpWindowImpl->mpPrev )
 490                 mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = this;
 491         }
 492
 493         mpWindowImpl->mpPrev = pRefWindow->mpWindowImpl->mpPrev;
 494         mpWindowImpl->mpNext = pRefWindow;
 495         if ( mpWindowImpl->mpPrev )
 496             mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
 497         mpWindowImpl->mpNext->mpWindowImpl->mpPrev = this;
 498     }
 499     else if ( nFlags & ZOrderFlags::Behind )
 500     {
 501         if ( pRefWindow->mpWindowImpl->mpNext.get() == this )
 502             return;
 503
 504         if ( ImplIsOverlapWindow() )
 505         {
 506             if ( mpWindowImpl->mpPrev )
 507                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 508             else
 509                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = mpWindowImpl->mpNext;
 510             if ( mpWindowImpl->mpNext )
 511                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 512             else
 513                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = mpWindowImpl->mpPrev;
 514             if ( !pRefWindow->mpWindowImpl->mpNext )
 515                 mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = this;
 516         }
 517         else
 518         {
 519             if ( mpWindowImpl->mpPrev )
 520                 mpWindowImpl->mpPrev->mpWindowImpl->mpNext = mpWindowImpl->mpNext;
 521             else
 522                 mpWindowImpl->mpParent->mpWindowImpl->mpFirstChild = mpWindowImpl->mpNext;
 523             if ( mpWindowImpl->mpNext )
 524                 mpWindowImpl->mpNext->mpWindowImpl->mpPrev = mpWindowImpl->mpPrev;
 525             else
 526                 mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = mpWindowImpl->mpPrev;
 527             if ( !pRefWindow->mpWindowImpl->mpNext )
 528                 mpWindowImpl->mpParent->mpWindowImpl->mpLastChild = this;
 529         }
 530
 531         mpWindowImpl->mpPrev = pRefWindow;
 532         mpWindowImpl->mpNext = pRefWindow->mpWindowImpl->mpNext;
 533         if ( mpWindowImpl->mpNext )
 534             mpWindowImpl->mpNext->mpWindowImpl->mpPrev = this;
 535         mpWindowImpl->mpPrev->mpWindowImpl->mpNext = this;
 536     }
 537
 538     if ( !IsReallyVisible() )
 539         return;
 540
 541     if ( !mpWindowImpl->mbInitWinClipRegion && mpWindowImpl->maWinClipRegion.IsEmpty() )
 542         return;
 543
 544     bool bInitWinClipRegion = mpWindowImpl->mbInitWinClipRegion;
 545     ImplSetClipFlag();
 546
 547     // When ClipRegion was not initialised, assume
 548     // the window has not been sent, therefore do not
 549     // trigger any Invalidates. This is an optimization
 550     // for HTML documents with many controls. If this
 551     // check gives problems, a flag should be introduced
 552     // which tracks whether the window has already been
 553     // emitted after Show
 554     if ( bInitWinClipRegion )
 555         return;
 556
 557     // Invalidate all windows which are next to each other
 558     // Is INCOMPLETE !!!
 559     tools::Rectangle   aWinRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
 560     vcl::Window*     pWindow = nullptr;
 561     if ( ImplIsOverlapWindow() )
 562     {
 563         if ( mpWindowImpl->mpOverlapWindow )
 564             pWindow = mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap;
 565     }
 566     else
 567         pWindow = ImplGetParent()->mpWindowImpl->mpFirstChild;
 568     // Invalidate all windows in front of us and which are covered by us
 569     while ( pWindow )
 570     {
 571         if ( pWindow == this )
 572             break;
 573         tools::Rectangle aCompRect( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
 574                              Size( pWindow->mnOutWidth, pWindow->mnOutHeight ) );
 575         if ( aWinRect.IsOver( aCompRect ) )
 576             pWindow->Invalidate( InvalidateFlags::Children | InvalidateFlags::NoTransparent );
 577         pWindow = pWindow->mpWindowImpl->mpNext;
 578     }
 579
 580     // If we are covered by a window in the background
 581     // we should redraw it
 582     while ( pWindow )
 583     {
 584         if ( pWindow != this )
 585         {
 586             tools::Rectangle aCompRect( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ),
 587                                  Size( pWindow->mnOutWidth, pWindow->mnOutHeight ) );
 588             if ( aWinRect.IsOver( aCompRect ) )
 589             {
 590                 Invalidate( InvalidateFlags::Children | InvalidateFlags::NoTransparent );
 591                 break;
 592             }
 593         }
 594         pWindow = pWindow->mpWindowImpl->mpNext;
 595     }
 596 }
 597
 598 void Window::EnableAlwaysOnTop( bool bEnable )
 599 {
 600
 601     mpWindowImpl->mbAlwaysOnTop = bEnable;
 602
 603     if ( mpWindowImpl->mpBorderWindow )
 604         mpWindowImpl->mpBorderWindow->EnableAlwaysOnTop( bEnable );
 605     else if ( bEnable && IsReallyVisible() )
 606         ToTop();
 607
 608     if ( mpWindowImpl->mbFrame )
 609         mpWindowImpl->mpFrame->SetAlwaysOnTop( bEnable );
 610 }
 611
 612 bool Window::IsTopWindow() const
 613 {
 614     if ( !mpWindowImpl || mpWindowImpl->mbInDispose )
 615         return false;
 616
 617     // topwindows must be frames or they must have a borderwindow which is a frame
 618     if( !mpWindowImpl->mbFrame && (!mpWindowImpl->mpBorderWindow || !mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame ) )
 619         return false;
 620
 621     ImplGetWinData();
 622     if( mpWindowImpl->mpWinData->mnIsTopWindow == sal_uInt16(~0))    // still uninitialized
 623     {
 624         // #113722#, cache result of expensive queryInterface call
 625         vcl::Window *pThisWin = const_cast<vcl::Window*>(this);
 626         uno::Reference< XTopWindow > xTopWindow( pThisWin->GetComponentInterface(), UNO_QUERY );
 627         pThisWin->mpWindowImpl->mpWinData->mnIsTopWindow = xTopWindow.is() ? 1 : 0;
 628     }
 629     return mpWindowImpl->mpWinData->mnIsTopWindow == 1;
 630 }
 631
 632 vcl::Window* Window::ImplFindWindow( const Point& rFramePos )
 633 {
 634     vcl::Window* pTempWindow;
 635     vcl::Window* pFindWindow;
 636
 637     // first check all overlapping windows
 638     pTempWindow = mpWindowImpl->mpFirstOverlap;
 639     while ( pTempWindow )
 640     {
 641         pFindWindow = pTempWindow->ImplFindWindow( rFramePos );
 642         if ( pFindWindow )
 643             return pFindWindow;
 644         pTempWindow = pTempWindow->mpWindowImpl->mpNext;
 645     }
 646
 647     // then we check our window
 648     if ( !mpWindowImpl->mbVisible )
 649         return nullptr;
 650
 651     WindowHitTest nHitTest = ImplHitTest( rFramePos );
 652     if ( nHitTest & WindowHitTest::Inside )
 653     {
 654         // and then we check all child windows
 655         pTempWindow = mpWindowImpl->mpFirstChild;
 656         while ( pTempWindow )
 657         {
 658             pFindWindow = pTempWindow->ImplFindWindow( rFramePos );
 659             if ( pFindWindow )
 660                 return pFindWindow;
 661             pTempWindow = pTempWindow->mpWindowImpl->mpNext;
 662         }
 663
 664         if ( nHitTest & WindowHitTest::Transparent )
 665             return nullptr;
 666         else
 667             return this;
 668     }
 669
 670     return nullptr;
 671 }
 672
 673 bool Window::ImplIsRealParentPath( const vcl::Window* pWindow ) const
 674 {
 675     pWindow = pWindow->GetParent();
 676     while ( pWindow )
 677     {
 678         if ( pWindow == this )
 679             return true;
 680         pWindow = pWindow->GetParent();
 681     }
 682
 683     return false;
 684 }
 685
 686 bool Window::ImplIsChild( const vcl::Window* pWindow, bool bSystemWindow ) const
 687 {
 688     do
 689     {
 690         if ( !bSystemWindow && pWindow->ImplIsOverlapWindow() )
 691             break;
 692
 693         pWindow = pWindow->ImplGetParent();
 694
 695         if ( pWindow == this )
 696             return true;
 697     }
 698     while ( pWindow );
 699
 700     return false;
 701 }
 702
 703 bool Window::ImplIsWindowOrChild( const vcl::Window* pWindow, bool bSystemWindow ) const
 704 {
 705     if ( this == pWindow )
 706         return true;
 707     return ImplIsChild( pWindow, bSystemWindow );
 708 }
 709
 710 void Window::ImplResetReallyVisible()
 711 {
 712     bool bBecameReallyInvisible = mpWindowImpl->mbReallyVisible;
 713
 714     mbDevOutput     = false;
 715     mpWindowImpl->mbReallyVisible = false;
 716     mpWindowImpl->mbReallyShown   = false;
 717
 718     // the SHOW/HIDE events serve as indicators to send child creation/destroy events to the access bridge.
 719     // For this, the data member of the event must not be NULL.
 720     // Previously, we did this in Window::Show, but there some events got lost in certain situations.
 721     if( bBecameReallyInvisible && ImplIsAccessibleCandidate() )
 722         CallEventListeners( VclEventId::WindowHide, this );
 723         // TODO. It's kind of a hack that we're re-using the VclEventId::WindowHide. Normally, we should
 724         // introduce another event which explicitly triggers the Accessibility implementations.
 725
 726     vcl::Window* pWindow = mpWindowImpl->mpFirstOverlap;
 727     while ( pWindow )
 728     {
 729         if ( pWindow->mpWindowImpl->mbReallyVisible )
 730             pWindow->ImplResetReallyVisible();
 731         pWindow = pWindow->mpWindowImpl->mpNext;
 732     }
 733
 734     pWindow = mpWindowImpl->mpFirstChild;
 735     while ( pWindow )
 736     {
 737         if ( pWindow->mpWindowImpl->mbReallyVisible )
 738             pWindow->ImplResetReallyVisible();
 739         pWindow = pWindow->mpWindowImpl->mpNext;
 740     }
 741 }
 742
 743 void Window::ImplUpdateWindowPtr( vcl::Window* pWindow )
 744 {
 745     if ( mpWindowImpl->mpFrameWindow != pWindow->mpWindowImpl->mpFrameWindow )
 746     {
 747         // release graphic
 748         OutputDevice *pOutDev = GetOutDev();
 749         pOutDev->ReleaseGraphics();
 750     }
 751
 752     mpWindowImpl->mpFrameData     = pWindow->mpWindowImpl->mpFrameData;
 753     if (mpWindowImpl->mpFrame != pWindow->mpWindowImpl->mpFrame)
 754     {
 755         mpWindowImpl->mpFrame = pWindow->mpWindowImpl->mpFrame;
 756         if (mpWindowImpl->mpSysObj)
 757             mpWindowImpl->mpSysObj->Reparent(mpWindowImpl->mpFrame);
 758     }
 759     mpWindowImpl->mpFrameWindow   = pWindow->mpWindowImpl->mpFrameWindow;
 760     if ( pWindow->ImplIsOverlapWindow() )
 761         mpWindowImpl->mpOverlapWindow = pWindow;
 762     else
 763         mpWindowImpl->mpOverlapWindow = pWindow->mpWindowImpl->mpOverlapWindow;
 764
 765     vcl::Window* pChild = mpWindowImpl->mpFirstChild;
 766     while ( pChild )
 767     {
 768         pChild->ImplUpdateWindowPtr( pWindow );
 769         pChild = pChild->mpWindowImpl->mpNext;
 770     }
 771 }
 772
 773 void Window::ImplUpdateWindowPtr()
 774 {
 775     vcl::Window* pChild = mpWindowImpl->mpFirstChild;
 776     while ( pChild )
 777     {
 778         pChild->ImplUpdateWindowPtr( this );
 779         pChild = pChild->mpWindowImpl->mpNext;
 780     }
 781 }
 782
 783 void Window::ImplUpdateOverlapWindowPtr( bool bNewFrame )
 784 {
 785     bool bVisible = IsVisible();
 786     Show( false );
 787     ImplRemoveWindow( bNewFrame );
 788     vcl::Window* pRealParent = mpWindowImpl->mpRealParent;
 789     ImplInsertWindow( ImplGetParent() );
 790     mpWindowImpl->mpRealParent = pRealParent;
 791     ImplUpdateWindowPtr();
 792     if ( ImplUpdatePos() )
 793         ImplUpdateSysObjPos();
 794
 795     if ( bNewFrame )
 796     {
 797         vcl::Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
 798         while ( pOverlapWindow )
 799         {
 800             vcl::Window* pNextOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 801             pOverlapWindow->ImplUpdateOverlapWindowPtr( bNewFrame );
 802             pOverlapWindow = pNextOverlapWindow;
 803         }
 804     }
 805
 806     if ( bVisible )
 807         Show();
 808 }
 809
 810 SystemWindow* Window::GetSystemWindow() const
 811 {
 812
 813     const vcl::Window* pWin = this;
 814     while ( pWin && !pWin->IsSystemWindow() )
 815         pWin  = pWin->GetParent();
 816     return static_cast<SystemWindow*>(const_cast<Window*>(pWin));
 817 }
 818
 819 static SystemWindow *ImplGetLastSystemWindow( vcl::Window *pWin )
 820 {
 821     // get the most top-level system window, the one that contains the taskpanelist
 822     SystemWindow *pSysWin = nullptr;
 823     if( !pWin )
 824         return pSysWin;
 825     vcl::Window *pMyParent = pWin;
 826     while ( pMyParent )
 827     {
 828         if ( pMyParent->IsSystemWindow() )
 829             pSysWin = static_cast<SystemWindow*>(pMyParent);
 830         pMyParent = pMyParent->GetParent();
 831     }
 832     return pSysWin;
 833 }
 834
 835 void Window::SetParent( vcl::Window* pNewParent )
 836 {
 837     SAL_WARN_IF( !pNewParent, "vcl", "Window::SetParent(): pParent == NULL" );
 838     SAL_WARN_IF( pNewParent == this, "vcl", "someone tried to reparent a window to itself" );
 839
 840     if( !pNewParent || pNewParent == this )
 841         return;
 842
 843     // check if the taskpanelist would change and move the window pointer accordingly
 844     SystemWindow *pSysWin = ImplGetLastSystemWindow(this);
 845     SystemWindow *pNewSysWin = nullptr;
 846     bool bChangeTaskPaneList = false;
 847     if( pSysWin && pSysWin->ImplIsInTaskPaneList( this ) )
 848     {
 849         pNewSysWin = ImplGetLastSystemWindow( pNewParent );
 850         if( pNewSysWin && pNewSysWin != pSysWin )
 851         {
 852             bChangeTaskPaneList = true;
 853             pSysWin->GetTaskPaneList()->RemoveWindow( this );
 854         }
 855     }
 856     // remove ownerdraw decorated windows from list in the top-most frame window
 857     if( (GetStyle() & WB_OWNERDRAWDECORATION) && mpWindowImpl->mbFrame )
 858     {
 859         ::std::vector< VclPtr<vcl::Window> >& rList = ImplGetOwnerDrawList();
 860         auto p = ::std::find( rList.begin(), rList.end(), VclPtr<vcl::Window>(this) );
 861         if( p != rList.end() )
 862             rList.erase( p );
 863     }
 864
 865     ImplSetFrameParent( pNewParent );
 866
 867     if ( mpWindowImpl->mpBorderWindow )
 868     {
 869         mpWindowImpl->mpRealParent = pNewParent;
 870         mpWindowImpl->mpBorderWindow->SetParent( pNewParent );
 871         return;
 872     }
 873
 874     if ( mpWindowImpl->mpParent.get() == pNewParent )
 875         return;
 876
 877     if ( mpWindowImpl->mbFrame )
 878         mpWindowImpl->mpFrame->SetParent( pNewParent->mpWindowImpl->mpFrame );
 879
 880     bool bVisible = IsVisible();
 881     Show( false, ShowFlags::NoFocusChange );
 882
 883     // check if the overlap window changes
 884     vcl::Window* pOldOverlapWindow;
 885     vcl::Window* pNewOverlapWindow = nullptr;
 886     if ( ImplIsOverlapWindow() )
 887         pOldOverlapWindow = nullptr;
 888     else
 889     {
 890         pNewOverlapWindow = pNewParent->ImplGetFirstOverlapWindow();
 891         if ( mpWindowImpl->mpOverlapWindow.get() != pNewOverlapWindow )
 892             pOldOverlapWindow = mpWindowImpl->mpOverlapWindow;
 893         else
 894             pOldOverlapWindow = nullptr;
 895     }
 896
 897     // convert windows in the hierarchy
 898     bool bFocusOverlapWin = HasChildPathFocus( true );
 899     bool bFocusWin = HasChildPathFocus();
 900     bool bNewFrame = pNewParent->mpWindowImpl->mpFrameWindow != mpWindowImpl->mpFrameWindow;
 901     if ( bNewFrame )
 902     {
 903         if ( mpWindowImpl->mpFrameData->mpFocusWin )
 904         {
 905             if ( IsWindowOrChild( mpWindowImpl->mpFrameData->mpFocusWin ) )
 906                 mpWindowImpl->mpFrameData->mpFocusWin = nullptr;
 907         }
 908         if ( mpWindowImpl->mpFrameData->mpMouseMoveWin )
 909         {
 910             if ( IsWindowOrChild( mpWindowImpl->mpFrameData->mpMouseMoveWin ) )
 911                 mpWindowImpl->mpFrameData->mpMouseMoveWin = nullptr;
 912         }
 913         if ( mpWindowImpl->mpFrameData->mpMouseDownWin )
 914         {
 915             if ( IsWindowOrChild( mpWindowImpl->mpFrameData->mpMouseDownWin ) )
 916                 mpWindowImpl->mpFrameData->mpMouseDownWin = nullptr;
 917         }
 918     }
 919     ImplRemoveWindow( bNewFrame );
 920     ImplInsertWindow( pNewParent );
 921     if ( mpWindowImpl->mnParentClipMode & ParentClipMode::Clip )
 922         pNewParent->mpWindowImpl->mbClipChildren = true;
 923     ImplUpdateWindowPtr();
 924     if ( ImplUpdatePos() )
 925         ImplUpdateSysObjPos();
 926
 927     // If the Overlap-Window has changed, we need to test whether
 928     // OverlapWindows that had the Child window as their parent
 929     // need to be put into the window hierarchy.
 930     if ( ImplIsOverlapWindow() )
 931     {
 932         if ( bNewFrame )
 933         {
 934             vcl::Window* pOverlapWindow = mpWindowImpl->mpFirstOverlap;
 935             while ( pOverlapWindow )
 936             {
 937                 vcl::Window* pNextOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 938                 pOverlapWindow->ImplUpdateOverlapWindowPtr( bNewFrame );
 939                 pOverlapWindow = pNextOverlapWindow;
 940             }
 941         }
 942     }
 943     else if ( pOldOverlapWindow )
 944     {
 945         // reset Focus-Save
 946         if ( bFocusWin ||
 947              (pOldOverlapWindow->mpWindowImpl->mpLastFocusWindow &&
 948               IsWindowOrChild( pOldOverlapWindow->mpWindowImpl->mpLastFocusWindow )) )
 949             pOldOverlapWindow->mpWindowImpl->mpLastFocusWindow = nullptr;
 950
 951         vcl::Window* pOverlapWindow = pOldOverlapWindow->mpWindowImpl->mpFirstOverlap;
 952         while ( pOverlapWindow )
 953         {
 954             vcl::Window* pNextOverlapWindow = pOverlapWindow->mpWindowImpl->mpNext;
 955             if ( ImplIsRealParentPath( pOverlapWindow->ImplGetWindow() ) )
 956                 pOverlapWindow->ImplUpdateOverlapWindowPtr( bNewFrame );
 957             pOverlapWindow = pNextOverlapWindow;
 958         }
 959
 960         // update activate-status at next overlap window
 961         if ( HasChildPathFocus( true ) )
 962             ImplCallFocusChangeActivate( pNewOverlapWindow, pOldOverlapWindow );
 963     }
 964
 965     // also convert Activate-Status
 966     if ( bNewFrame )
 967     {
 968         if ( (GetType() == WindowType::BORDERWINDOW) &&
 969              (ImplGetWindow()->GetType() == WindowType::FLOATINGWINDOW) )
 970             static_cast<ImplBorderWindow*>(this)->SetDisplayActive( mpWindowImpl->mpFrameData->mbHasFocus );
 971     }
 972
 973     // when required give focus to new frame if
 974     // FocusWindow is changed with SetParent()
 975     if ( bFocusOverlapWin )
 976     {
 977         mpWindowImpl->mpFrameData->mpFocusWin = Application::GetFocusWindow();
 978         if ( !mpWindowImpl->mpFrameData->mbHasFocus )
 979         {
 980             mpWindowImpl->mpFrame->ToTop( SalFrameToTop::NONE );
 981         }
 982     }
 983
 984     // Assure DragSource and DropTarget members are created
 985     if ( bNewFrame )
 986     {
 987             GetDropTarget();
 988     }
 989
 990     if( bChangeTaskPaneList )
 991         pNewSysWin->GetTaskPaneList()->AddWindow( this );
 992
 993     if( (GetStyle() & WB_OWNERDRAWDECORATION) && mpWindowImpl->mbFrame )
 994         ImplGetOwnerDrawList().emplace_back(this );
 995
 996     if ( bVisible )
 997         Show( true, ShowFlags::NoFocusChange | ShowFlags::NoActivate );
 998 }
 999
1000 bool Window::IsAncestorOf( const vcl::Window& rWindow ) const
1001 {
1002     return ImplIsRealParentPath(&rWindow);
1003 }
1004
1005 sal_uInt16 Window::GetChildCount() const
1006 {
1007     if (!mpWindowImpl)
1008         return 0;
1009
1010     sal_uInt16  nChildCount = 0;
1011     vcl::Window* pChild = mpWindowImpl->mpFirstChild;
1012     while ( pChild )
1013     {
1014         nChildCount++;
1015         pChild = pChild->mpWindowImpl->mpNext;
1016     }
1017
1018     return nChildCount;
1019 }
1020
1021 vcl::Window* Window::GetChild( sal_uInt16 nChild ) const
1022 {
1023     if (!mpWindowImpl)
1024         return nullptr;
1025
1026     sal_uInt16  nChildCount = 0;
1027     vcl::Window* pChild = mpWindowImpl->mpFirstChild;
1028     while ( pChild )
1029     {
1030         if ( nChild == nChildCount )
1031             return pChild;
1032         pChild = pChild->mpWindowImpl->mpNext;
1033         nChildCount++;
1034     }
1035
1036     return nullptr;
1037 }
1038
1039 vcl::Window* Window::GetWindow( GetWindowType nType ) const
1040 {
1041     if (!mpWindowImpl)
1042         return nullptr;
1043
1044     switch ( nType )
1045     {
1046         case GetWindowType::Parent:
1047             return mpWindowImpl->mpRealParent;
1048
1049         case GetWindowType::FirstChild:
1050             return mpWindowImpl->mpFirstChild;
1051
1052         case GetWindowType::LastChild:
1053             return mpWindowImpl->mpLastChild;
1054
1055         case GetWindowType::Prev:
1056             return mpWindowImpl->mpPrev;
1057
1058         case GetWindowType::Next:
1059             return mpWindowImpl->mpNext;
1060
1061         case GetWindowType::FirstOverlap:
1062             return mpWindowImpl->mpFirstOverlap;
1063
1064         case GetWindowType::Overlap:
1065             if ( ImplIsOverlapWindow() )
1066                 return const_cast<vcl::Window*>(this);
1067             else
1068                 return mpWindowImpl->mpOverlapWindow;
1069
1070         case GetWindowType::ParentOverlap:
1071             if ( ImplIsOverlapWindow() )
1072                 return mpWindowImpl->mpOverlapWindow;
1073             else
1074                 return mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpOverlapWindow;
1075
1076         case GetWindowType::Client:
1077             return this->ImplGetWindow();
1078
1079         case GetWindowType::RealParent:
1080             return ImplGetParent();
1081
1082         case GetWindowType::Frame:
1083             return mpWindowImpl->mpFrameWindow;
1084
1085         case GetWindowType::Border:
1086             if ( mpWindowImpl->mpBorderWindow )
1087                 return mpWindowImpl->mpBorderWindow->GetWindow( GetWindowType::Border );
1088             return const_cast<vcl::Window*>(this);
1089
1090         case GetWindowType::FirstTopWindowChild:
1091             return ImplGetWinData()->maTopWindowChildren.empty() ? nullptr : (*ImplGetWinData()->maTopWindowChildren.begin()).get();
1092
1093         case GetWindowType::NextTopWindowSibling:
1094         {
1095             if ( !mpWindowImpl->mpRealParent )
1096                 return nullptr;
1097             const ::std::list< VclPtr<vcl::Window> >& rTopWindows( mpWindowImpl->mpRealParent->ImplGetWinData()->maTopWindowChildren );
1098             ::std::list< VclPtr<vcl::Window> >::const_iterator myPos =
1099                 ::std::find( rTopWindows.begin(), rTopWindows.end(), this );
1100             if ( ( myPos == rTopWindows.end() ) || ( ++myPos == rTopWindows.end() ) )
1101                 return nullptr;
1102             return *myPos;
1103         }
1104
1105     }
1106
1107     return nullptr;
1108 }
1109
1110 bool Window::IsChild( const vcl::Window* pWindow ) const
1111 {
1112     do
1113     {
1114         if ( pWindow->ImplIsOverlapWindow() )
1115             break;
1116
1117         pWindow = pWindow->ImplGetParent();
1118
1119         if ( pWindow == this )
1120             return true;
1121     }
1122     while ( pWindow );
1123
1124     return false;
1125 }
1126
1127 bool Window::IsWindowOrChild( const vcl::Window* pWindow, bool bSystemWindow ) const
1128 {
1129
1130     if ( this == pWindow )
1131         return true;
1132     return ImplIsChild( pWindow, bSystemWindow );
1133 }
1134
1135 void Window::ImplSetFrameParent( const vcl::Window* pParent )
1136 {
1137     vcl::Window* pFrameWindow = ImplGetSVData()->maFrameData.mpFirstFrame;
1138     while( pFrameWindow )
1139     {
1140         // search all frames that are children of this window
1141         // and reparent them
1142         if( ImplIsRealParentPath( pFrameWindow ) )
1143         {
1144             SAL_WARN_IF( mpWindowImpl->mpFrame == pFrameWindow->mpWindowImpl->mpFrame, "vcl", "SetFrameParent to own" );
1145             SAL_WARN_IF( !mpWindowImpl->mpFrame, "vcl", "no frame" );
1146             SalFrame* pParentFrame = pParent ? pParent->mpWindowImpl->mpFrame : nullptr;
1147             pFrameWindow->mpWindowImpl->mpFrame->SetParent( pParentFrame );
1148         }
1149         pFrameWindow = pFrameWindow->mpWindowImpl->mpFrameData->mpNextFrame;
1150     }
1151 }
1152
1153 } /* namespace vcl */
1154
1155 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */