vcl/source/window/dockwin.cxx

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