vcl/source/window/dockwin.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 <tools/time.hxx>
  21 #include <tools/rc.h>
  22 #include <vcl/event.hxx>
  23 #include <vcl/floatwin.hxx>
  24 #include <vcl/dockwin.hxx>
  25 #include <vcl/layout.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/timer.hxx>
  28 #include <vcl/idle.hxx>
  29 #include <vcl/unowrap.hxx>
  30 #include <vcl/settings.hxx>
  31
  32 #include <svdata.hxx>
  33 #include <window.h>
  34 #include <brdwin.hxx>
  35 #include <salframe.hxx>
  36
  37 #define DOCKWIN_FLOATSTYLES         (WB_SIZEABLE | WB_MOVEABLE | WB_CLOSEABLE | WB_STANDALONE | WB_PINABLE | WB_ROLLABLE )
  38
  39 class DockingWindow::ImplData
  40 {
  41 public:
  42     ImplData();
  43
  44     VclPtr<vcl::Window> mpParent;
  45     Size                maMaxOutSize;
  46 };
  47
  48 DockingWindow::ImplData::ImplData()
  49 {
  50     mpParent = nullptr;
  51     maMaxOutSize = Size( SHRT_MAX, SHRT_MAX );
  52 }
  53
  54 class ImplDockFloatWin : public FloatingWindow
  55 {
  56 private:
  57     VclPtr<DockingWindow> mpDockWin;
  58     sal_uInt64      mnLastTicks;
  59     Idle            maDockIdle;
  60     Point           maDockPos;
  61     Rectangle       maDockRect;
  62     bool            mbInMove;
  63     ImplSVEvent *   mnLastUserEvent;
  64
  65     DECL_LINK(DockingHdl, void *, void);
  66     DECL_LINK(DockTimerHdl, Idle *, void);
  67 public:
  68     ImplDockFloatWin( vcl::Window* pParent, WinBits nWinBits,
  69                       DockingWindow* pDockingWin );
  70     virtual ~ImplDockFloatWin() override;
  71     virtual void dispose() override;
  72
  73     virtual void    Move() override;
  74     virtual void    Resize() override;
  75     virtual void    Resizing( Size& rSize ) override;
  76     virtual bool    Close() override;
  77 };
  78
  79 ImplDockFloatWin::ImplDockFloatWin( vcl::Window* pParent, WinBits nWinBits,
  80                                     DockingWindow* pDockingWin ) :
  81         FloatingWindow( pParent, nWinBits ),
  82         mpDockWin( pDockingWin ),
  83         mnLastTicks( tools::Time::GetSystemTicks() ),
  84         mbInMove( false ),
  85         mnLastUserEvent( nullptr )
  86 {
  87     // copy settings of DockingWindow
  88     if ( pDockingWin )
  89     {
  90         SetSettings( pDockingWin->GetSettings() );
  91         Enable( pDockingWin->IsEnabled(), false );
  92         EnableInput( pDockingWin->IsInputEnabled(), false );
  93         AlwaysEnableInput( pDockingWin->IsAlwaysEnableInput(), false );
  94         EnableAlwaysOnTop( pDockingWin->IsAlwaysOnTopEnabled() );
  95         SetActivateMode( pDockingWin->GetActivateMode() );
  96     }
  97
  98     SetBackground();
  99
 100     maDockIdle.SetIdleHdl( LINK( this, ImplDockFloatWin, DockTimerHdl ) );
 101     maDockIdle.SetPriority( SchedulerPriority::MEDIUM );
 102     maDockIdle.SetDebugName( "vcl::ImplDockFloatWin maDockIdle" );
 103 }
 104
 105 ImplDockFloatWin::~ImplDockFloatWin()
 106 {
 107     disposeOnce();
 108 }
 109
 110 void ImplDockFloatWin::dispose()
 111 {
 112     if( mnLastUserEvent )
 113         Application::RemoveUserEvent( mnLastUserEvent );
 114
 115     disposeBuilder();
 116
 117     mpDockWin.clear();
 118     FloatingWindow::dispose();
 119 }
 120
 121 IMPL_LINK_NOARG(ImplDockFloatWin, DockTimerHdl, Idle *, void)
 122 {
 123     SAL_WARN_IF( !mpDockWin->IsFloatingMode(), "vcl", "docktimer called but not floating" );
 124
 125     maDockIdle.Stop();
 126     PointerState aState = GetPointerState();
 127
 128     if( aState.mnState & KEY_MOD1 )
 129     {
 130         // i43499 CTRL disables docking now
 131         mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
 132         mpDockWin->EndDocking( maDockRect, true );
 133         if( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) )
 134             maDockIdle.Start();
 135     }
 136     else if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) )
 137     {
 138         mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
 139         mpDockWin->EndDocking( maDockRect, false );
 140     }
 141     else
 142     {
 143         mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, ShowTrackFlags::Big | ShowTrackFlags::TrackWindow );
 144         maDockIdle.Start();
 145     }
 146 }
 147
 148 IMPL_LINK_NOARG(ImplDockFloatWin, DockingHdl, void*, void)
 149 {
 150     PointerState aState = mpDockWin->GetParent()->GetPointerState();
 151
 152     mnLastUserEvent = nullptr;
 153     if( mpDockWin->IsDockable()                             &&
 154         (tools::Time::GetSystemTicks() - mnLastTicks > 500)        &&
 155         ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) &&
 156         !(aState.mnState & KEY_MOD1) )  // i43499 CTRL disables docking now
 157     {
 158         maDockPos = Point( mpDockWin->GetParent()->AbsoluteScreenToOutputPixel( OutputToAbsoluteScreenPixel( Point() ) ) );
 159         maDockPos = mpDockWin->GetParent()->OutputToScreenPixel( maDockPos );  // sfx expects screen coordinates
 160
 161         if( ! mpDockWin->IsDocking() )
 162             mpDockWin->StartDocking();
 163         maDockRect = Rectangle( maDockPos, mpDockWin->GetSizePixel() );
 164
 165         // mouse pos also in screen pixels
 166         Point aMousePos = mpDockWin->GetParent()->OutputToScreenPixel( aState.maPos );
 167
 168         bool bFloatMode = mpDockWin->Docking( aMousePos, maDockRect );
 169         if( ! bFloatMode )
 170         {
 171             mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, ShowTrackFlags::Object | ShowTrackFlags::TrackWindow );
 172             DockTimerHdl( nullptr );
 173         }
 174         else
 175         {
 176             mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking();
 177             maDockIdle.Stop();
 178             mpDockWin->EndDocking( maDockRect, true );
 179         }
 180     }
 181     mbInMove = false;
 182 }
 183
 184 void ImplDockFloatWin::Move()
 185 {
 186     if( mbInMove )
 187         return;
 188
 189     mbInMove = true;
 190     FloatingWindow::Move();
 191     mpDockWin->Move();
 192
 193     /*
 194      *  note: the window should only dock if
 195      *  the user releases all mouse buttons. The real problem here
 196      *  is that we don't get mouse events (at least not on X)
 197      *  if the mouse is on the decoration. So we have to start an
 198      *  awkward timer based process that polls the modifier/buttons
 199      *  to see whether they are in the right condition shortly after the
 200      *  last Move message.
 201      */
 202     if( ! mnLastUserEvent )
 203         mnLastUserEvent = Application::PostUserEvent( LINK( this, ImplDockFloatWin, DockingHdl ), nullptr, true );
 204 }
 205
 206 void ImplDockFloatWin::Resize()
 207 {
 208     FloatingWindow::Resize();
 209     Size aSize( GetSizePixel() );
 210     mpDockWin->ImplPosSizeWindow( 0, 0, aSize.Width(), aSize.Height(), PosSizeFlags::PosSize );
 211 }
 212
 213 void ImplDockFloatWin::Resizing( Size& rSize )
 214 {
 215     FloatingWindow::Resizing( rSize );
 216     mpDockWin->Resizing( rSize );
 217 }
 218
 219 bool ImplDockFloatWin::Close()
 220 {
 221     return mpDockWin->Close();
 222 }
 223
 224 bool DockingWindow::ImplStartDocking( const Point& rPos )
 225 {
 226     if ( !mbDockable )
 227         return false;
 228
 229     maMouseOff      = rPos;
 230     maMouseStart    = maMouseOff;
 231     mbDocking       = true;
 232     mbLastFloatMode = IsFloatingMode();
 233     mbStartFloat    = mbLastFloatMode;
 234
 235     // calculate FloatingBorder
 236     VclPtr<FloatingWindow> pWin;
 237     if ( mpFloatWin )
 238         pWin = mpFloatWin;
 239     else
 240         pWin = VclPtr<ImplDockFloatWin>::Create( mpImplData->mpParent, mnFloatBits, nullptr );
 241     pWin->GetBorder( mnDockLeft, mnDockTop, mnDockRight, mnDockBottom );
 242     if ( !mpFloatWin )
 243         pWin.disposeAndClear();
 244
 245     Point   aPos    = ImplOutputToFrame( Point() );
 246     Size    aSize   = Window::GetOutputSizePixel();
 247     mnTrackX        = aPos.X();
 248     mnTrackY        = aPos.Y();
 249     mnTrackWidth    = aSize.Width();
 250     mnTrackHeight   = aSize.Height();
 251
 252     if ( mbLastFloatMode )
 253     {
 254         maMouseOff.X()  += mnDockLeft;
 255         maMouseOff.Y()  += mnDockTop;
 256         mnTrackX        -= mnDockLeft;
 257         mnTrackY        -= mnDockTop;
 258         mnTrackWidth    += mnDockLeft+mnDockRight;
 259         mnTrackHeight   += mnDockTop+mnDockBottom;
 260     }
 261
 262     if ( GetSettings().GetStyleSettings().GetDragFullOptions() & DragFullOptions::Docking &&
 263         !( mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ) ) // no full drag when migrating to system window
 264         mbDragFull = true;
 265     else
 266     {
 267         StartDocking();
 268         mbDragFull = false;
 269         ImplUpdateAll();
 270         ImplGetFrameWindow()->ImplUpdateAll();
 271     }
 272
 273     StartTracking( StartTrackingFlags::KeyMod );
 274     return true;
 275 }
 276
 277 void DockingWindow::ImplInitDockingWindowData()
 278 {
 279     mpWindowImpl->mbDockWin = true;
 280     mpFloatWin     = nullptr;
 281     mpOldBorderWin = nullptr;
 282     mpImplData     = new ImplData;
 283     mnTrackX       = 0;
 284     mnTrackY       = 0;
 285     mnTrackWidth   = 0;
 286     mnTrackHeight  = 0;
 287     mnDockLeft     = 0;
 288     mnDockTop      = 0;
 289     mnDockRight    = 0;
 290     mnDockBottom   = 0;
 291     mnFloatBits    = 0;
 292     mbDockCanceled  = false;
 293     mbDockable     = false;
 294     mbDocking      = false;
 295     mbDragFull     = false;
 296     mbLastFloatMode = false;
 297     mbStartFloat   = false;
 298     mbPinned       = false;
 299     mbRollUp       = false;
 300     mbDockBtn      = false;
 301     mbHideBtn      = false;
 302     mbIsDefferedInit = false;
 303     mbIsCalculatingInitialLayoutSize = false;
 304     mpDialogParent = nullptr;
 305
 306     //To-Do, reuse maResizeTimer
 307     maLayoutIdle.SetPriority(SchedulerPriority::RESIZE);
 308     maLayoutIdle.SetIdleHdl( LINK( this, DockingWindow, ImplHandleLayoutTimerHdl ) );
 309     maLayoutIdle.SetDebugName( "vcl::DockingWindow maLayoutIdle" );
 310 }
 311
 312 void DockingWindow::ImplInit( vcl::Window* pParent, WinBits nStyle )
 313 {
 314     if ( !(nStyle & WB_NODIALOGCONTROL) )
 315         nStyle |= WB_DIALOGCONTROL;
 316
 317     mpImplData->mpParent    = pParent;
 318     mbDockable              = (nStyle & WB_DOCKABLE) != 0;
 319     mnFloatBits             = WB_BORDER | (nStyle & DOCKWIN_FLOATSTYLES);
 320     nStyle                 &= ~(DOCKWIN_FLOATSTYLES | WB_BORDER);
 321     if ( nStyle & WB_DOCKBORDER )
 322         nStyle |= WB_BORDER;
 323
 324     Window::ImplInit( pParent, nStyle, nullptr );
 325
 326     ImplInitSettings();
 327 }
 328
 329 void DockingWindow::ImplInitSettings()
 330 {
 331     // Hack: to be able to build DockingWindows w/o background before switching
 332     // TODO: Hack
 333     if ( IsBackground() )
 334     {
 335         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 336
 337         Color aColor;
 338         if ( IsControlBackground() )
 339             aColor = GetControlBackground();
 340         else if ( Window::GetStyle() & WB_3DLOOK )
 341             aColor = rStyleSettings.GetFaceColor();
 342         else
 343             aColor = rStyleSettings.GetWindowColor();
 344         SetBackground( aColor );
 345     }
 346 }
 347
 348 DockingWindow::DockingWindow( WindowType nType ) :
 349     Window(nType)
 350 {
 351     ImplInitDockingWindowData();
 352 }
 353
 354 DockingWindow::DockingWindow( vcl::Window* pParent, WinBits nStyle ) :
 355     Window( WINDOW_DOCKINGWINDOW )
 356 {
 357     ImplInitDockingWindowData();
 358     ImplInit( pParent, nStyle );
 359 }
 360
 361 //Find the real parent stashed in mpDialogParent.
 362 void DockingWindow::doDeferredInit(WinBits nBits)
 363 {
 364     vcl::Window *pParent = mpDialogParent;
 365     mpDialogParent = nullptr;
 366     ImplInit(pParent, nBits);
 367     mbIsDefferedInit = false;
 368 }
 369
 370 void DockingWindow::loadUI(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription,
 371     const css::uno::Reference<css::frame::XFrame> &rFrame)
 372 {
 373     mbIsDefferedInit = true;
 374     mpDialogParent = pParent; //should be unset in doDeferredInit
 375     m_pUIBuilder.reset( new VclBuilder(this, getUIRootDir(), rUIXMLDescription, rID, rFrame) );
 376 }
 377
 378 DockingWindow::DockingWindow(vcl::Window* pParent, const OString& rID,
 379     const OUString& rUIXMLDescription, const css::uno::Reference<css::frame::XFrame> &rFrame)
 380     : Window(WINDOW_DOCKINGWINDOW)
 381 {
 382     ImplInitDockingWindowData();
 383
 384     loadUI(pParent, rID, rUIXMLDescription, rFrame);
 385 }
 386
 387 DockingWindow::~DockingWindow()
 388 {
 389     disposeOnce();
 390 }
 391
 392 void DockingWindow::dispose()
 393 {
 394     if ( IsFloatingMode() )
 395     {
 396         Show( false, ShowFlags::NoFocusChange );
 397         SetFloatingMode(false);
 398     }
 399     delete mpImplData;
 400     mpImplData = nullptr;
 401     mpFloatWin.clear();
 402     mpOldBorderWin.clear();
 403     mpDialogParent.clear();
 404     disposeBuilder();
 405     Window::dispose();
 406 }
 407
 408 void DockingWindow::Tracking( const TrackingEvent& rTEvt )
 409 {
 410     if( GetDockingManager()->IsDockable( this ) )   // new docking interface
 411         return Window::Tracking( rTEvt );
 412
 413     if ( mbDocking )
 414     {
 415         if ( rTEvt.IsTrackingEnded() )
 416         {
 417             mbDocking = false;
 418             if ( mbDragFull )
 419             {
 420                 // reset old state on Cancel
 421                 if ( rTEvt.IsTrackingCanceled() )
 422                 {
 423                     StartDocking();
 424                     Rectangle aRect( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) );
 425                     EndDocking( aRect, mbStartFloat );
 426                 }
 427             }
 428             else
 429             {
 430                 HideTracking();
 431                 if ( rTEvt.IsTrackingCanceled() )
 432                 {
 433                     mbDockCanceled = true;
 434                     EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
 435                     mbDockCanceled = false;
 436                 }
 437                 else
 438                     EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
 439             }
 440         }
 441         // dock only for non-synthetic MouseEvents
 442         else if ( !rTEvt.GetMouseEvent().IsSynthetic() || rTEvt.GetMouseEvent().IsModifierChanged() )
 443         {
 444             Point   aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
 445             Point   aFrameMousePos = ImplOutputToFrame( aMousePos );
 446             Size    aFrameSize = mpWindowImpl->mpFrameWindow->GetOutputSizePixel();
 447             if ( aFrameMousePos.X() < 0 )
 448                 aFrameMousePos.X() = 0;
 449             if ( aFrameMousePos.Y() < 0 )
 450                 aFrameMousePos.Y() = 0;
 451             if ( aFrameMousePos.X() > aFrameSize.Width()-1 )
 452                 aFrameMousePos.X() = aFrameSize.Width()-1;
 453             if ( aFrameMousePos.Y() > aFrameSize.Height()-1 )
 454                 aFrameMousePos.Y() = aFrameSize.Height()-1;
 455             aMousePos = ImplFrameToOutput( aFrameMousePos );
 456             aMousePos.X() -= maMouseOff.X();
 457             aMousePos.Y() -= maMouseOff.Y();
 458             Point aFramePos = ImplOutputToFrame( aMousePos );
 459             Rectangle aTrackRect( aFramePos, Size( mnTrackWidth, mnTrackHeight ) );
 460             Rectangle aCompRect = aTrackRect;
 461             aFramePos.X()    += maMouseOff.X();
 462             aFramePos.Y()    += maMouseOff.Y();
 463             if ( mbDragFull )
 464                 StartDocking();
 465             bool bFloatMode = Docking( aFramePos, aTrackRect );
 466             if ( mbLastFloatMode != bFloatMode )
 467             {
 468                 if ( bFloatMode )
 469                 {
 470                     aTrackRect.Left()   -= mnDockLeft;
 471                     aTrackRect.Top()    -= mnDockTop;
 472                     aTrackRect.Right()  += mnDockRight;
 473                     aTrackRect.Bottom() += mnDockBottom;
 474                 }
 475                 else
 476                 {
 477                     if ( aCompRect == aTrackRect )
 478                     {
 479                         aTrackRect.Left()   += mnDockLeft;
 480                         aTrackRect.Top()    += mnDockTop;
 481                         aTrackRect.Right()  -= mnDockRight;
 482                         aTrackRect.Bottom() -= mnDockBottom;
 483                     }
 484                 }
 485                 mbLastFloatMode = bFloatMode;
 486             }
 487             if ( mbDragFull )
 488             {
 489                 Point aOldPos = OutputToScreenPixel( Point() );
 490                 EndDocking( aTrackRect, mbLastFloatMode );
 491                 // repaint if state or position has changed
 492                 if ( aOldPos != OutputToScreenPixel( Point() ) )
 493                 {
 494                     ImplUpdateAll();
 495                     ImplGetFrameWindow()->ImplUpdateAll();
 496                 }
 497 //                EndDocking( aTrackRect, mbLastFloatMode );
 498             }
 499             else
 500             {
 501                 ShowTrackFlags nTrackStyle;
 502                 if ( bFloatMode )
 503                     nTrackStyle = ShowTrackFlags::Big;
 504                 else
 505                     nTrackStyle = ShowTrackFlags::Object;
 506                 Rectangle aShowTrackRect = aTrackRect;
 507                 aShowTrackRect.SetPos( ImplFrameToOutput( aShowTrackRect.TopLeft() ) );
 508                 ShowTracking( aShowTrackRect, nTrackStyle );
 509
 510                 // recalculate mouse offset, as the rectangle was changed
 511                 maMouseOff.X()  = aFramePos.X() - aTrackRect.Left();
 512                 maMouseOff.Y()  = aFramePos.Y() - aTrackRect.Top();
 513             }
 514
 515             mnTrackX        = aTrackRect.Left();
 516             mnTrackY        = aTrackRect.Top();
 517             mnTrackWidth    = aTrackRect.GetWidth();
 518             mnTrackHeight   = aTrackRect.GetHeight();
 519         }
 520     }
 521 }
 522
 523 bool DockingWindow::EventNotify( NotifyEvent& rNEvt )
 524 {
 525     if( GetDockingManager()->IsDockable( this ) )   // new docking interface
 526         return Window::EventNotify( rNEvt );
 527
 528     if ( mbDockable )
 529     {
 530         const bool bDockingSupportCrippled = !StyleSettings::GetDockingFloatsSupported();
 531
 532         if ( rNEvt.GetType() == MouseNotifyEvent::MOUSEBUTTONDOWN )
 533         {
 534             const MouseEvent* pMEvt = rNEvt.GetMouseEvent();
 535             if ( pMEvt->IsLeft() )
 536             {
 537                 if (!bDockingSupportCrippled && pMEvt->IsMod1() && (pMEvt->GetClicks() == 2) )
 538                 {
 539                     SetFloatingMode( !IsFloatingMode() );
 540                     return true;
 541                 }
 542                 else if ( pMEvt->GetClicks() == 1 )
 543                 {
 544                     // check if window is floating standalone (IsFloating())
 545                     // or only partially floating and still docked with one border
 546                     // ( !mpWindowImpl->mbFrame)
 547                     if( ! IsFloatingMode() || ! mpFloatWin->mpWindowImpl->mbFrame )
 548                     {
 549                         Point   aPos = pMEvt->GetPosPixel();
 550                         vcl::Window* pWindow = rNEvt.GetWindow();
 551                         if ( pWindow != this )
 552                         {
 553                             aPos = pWindow->OutputToScreenPixel( aPos );
 554                             aPos = ScreenToOutputPixel( aPos );
 555                         }
 556                         ImplStartDocking( aPos );
 557                     }
 558                     return true;
 559                 }
 560             }
 561         }
 562         else if( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
 563         {
 564             const vcl::KeyCode& rKey = rNEvt.GetKeyEvent()->GetKeyCode();
 565             if( rKey.GetCode() == KEY_F10 && rKey.GetModifier() &&
 566                 rKey.IsShift() && rKey.IsMod1() && !bDockingSupportCrippled )
 567             {
 568                 SetFloatingMode( !IsFloatingMode() );
 569                 return true;
 570             }
 571         }
 572     }
 573
 574     return Window::EventNotify( rNEvt );
 575 }
 576
 577 void DockingWindow::StartDocking()
 578 {
 579     mbDocking = true;
 580 }
 581
 582 bool DockingWindow::Docking( const Point&, Rectangle& )
 583 {
 584     return IsFloatingMode();
 585 }
 586
 587 void DockingWindow::EndDocking( const Rectangle& rRect, bool bFloatMode )
 588 {
 589     bool bOrigDockCanceled = mbDockCanceled;
 590     if (bFloatMode && !StyleSettings::GetDockingFloatsSupported())
 591         mbDockCanceled = true;
 592
 593     if ( !IsDockingCanceled() )
 594     {
 595         bool bShow = false;
 596         if ( bool(bFloatMode) != IsFloatingMode() )
 597         {
 598             Show( false, ShowFlags::NoFocusChange );
 599             SetFloatingMode( bFloatMode );
 600             bShow = true;
 601             if ( bFloatMode && mpFloatWin )
 602                 mpFloatWin->SetPosSizePixel( rRect.TopLeft(), rRect.GetSize() );
 603         }
 604         if ( !bFloatMode )
 605         {
 606             Point aPos = rRect.TopLeft();
 607             aPos = GetParent()->ScreenToOutputPixel( aPos );
 608             Window::SetPosSizePixel( aPos, rRect.GetSize() );
 609         }
 610
 611         if ( bShow )
 612             Show();
 613     }
 614     mbDocking = false;
 615     mbDockCanceled = bOrigDockCanceled;
 616 }
 617
 618 bool DockingWindow::PrepareToggleFloatingMode()
 619 {
 620     return true;
 621 }
 622
 623 bool DockingWindow::Close()
 624 {
 625     VclPtr<vcl::Window> xWindow = this;
 626     CallEventListeners( VCLEVENT_WINDOW_CLOSE );
 627     if ( xWindow->IsDisposed() )
 628         return false;
 629
 630     if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
 631         return false;
 632
 633     Show( false, ShowFlags::NoFocusChange );
 634     return true;
 635 }
 636
 637 void DockingWindow::ToggleFloatingMode()
 638 {
 639 }
 640
 641 void DockingWindow::Resizing( Size& )
 642 {
 643 }
 644
 645 void DockingWindow::DoInitialLayout()
 646 {
 647     if (GetSettings().GetStyleSettings().GetAutoMnemonic())
 648        Accelerator::GenerateAutoMnemonicsOnHierarchy(this);
 649
 650     if (isLayoutEnabled())
 651     {
 652         mbIsCalculatingInitialLayoutSize = true;
 653         setDeferredProperties();
 654         if (IsFloatingMode())
 655             setOptimalLayoutSize();
 656         mbIsCalculatingInitialLayoutSize = false;
 657     }
 658 }
 659
 660 void DockingWindow::StateChanged( StateChangedType nType )
 661 {
 662     switch(nType)
 663     {
 664         case StateChangedType::InitShow:
 665             DoInitialLayout();
 666             break;
 667
 668         case StateChangedType::ControlBackground:
 669             ImplInitSettings();
 670             Invalidate();
 671             break;
 672
 673         case StateChangedType::Style:
 674             mbDockable = (GetStyle() & WB_DOCKABLE) != 0;
 675             break;
 676
 677         default:
 678             break;
 679     }
 680
 681     Window::StateChanged( nType );
 682 }
 683
 684 void DockingWindow::DataChanged( const DataChangedEvent& rDCEvt )
 685 {
 686     if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 687          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 688     {
 689         ImplInitSettings();
 690         Invalidate();
 691     }
 692     else
 693         Window::DataChanged( rDCEvt );
 694 }
 695
 696 void DockingWindow::SetFloatingMode( bool bFloatMode )
 697 {
 698     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 699     if( pWrapper )
 700     {
 701         pWrapper->SetFloatingMode( bFloatMode );
 702         return;
 703     }
 704     if ( IsFloatingMode() != bFloatMode )
 705     {
 706         if ( PrepareToggleFloatingMode() ) // changes to floating mode can be vetoed
 707         {
 708             bool bVisible = IsVisible();
 709
 710             if ( bFloatMode )
 711             {
 712                 Show( false, ShowFlags::NoFocusChange );
 713
 714                 sal_Int32 nBorderWidth = get_border_width();
 715
 716                 maDockPos = Window::GetPosPixel();
 717
 718                 vcl::Window* pRealParent = mpWindowImpl->mpRealParent;
 719                 mpOldBorderWin = mpWindowImpl->mpBorderWindow;
 720
 721                 VclPtrInstance<ImplDockFloatWin> pWin(
 722                                          mpImplData->mpParent,
 723                                          mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ?  mnFloatBits | WB_SYSTEMWINDOW : mnFloatBits,
 724                                          this );
 725                 mpFloatWin      = pWin;
 726                 mpWindowImpl->mpBorderWindow  = nullptr;
 727                 mpWindowImpl->mnLeftBorder    = 0;
 728                 mpWindowImpl->mnTopBorder     = 0;
 729                 mpWindowImpl->mnRightBorder   = 0;
 730                 mpWindowImpl->mnBottomBorder  = 0;
 731                 // if the parent gets destroyed, we also have to reset the parent of the BorderWindow
 732                 if ( mpOldBorderWin )
 733                     mpOldBorderWin->SetParent( pWin );
 734
 735                 // #i123765# reset the buffered DropTargets when undocking, else it may not
 736                 // be correctly initialized
 737                 mpWindowImpl->mxDNDListenerContainer.clear();
 738
 739                 SetParent( pWin );
 740                 SetPosPixel( Point() );
 741                 mpWindowImpl->mpBorderWindow = pWin;
 742                 pWin->mpWindowImpl->mpClientWindow = this;
 743                 mpWindowImpl->mpRealParent = pRealParent;
 744                 pWin->SetText( Window::GetText() );
 745                 Size aSize(Window::GetSizePixel());
 746                 pWin->SetOutputSizePixel(aSize);
 747                 pWin->SetPosPixel( maFloatPos );
 748                 // pass on DockingData to FloatingWindow
 749                 pWin->ShowTitleButton( TitleButton::Docking, mbDockBtn );
 750                 pWin->ShowTitleButton( TitleButton::Hide, mbHideBtn );
 751                 pWin->SetPin( mbPinned );
 752                 if ( mbRollUp )
 753                     pWin->RollUp();
 754                 else
 755                     pWin->RollDown();
 756                 pWin->SetRollUpOutputSizePixel( maRollUpOutSize );
 757                 pWin->SetMinOutputSizePixel( maMinOutSize );
 758
 759                 pWin->SetMaxOutputSizePixel( mpImplData->maMaxOutSize );
 760
 761                 ToggleFloatingMode();
 762
 763                 set_border_width(nBorderWidth);
 764
 765                 if ( bVisible )
 766                     Show();
 767
 768                 mpFloatWin->queue_resize();
 769             }
 770             else
 771             {
 772                 Show( false, ShowFlags::NoFocusChange );
 773
 774                 sal_Int32 nBorderWidth = get_border_width();
 775
 776                 // store FloatingData in FloatingWindow
 777                 maFloatPos      = mpFloatWin->GetPosPixel();
 778                 mbDockBtn       = mpFloatWin->IsTitleButtonVisible( TitleButton::Docking );
 779                 mbHideBtn       = mpFloatWin->IsTitleButtonVisible( TitleButton::Hide );
 780                 mbPinned        = mpFloatWin->IsPinned();
 781                 mbRollUp        = mpFloatWin->IsRollUp();
 782                 maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel();
 783                 maMinOutSize    = mpFloatWin->GetMinOutputSizePixel();
 784                 mpImplData->maMaxOutSize = mpFloatWin->GetMaxOutputSizePixel();
 785
 786                 vcl::Window* pRealParent = mpWindowImpl->mpRealParent;
 787                 mpWindowImpl->mpBorderWindow = nullptr;
 788                 if ( mpOldBorderWin )
 789                 {
 790                     SetParent( mpOldBorderWin );
 791                     static_cast<ImplBorderWindow*>(mpOldBorderWin.get())->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
 792                     mpOldBorderWin->Resize();
 793                 }
 794                 mpWindowImpl->mpBorderWindow = mpOldBorderWin;
 795                 SetParent( pRealParent );
 796                 mpWindowImpl->mpRealParent = pRealParent;
 797                 mpFloatWin.disposeAndClear();
 798                 SetPosPixel( maDockPos );
 799
 800                 ToggleFloatingMode();
 801
 802                 set_border_width(nBorderWidth);
 803
 804                 if ( bVisible )
 805                     Show();
 806             }
 807         }
 808     }
 809 }
 810
 811 void DockingWindow::SetFloatStyle( WinBits nStyle )
 812 {
 813     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 814     if( pWrapper )
 815     {
 816         pWrapper->SetFloatStyle( nStyle );
 817         return;
 818     }
 819
 820     mnFloatBits = nStyle;
 821 }
 822
 823 WinBits DockingWindow::GetFloatStyle() const
 824 {
 825     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 826     if( pWrapper )
 827     {
 828         return pWrapper->GetFloatStyle();
 829     }
 830
 831     return mnFloatBits;
 832 }
 833
 834 void DockingWindow::setPosSizePixel( long nX, long nY,
 835                                      long nWidth, long nHeight,
 836                                      PosSizeFlags nFlags )
 837 {
 838     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 839     if (pWrapper)
 840     {
 841         if (!pWrapper->mpFloatWin)
 842             Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
 843     }
 844     else
 845     {
 846         if (!mpFloatWin)
 847             Window::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
 848     }
 849
 850     if (::isLayoutEnabled(this))
 851     {
 852         Size aSize(GetSizePixel());
 853
 854         sal_Int32 nBorderWidth = get_border_width();
 855
 856         aSize.Width() -= 2 * nBorderWidth;
 857         aSize.Height() -= 2 * nBorderWidth;
 858
 859         Point aPos(nBorderWidth, nBorderWidth);
 860         Window *pBox = GetWindow(GetWindowType::FirstChild);
 861         assert(pBox);
 862         VclContainer::setLayoutAllocation(*pBox, aPos, aSize);
 863     }
 864 }
 865
 866 Point DockingWindow::GetPosPixel() const
 867 {
 868     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 869     if( pWrapper )
 870     {
 871         if ( pWrapper->mpFloatWin )
 872             return pWrapper->mpFloatWin->GetPosPixel();
 873         else
 874             return Window::GetPosPixel();
 875     }
 876
 877     if ( mpFloatWin )
 878         return mpFloatWin->GetPosPixel();
 879     else
 880         return Window::GetPosPixel();
 881 }
 882
 883 Size DockingWindow::GetSizePixel() const
 884 {
 885     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 886     if( pWrapper )
 887     {
 888         if ( pWrapper->mpFloatWin )
 889             return pWrapper->mpFloatWin->GetSizePixel();
 890         else
 891             return Window::GetSizePixel();
 892     }
 893
 894     if ( mpFloatWin )
 895         return mpFloatWin->GetSizePixel();
 896     else
 897         return Window::GetSizePixel();
 898 }
 899
 900 void DockingWindow::SetOutputSizePixel( const Size& rNewSize )
 901 {
 902     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 903     if( pWrapper )
 904     {
 905         if ( pWrapper->mpFloatWin )
 906             pWrapper->mpFloatWin->SetOutputSizePixel( rNewSize );
 907         else
 908             Window::SetOutputSizePixel( rNewSize );
 909         return;
 910     }
 911
 912     if ( mpFloatWin )
 913         mpFloatWin->SetOutputSizePixel( rNewSize );
 914     else
 915         Window::SetOutputSizePixel( rNewSize );
 916 }
 917
 918 Size DockingWindow::GetOutputSizePixel() const
 919 {
 920     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 921     if( pWrapper )
 922     {
 923         if ( pWrapper->mpFloatWin )
 924             return pWrapper->mpFloatWin->GetOutputSizePixel();
 925         else
 926             return Window::GetOutputSizePixel();
 927     }
 928
 929     if ( mpFloatWin )
 930         return mpFloatWin->GetOutputSizePixel();
 931     else
 932         return Window::GetOutputSizePixel();
 933 }
 934
 935 Point DockingWindow::GetFloatingPos() const
 936 {
 937     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 938     if( pWrapper )
 939     {
 940         if ( pWrapper->mpFloatWin )
 941         {
 942             WindowStateData aData;
 943             aData.SetMask( WindowStateMask::Pos );
 944             pWrapper->mpFloatWin->GetWindowStateData( aData );
 945             Point aPos( aData.GetX(), aData.GetY() );
 946             aPos = pWrapper->mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
 947             return aPos;
 948         }
 949         else
 950             return maFloatPos;
 951     }
 952
 953     if ( mpFloatWin )
 954     {
 955         WindowStateData aData;
 956         aData.SetMask( WindowStateMask::Pos );
 957         mpFloatWin->GetWindowStateData( aData );
 958         Point aPos( aData.GetX(), aData.GetY() );
 959         aPos = mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
 960         return aPos;
 961     }
 962     else
 963         return maFloatPos;
 964 }
 965
 966 bool DockingWindow::IsFloatingMode() const
 967 {
 968     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 969     if( pWrapper )
 970         return pWrapper->IsFloatingMode();
 971     else
 972         return (mpFloatWin != nullptr);
 973 }
 974
 975 void DockingWindow::SetMaxOutputSizePixel( const Size& rSize )
 976 {
 977     if ( mpFloatWin )
 978         mpFloatWin->SetMaxOutputSizePixel( rSize );
 979     mpImplData->maMaxOutSize = rSize;
 980 }
 981
 982 void DockingWindow::SetText(const OUString& rStr)
 983 {
 984     setDeferredProperties();
 985     Window::SetText(rStr);
 986 }
 987
 988 OUString DockingWindow::GetText() const
 989 {
 990     const_cast<DockingWindow*>(this)->setDeferredProperties();
 991     return Window::GetText();
 992 }
 993
 994 bool DockingWindow::isLayoutEnabled() const
 995 {
 996     //pre dtor called, and single child is a container => we're layout enabled
 997     return mpImplData && ::isLayoutEnabled(this);
 998 }
 999
1000 void DockingWindow::setOptimalLayoutSize()
1001 {
1002     maLayoutIdle.Stop();
1003
1004     //resize DockingWindow to fit requisition on initial show
1005     Window *pBox = GetWindow(GetWindowType::FirstChild);
1006
1007     Size aSize = get_preferred_size();
1008
1009     Size aMax(bestmaxFrameSizeForScreenSize(GetDesktopRectPixel().GetSize()));
1010
1011     aSize.Width() = std::min(aMax.Width(), aSize.Width());
1012     aSize.Height() = std::min(aMax.Height(), aSize.Height());
1013
1014     SetMinOutputSizePixel(aSize);
1015     SetSizePixel(aSize);
1016     setPosSizeOnContainee(aSize, *pBox);
1017 }
1018
1019 void DockingWindow::setPosSizeOnContainee(Size aSize, Window &rBox)
1020 {
1021     sal_Int32 nBorderWidth = get_border_width();
1022
1023     aSize.Width() -= 2 * nBorderWidth;
1024     aSize.Height() -= 2 * nBorderWidth;
1025
1026     Point aPos(nBorderWidth, nBorderWidth);
1027     VclContainer::setLayoutAllocation(rBox, aPos, aSize);
1028 }
1029
1030 Size DockingWindow::GetOptimalSize() const
1031 {
1032     if (!isLayoutEnabled())
1033         return Window::GetOptimalSize();
1034
1035     Size aSize = VclContainer::getLayoutRequisition(*GetWindow(GetWindowType::FirstChild));
1036
1037     sal_Int32 nBorderWidth = get_border_width();
1038
1039     aSize.Height() += 2 * nBorderWidth;
1040     aSize.Width()  += 2 * nBorderWidth;
1041
1042     return Window::CalcWindowSize(aSize);
1043 }
1044
1045 void DockingWindow::queue_resize(StateChangedType eReason)
1046 {
1047     bool bTriggerLayout = true;
1048     if (maLayoutIdle.IsActive() || mbIsCalculatingInitialLayoutSize)
1049     {
1050         bTriggerLayout = false;
1051     }
1052     if (!isLayoutEnabled())
1053     {
1054         bTriggerLayout = false;
1055     }
1056     if (bTriggerLayout)
1057     {
1058         InvalidateSizeCache();
1059         maLayoutIdle.Start();
1060     }
1061     vcl::Window::queue_resize(eReason);
1062 }
1063
1064 IMPL_LINK_NOARG(DockingWindow, ImplHandleLayoutTimerHdl, Idle*, void)
1065 {
1066     if (!isLayoutEnabled())
1067     {
1068         SAL_WARN("vcl.layout", "DockingWindow has become non-layout because extra children have been added directly to it.");
1069         return;
1070     }
1071
1072     Window *pBox = GetWindow(GetWindowType::FirstChild);
1073     assert(pBox);
1074     setPosSizeOnContainee(GetSizePixel(), *pBox);
1075 }
1076
1077 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */