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