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