vcl/source/window/dockmgr.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: dockmgr.cxx,v $
  10  * $Revision: 1.24 $
  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/toolbox.hxx>
  46 #include <vcl/svapp.hxx>
  47 #include <vcl/svdata.hxx>
  48 #include <vcl/timer.hxx>
  49 #include <vcl/lineinfo.hxx>
  50 #include <vcl/window.h>
  51 #include <vcl/unowrap.hxx>
  52 #include <vcl/salframe.hxx>
  53
  54
  55 // =======================================================================
  56
  57 #define DOCKWIN_FLOATSTYLES         (WB_SIZEABLE | WB_MOVEABLE | WB_CLOSEABLE | WB_STANDALONE | WB_PINABLE | WB_ROLLABLE )
  58
  59 // =======================================================================
  60
  61
  62 // =======================================================================
  63
  64 class ImplDockFloatWin2 : public FloatingWindow
  65 {
  66 private:
  67     ImplDockingWindowWrapper*  mpDockWin;
  68     ULONG                       mnLastTicks;
  69     Timer                       maDockTimer;
  70     Timer                       maEndDockTimer;
  71     Point                       maDockPos;
  72     Rectangle           maDockRect;
  73     BOOL            mbInMove;
  74     ULONG                       mnLastUserEvent;
  75
  76     DECL_LINK( DockingHdl, ImplDockFloatWin2* );
  77     DECL_LINK( DockTimerHdl, ImplDockFloatWin2* );
  78     DECL_LINK( EndDockTimerHdl, ImplDockFloatWin2* );
  79 public:
  80     ImplDockFloatWin2( Window* pParent, WinBits nWinBits,
  81                       ImplDockingWindowWrapper* pDockingWin );
  82     ~ImplDockFloatWin2();
  83
  84     virtual void        Move();
  85     virtual void        Resize();
  86     virtual void        TitleButtonClick( USHORT nButton );
  87     virtual void        Pin();
  88     virtual void        Roll();
  89     virtual void        PopupModeEnd();
  90     virtual void        Resizing( Size& rSize );
  91     virtual BOOL        Close();
  92     using Window::SetPosSizePixel;
  93     virtual void    SetPosSizePixel( long nX, long nY,
  94                                      long nWidth, long nHeight,
  95                                      USHORT nFlags = WINDOW_POSSIZE_ALL );
  96
  97     ULONG GetLastTicks() const { return mnLastTicks; }
  98 };
  99
 100 // =======================================================================
 101
 102 ImplDockFloatWin2::ImplDockFloatWin2( Window* pParent, WinBits nWinBits,
 103                                     ImplDockingWindowWrapper* pDockingWin ) :
 104         FloatingWindow( pParent, nWinBits ),
 105         mpDockWin( pDockingWin ),
 106         mnLastTicks( Time::GetSystemTicks() ),
 107         mbInMove( FALSE ),
 108         mnLastUserEvent( 0 )
 109 {
 110     // Daten vom DockingWindow uebernehmen
 111     if ( pDockingWin )
 112     {
 113         SetSettings( pDockingWin->GetWindow()->GetSettings() );
 114         Enable( pDockingWin->GetWindow()->IsEnabled(), FALSE );
 115         EnableInput( pDockingWin->GetWindow()->IsInputEnabled(), FALSE );
 116         AlwaysEnableInput( pDockingWin->GetWindow()->IsAlwaysEnableInput(), FALSE );
 117         EnableAlwaysOnTop( pDockingWin->GetWindow()->IsAlwaysOnTopEnabled() );
 118         SetActivateMode( pDockingWin->GetWindow()->GetActivateMode() );
 119     }
 120
 121     SetBackground( GetSettings().GetStyleSettings().GetFaceColor() );
 122
 123     maDockTimer.SetTimeoutHdl( LINK( this, ImplDockFloatWin2, DockTimerHdl ) );
 124     maDockTimer.SetTimeout( 50 );
 125     maEndDockTimer.SetTimeoutHdl( LINK( this, ImplDockFloatWin2, EndDockTimerHdl ) );
 126     maEndDockTimer.SetTimeout( 50 );
 127 }
 128
 129 // -----------------------------------------------------------------------
 130
 131 ImplDockFloatWin2::~ImplDockFloatWin2()
 132 {
 133     if( mnLastUserEvent )
 134         Application::RemoveUserEvent( mnLastUserEvent );
 135 }
 136
 137 // -----------------------------------------------------------------------
 138
 139 IMPL_LINK( ImplDockFloatWin2, DockTimerHdl, ImplDockFloatWin2*, EMPTYARG )
 140 {
 141     DBG_ASSERT( mpDockWin->IsFloatingMode(), "docktimer called but not floating" );
 142
 143     maDockTimer.Stop();
 144     PointerState aState = GetPointerState();
 145
 146     if( aState.mnState & KEY_MOD1 )
 147     {
 148         // i43499 CTRL disables docking now
 149         mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->HideTracking();
 150         if( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) )
 151             maDockTimer.Start();
 152     }
 153     else if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) )
 154     {
 155         mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->HideTracking();
 156         mpDockWin->EndDocking( maDockRect, FALSE );
 157     }
 158     else
 159     {
 160         mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_BIG | SHOWTRACK_WINDOW );
 161         maDockTimer.Start();
 162     }
 163
 164     return 0;
 165 }
 166
 167 IMPL_LINK( ImplDockFloatWin2, EndDockTimerHdl, ImplDockFloatWin2*, EMPTYARG )
 168 {
 169     DBG_ASSERT( mpDockWin->IsFloatingMode(), "enddocktimer called but not floating" );
 170
 171     maEndDockTimer.Stop();
 172     PointerState aState = GetPointerState();
 173     if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) )
 174     {
 175         mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->HideTracking();
 176         mpDockWin->EndDocking( maDockRect, TRUE );
 177     }
 178     else
 179     {
 180         maEndDockTimer.Start();
 181     }
 182
 183     return 0;
 184 }
 185
 186
 187 IMPL_LINK( ImplDockFloatWin2, DockingHdl, ImplDockFloatWin2*, EMPTYARG )
 188 {
 189     // called during move of a floating window
 190     mnLastUserEvent = 0;
 191
 192     Window *pDockingArea = mpDockWin->GetWindow()->GetParent();
 193     PointerState aState = pDockingArea->GetPointerState();
 194
 195     BOOL bRealMove = TRUE;
 196     if( GetStyle() & WB_OWNERDRAWDECORATION )
 197     {
 198         // for windows with ownerdraw decoration
 199         // we allow docking only when the window was moved
 200         // by dragging its caption
 201         // and ignore move request due to resizing
 202         Window *pBorder = GetWindow( WINDOW_BORDER );
 203         if( pBorder != this )
 204         {
 205             Point aPt;
 206             Rectangle aBorderRect( aPt, pBorder->GetSizePixel() );
 207             sal_Int32 nLeft, nTop, nRight, nBottom;
 208             GetBorder( nLeft, nTop, nRight, nBottom );
 209             // limit borderrect to the caption part only and without the resizing borders
 210             aBorderRect.nBottom = aBorderRect.nTop + nTop;
 211             aBorderRect.nLeft += nLeft;
 212             aBorderRect.nRight -= nRight;
 213
 214             PointerState aBorderState = pBorder->GetPointerState();
 215             if( aBorderRect.IsInside( aBorderState.maPos ) )
 216                 bRealMove = TRUE;
 217             else
 218                 bRealMove = FALSE;
 219         }
 220     }
 221
 222     if( mpDockWin->IsDockable() &&
 223         mpDockWin->GetWindow()->IsVisible() &&
 224         (Time::GetSystemTicks() - mnLastTicks > 500) &&
 225         ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) &&
 226         !(aState.mnState & KEY_MOD1) && // i43499 CTRL disables docking now
 227         bRealMove )
 228     {
 229         maDockPos = Point( pDockingArea->OutputToScreenPixel( pDockingArea->AbsoluteScreenToOutputPixel( OutputToAbsoluteScreenPixel( Point() ) ) ) );
 230         maDockRect = Rectangle( maDockPos, mpDockWin->GetSizePixel() );
 231
 232         // mouse pos in screen pixels
 233         Point aMousePos = pDockingArea->OutputToScreenPixel( aState.maPos );
 234
 235         if( ! mpDockWin->IsDocking() )
 236             mpDockWin->StartDocking( aMousePos, maDockRect );
 237
 238         BOOL bFloatMode = mpDockWin->Docking( aMousePos, maDockRect );
 239
 240         if( ! bFloatMode )
 241         {
 242             // indicates that the window could be docked at maDockRect
 243             maDockRect.SetPos( mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->ScreenToOutputPixel(
 244                  maDockRect.TopLeft() ) );
 245             mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_BIG | SHOWTRACK_WINDOW );
 246             maEndDockTimer.Stop();
 247             DockTimerHdl( this );
 248         }
 249         else
 250         {
 251             mpDockWin->GetWindow()->GetParent()->ImplGetFrameWindow()->HideTracking();
 252             maDockTimer.Stop();
 253             EndDockTimerHdl( this );
 254         }
 255     }
 256     mbInMove = FALSE;
 257     return 0;
 258 }
 259 // -----------------------------------------------------------------------
 260
 261 void ImplDockFloatWin2::Move()
 262 {
 263     if( mbInMove )
 264         return;
 265
 266     mbInMove = TRUE;
 267     FloatingWindow::Move();
 268     mpDockWin->GetWindow()->Move();
 269
 270     /*
 271      *  note: the window should only dock if KEY_MOD1 is pressed
 272      *  and the user releases all mouse buttons. The real problem here
 273      *  is that we don't get mouse events (at least not on X)
 274      *  if the mouse is on the decoration. So we have to start an
 275      *  awkward timer based process that polls the modifier/buttons
 276      *  to see whether they are in the right condition shortly after the
 277      *  last Move message.
 278      */
 279     if( ! mnLastUserEvent )
 280         mnLastUserEvent = Application::PostUserEvent( LINK( this, ImplDockFloatWin2, DockingHdl ) );
 281 }
 282
 283 // -----------------------------------------------------------------------
 284
 285 void ImplDockFloatWin2::Resize()
 286 {
 287     // forwarding of resize only required if we have no borderwindow ( GetWindow() then returns 'this' )
 288     if( GetWindow( WINDOW_BORDER ) == this )
 289     {
 290         FloatingWindow::Resize();
 291         Size aSize( GetSizePixel() );
 292         mpDockWin->GetWindow()->ImplPosSizeWindow( 0, 0, aSize.Width(), aSize.Height(), WINDOW_POSSIZE_POSSIZE ); // is this needed ???
 293     }
 294 }
 295
 296 void ImplDockFloatWin2::SetPosSizePixel( long nX, long nY,
 297                                      long nWidth, long nHeight,
 298                                      USHORT nFlags )
 299 {
 300     FloatingWindow::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
 301 }
 302
 303 // -----------------------------------------------------------------------
 304
 305
 306 void ImplDockFloatWin2::TitleButtonClick( USHORT nButton )
 307 {
 308     FloatingWindow::TitleButtonClick( nButton );
 309     mpDockWin->TitleButtonClick( nButton );
 310 }
 311
 312 // -----------------------------------------------------------------------
 313
 314 void ImplDockFloatWin2::Pin()
 315 {
 316     FloatingWindow::Pin();
 317     mpDockWin->Pin();
 318 }
 319
 320 // -----------------------------------------------------------------------
 321
 322 void ImplDockFloatWin2::Roll()
 323 {
 324     FloatingWindow::Roll();
 325     mpDockWin->Roll();
 326 }
 327
 328 // -----------------------------------------------------------------------
 329
 330 void ImplDockFloatWin2::PopupModeEnd()
 331 {
 332     FloatingWindow::PopupModeEnd();
 333     mpDockWin->PopupModeEnd();
 334 }
 335
 336 // -----------------------------------------------------------------------
 337
 338 void ImplDockFloatWin2::Resizing( Size& rSize )
 339 {
 340     FloatingWindow::Resizing( rSize );
 341     mpDockWin->Resizing( rSize );
 342 }
 343
 344 // -----------------------------------------------------------------------
 345
 346 BOOL ImplDockFloatWin2::Close()
 347 {
 348     return mpDockWin->Close();
 349 }
 350
 351 // =======================================================================
 352
 353 DockingManager::DockingManager()
 354 {
 355 }
 356
 357 DockingManager::~DockingManager()
 358 {
 359     ::std::vector< ImplDockingWindowWrapper* >::iterator p;
 360     p = mDockingWindows.begin();
 361     for(; p != mDockingWindows.end(); ++p )
 362     {
 363         delete (*p);
 364     }
 365     mDockingWindows.clear();
 366 }
 367
 368 ImplDockingWindowWrapper* DockingManager::GetDockingWindowWrapper( const Window *pWindow )
 369 {
 370     ::std::vector< ImplDockingWindowWrapper* >::iterator p;
 371     p = mDockingWindows.begin();
 372     while( p != mDockingWindows.end() )
 373     {
 374         if( (*p)->mpDockingWindow == pWindow )
 375             return (*p);
 376         else
 377             p++;
 378     }
 379     return NULL;
 380 }
 381
 382 BOOL DockingManager::IsDockable( const Window *pWindow )
 383 {
 384     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 385
 386     /*
 387     if( pWindow->HasDockingHandler() )
 388         return TRUE;
 389     */
 390     return (pWrapper != NULL);
 391 }
 392
 393 BOOL DockingManager::IsFloating( const Window *pWindow )
 394 {
 395     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 396     if( pWrapper )
 397         return pWrapper->IsFloatingMode();
 398     else
 399         return FALSE;
 400 }
 401
 402 BOOL DockingManager::IsLocked( const Window *pWindow )
 403 {
 404     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 405     if( pWrapper && pWrapper->IsLocked() )
 406         return TRUE;
 407     else
 408         return FALSE;
 409 }
 410
 411 void DockingManager::Lock( const Window *pWindow )
 412 {
 413     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 414     if( pWrapper )
 415         pWrapper->Lock();
 416 }
 417
 418 void DockingManager::Unlock( const Window *pWindow )
 419 {
 420     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 421     if( pWrapper )
 422         pWrapper->Unlock();
 423 }
 424
 425 void DockingManager::SetFloatingMode( const Window *pWindow, BOOL bFloating )
 426 {
 427     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 428     if( pWrapper )
 429         pWrapper->SetFloatingMode( bFloating );
 430 }
 431
 432 void DockingManager::StartPopupMode( ToolBox *pParentToolBox, const Window *pWindow )
 433 {
 434     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 435     if( pWrapper )
 436         pWrapper->StartPopupMode( pParentToolBox );
 437 }
 438
 439 BOOL DockingManager::IsInPopupMode( const Window *pWindow )
 440 {
 441     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 442     if( pWrapper && pWrapper->IsInPopupMode() )
 443         return TRUE;
 444     else
 445         return FALSE;
 446 }
 447
 448 void DockingManager::AddWindow( const Window *pWindow )
 449 {
 450     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 451     if( pWrapper )
 452         return;
 453     else
 454         pWrapper = new ImplDockingWindowWrapper( pWindow );
 455
 456     mDockingWindows.push_back( pWrapper );
 457 }
 458
 459 void DockingManager::RemoveWindow( const Window *pWindow )
 460 {
 461     ::std::vector< ImplDockingWindowWrapper* >::iterator p;
 462     p = mDockingWindows.begin();
 463     while( p != mDockingWindows.end() )
 464     {
 465         if( (*p)->mpDockingWindow == pWindow )
 466         {
 467             delete (*p);
 468             mDockingWindows.erase( p );
 469             break;
 470         }
 471         else
 472             p++;
 473     }
 474 }
 475
 476 void DockingManager::SetPosSizePixel( Window *pWindow, long nX, long nY,
 477                                     long nWidth, long nHeight,
 478                                     USHORT nFlags )
 479 {
 480     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 481     if( pWrapper )
 482         pWrapper->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
 483 }
 484
 485 Rectangle DockingManager::GetPosSizePixel( const Window *pWindow )
 486 {
 487     Rectangle aRect;
 488     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
 489     if( pWrapper )
 490         aRect = Rectangle( pWrapper->GetPosPixel(), pWrapper->GetSizePixel() );
 491
 492     return aRect;
 493 }
 494
 495 // =======================================================================
 496 // special floating window for popup mode
 497 // main purpose: provides tear-off area for undocking
 498 // =======================================================================
 499
 500 // if TEAROFF_DASHED defined a single dashed line is used
 501 // otherwise multiple smaller lines will be painted
 502 //#define TEAROFF_DASHED
 503
 504 // size of the drag area
 505 #ifdef TEAROFF_DASHED
 506 #define POPUP_DRAGBORDER    2
 507 #define POPUP_DRAGGRIP      5
 508 #else
 509 #define POPUP_DRAGBORDER    3
 510 #define POPUP_DRAGGRIP      5
 511 #endif
 512 #define POPUP_DRAGHEIGHT    (POPUP_DRAGGRIP+POPUP_DRAGBORDER+POPUP_DRAGBORDER)
 513 #define POPUP_DRAGWIDTH     20
 514
 515 class ImplPopupFloatWin : public FloatingWindow
 516 {
 517 private:
 518     ImplDockingWindowWrapper*   mpDockingWin;
 519     BOOL                        mbHighlight;
 520     BOOL                        mbMoving;
 521     Point                       maDelta;
 522     Point                       maTearOffPosition;
 523     void                        ImplSetBorder();
 524
 525 public:
 526     ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper* pDockingWin );
 527     ~ImplPopupFloatWin();
 528
 529     virtual ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible();
 530     virtual void        Paint( const Rectangle& rRect );
 531     virtual void        MouseMove( const MouseEvent& rMEvt );
 532     virtual void        MouseButtonDown( const MouseEvent& rMEvt );
 533     virtual void        MouseButtonUp( const MouseEvent& rMEvt );
 534     virtual void        Tracking( const TrackingEvent& rTEvt );
 535     virtual void        Resize();
 536     virtual Window*     GetPreferredKeyInputWindow();
 537
 538     Rectangle           GetDragRect() const;
 539     Point               GetToolboxPosition() const;
 540     Point               GetTearOffPosition() const;
 541     void                DrawGrip();
 542     void                DrawBorder();
 543 };
 544
 545 ImplPopupFloatWin::ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper* pDockingWin ) :
 546     FloatingWindow( pParent, WB_NOBORDER | WB_SYSTEMWINDOW | WB_NOSHADOW)
 547 {
 548     mpWindowImpl->mbToolbarFloatingWindow = TRUE;   // indicate window type, required for accessibility
 549                                                     // which should not see this window as a toplevel window
 550     mpDockingWin = pDockingWin;
 551     mbHighlight = FALSE;
 552     mbMoving = FALSE;
 553
 554     ImplSetBorder();
 555 }
 556
 557 ImplPopupFloatWin::~ImplPopupFloatWin()
 558 {
 559     mpDockingWin = NULL;
 560 }
 561
 562 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ImplPopupFloatWin::CreateAccessible()
 563 {
 564     // switch off direct accessibilty support for this window
 565
 566     // this is to avoid appearance of this window as standalone window in the accessibility hierarchy
 567     // as this window is only used as a helper for subtoolbars that are not teared-off, the parent toolbar
 568     // has to provide accessibility support (as implemented in the toolkit)
 569     // so the contained toolbar should appear as child of the correponsing toolbar item of the parent toolbar
 570     return ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >();
 571 }
 572
 573 Window* ImplPopupFloatWin::GetPreferredKeyInputWindow()
 574 {
 575     if( mpWindowImpl->mpClientWindow )
 576         return mpWindowImpl->mpClientWindow;
 577     else
 578         return FloatingWindow::GetPreferredKeyInputWindow();
 579 }
 580
 581
 582 void ImplPopupFloatWin::ImplSetBorder()
 583 {
 584     // although we have no border in the sense of a borderwindow
 585     //  we're using a special border for the grip
 586     // by setting those members the method SetOutputSizePixel() can
 587     //  be used to set the proper window size
 588     mpWindowImpl->mnTopBorder     = 1 + POPUP_DRAGHEIGHT+2;
 589     mpWindowImpl->mnBottomBorder  = 1;
 590     mpWindowImpl->mnLeftBorder    = 1;
 591     mpWindowImpl->mnRightBorder   = 1;
 592 }
 593
 594 void ImplPopupFloatWin::Resize()
 595 {
 596     // the borderview overwrites the border during resize so restore it
 597     ImplSetBorder();
 598 }
 599
 600 Rectangle ImplPopupFloatWin::GetDragRect() const
 601 {
 602     return Rectangle( 1, 1, GetOutputSizePixel().Width()-1, 2+POPUP_DRAGHEIGHT );
 603 }
 604
 605 Point ImplPopupFloatWin::GetToolboxPosition() const
 606 {
 607     // return inner position where a toolbox could be placed
 608     Point aPt( 1, 1+GetDragRect().getHeight() );    // grip + border
 609     return aPt;
 610 }
 611
 612 Point ImplPopupFloatWin::GetTearOffPosition() const
 613 {
 614     Point aPt( maTearOffPosition );
 615     //aPt += GetToolboxPosition();    // remove 'decoration'
 616     return aPt;
 617 }
 618
 619 void ImplPopupFloatWin::DrawBorder()
 620 {
 621     SetFillColor();
 622     SetLineColor( GetSettings().GetStyleSettings().GetShadowColor() );
 623     Point aPt;
 624     Rectangle aRect( aPt, GetOutputSizePixel() );
 625
 626     Region oldClipRgn( GetClipRegion( ) );
 627     Region aClipRgn( aRect );
 628     Rectangle aItemClipRect( ImplGetItemEdgeClipRect() );
 629     if( !aItemClipRect.IsEmpty() )
 630     {
 631         aItemClipRect.SetPos( AbsoluteScreenToOutputPixel( aItemClipRect.TopLeft() ) );
 632         aClipRgn.Exclude( aItemClipRect );
 633         SetClipRegion( aClipRgn );
 634     }
 635     DrawRect( aRect );
 636     SetClipRegion( oldClipRgn );
 637 }
 638
 639 void ImplPopupFloatWin::DrawGrip()
 640 {
 641     BOOL bLinecolor     = IsLineColor();
 642     Color aLinecolor    = GetLineColor();
 643     BOOL bFillcolor     = IsFillColor();
 644     Color aFillcolor    = GetFillColor();
 645
 646     // draw background
 647     Rectangle aRect( GetDragRect() );
 648     aRect.nTop      += POPUP_DRAGBORDER;
 649     aRect.nBottom   -= POPUP_DRAGBORDER;
 650     aRect.nLeft+=3;
 651     aRect.nRight-=3;
 652
 653     if( mbHighlight )
 654     {
 655         Erase( aRect );
 656         DrawSelectionBackground( aRect, 2, FALSE, TRUE, FALSE );
 657     }
 658     else
 659     {
 660         SetFillColor( GetSettings().GetStyleSettings().GetFaceColor() );
 661         SetLineColor();
 662         DrawRect( aRect );
 663     }
 664
 665     if( !ToolBox::AlwaysLocked() )  // no grip if toolboxes are locked
 666     {
 667 #ifdef TEAROFF_DASHED
 668         // draw single dashed line
 669         LineInfo aLineInfo( LINE_DASH );
 670         aLineInfo.SetDistance( 4 );
 671         aLineInfo.SetDashLen( 12 );
 672         aLineInfo.SetDashCount( 1 );
 673
 674         aRect.nLeft+=2; aRect.nRight-=2;
 675
 676         aRect.nTop+=2;
 677         aRect.nBottom = aRect.nTop;
 678         SetLineColor( GetSettings().GetStyleSettings().GetDarkShadowColor() );
 679         DrawLine( aRect.TopLeft(), aRect.TopRight(), aLineInfo );
 680
 681         if( !mbHighlight )
 682         {
 683             aRect.nTop++; aRect.nBottom++;
 684             SetLineColor( GetSettings().GetStyleSettings().GetLightColor() );
 685             DrawLine( aRect.TopLeft(), aRect.TopRight(), aLineInfo );
 686         }
 687
 688 #else
 689         // draw several grip lines
 690         SetFillColor( GetSettings().GetStyleSettings().GetShadowColor() );
 691         aRect.nTop++;
 692         aRect.nBottom = aRect.nTop;
 693
 694         int width = POPUP_DRAGWIDTH;
 695         while( width >= aRect.getWidth() )
 696             width -= 4;
 697         if( width <= 0 )
 698             width = aRect.getWidth();
 699         //aRect.nLeft = aRect.nLeft + (aRect.getWidth() - width) / 2;
 700         aRect.nLeft = (aRect.nLeft + aRect.nRight - width) / 2;
 701         aRect.nRight = aRect.nLeft + width;
 702
 703         int i=0;
 704         while( i< POPUP_DRAGGRIP )
 705         {
 706             DrawRect( aRect );
 707             aRect.nTop+=2;
 708             aRect.nBottom+=2;
 709             i+=2;
 710         }
 711 #endif
 712     }
 713
 714     if( bLinecolor )
 715         SetLineColor( aLinecolor );
 716     else
 717         SetLineColor();
 718     if( bFillcolor )
 719         SetFillColor( aFillcolor );
 720     else
 721         SetFillColor();
 722 }
 723
 724 void ImplPopupFloatWin::Paint( const Rectangle& )
 725 {
 726     Point aPt;
 727     Rectangle aRect( aPt, GetOutputSizePixel() );
 728     DrawWallpaper( aRect, Wallpaper( GetSettings().GetStyleSettings().GetFaceGradientColor() ) );
 729     DrawBorder();
 730     DrawGrip();
 731 }
 732
 733 void ImplPopupFloatWin::MouseMove( const MouseEvent& rMEvt )
 734 {
 735     Point aMousePos = rMEvt.GetPosPixel();
 736
 737     if( !ToolBox::AlwaysLocked() )  // no tear off if locking is enabled
 738     {
 739         if( rMEvt.IsLeft() && GetDragRect().IsInside( aMousePos ) )
 740         {
 741             // start window move
 742             mbMoving = TRUE;
 743             StartTracking( STARTTRACK_NOKEYCANCEL );
 744             return;
 745         }
 746         if( !mbHighlight && GetDragRect().IsInside( aMousePos ) )
 747         {
 748             mbHighlight = TRUE;
 749             DrawGrip();
 750         }
 751         if( mbHighlight && ( rMEvt.IsLeaveWindow() || !GetDragRect().IsInside( aMousePos ) ) )
 752         {
 753             mbHighlight = FALSE;
 754             DrawGrip();
 755         }
 756     }
 757 }
 758
 759 void ImplPopupFloatWin::MouseButtonUp( const MouseEvent& rMEvt )
 760 {
 761     FloatingWindow::MouseButtonUp( rMEvt );
 762 }
 763
 764 void ImplPopupFloatWin::MouseButtonDown( const MouseEvent& rMEvt )
 765 {
 766     Point aMousePos = rMEvt.GetPosPixel();
 767     if( GetDragRect().IsInside( aMousePos ) )
 768     {
 769         // get mouse pos at a static window to have a fixed reference point
 770         PointerState aState = GetParent()->GetPointerState();
 771         if (ImplHasMirroredGraphics() && IsRTLEnabled())
 772             ImplMirrorFramePos(aState.maPos);
 773         maTearOffPosition = GetWindow( WINDOW_BORDER )->GetPosPixel();
 774         maDelta = aState.maPos - maTearOffPosition;
 775     }
 776 }
 777
 778 void ImplPopupFloatWin::Tracking( const TrackingEvent& rTEvt )
 779 {
 780     if( mbMoving )
 781     {
 782         if ( rTEvt.IsTrackingEnded() )
 783         {
 784             mbMoving = FALSE;
 785             EndPopupMode( FLOATWIN_POPUPMODEEND_TEAROFF );
 786         }
 787         else if ( !rTEvt.GetMouseEvent().IsSynthetic() )
 788         {
 789             // move the window according to mouse pos
 790             PointerState aState = GetParent()->GetPointerState();
 791             if (ImplHasMirroredGraphics() && IsRTLEnabled())
 792                 ImplMirrorFramePos(aState.maPos);
 793             maTearOffPosition = aState.maPos - maDelta;
 794             GetWindow( WINDOW_BORDER )->SetPosPixel( maTearOffPosition );
 795         }
 796     }
 797 }
 798
 799
 800 // =======================================================================
 801
 802 ImplDockingWindowWrapper::ImplDockingWindowWrapper( const Window *pWindow )
 803 {
 804     ImplInitData();
 805
 806     mpDockingWindow = (Window*) pWindow;
 807     mpParent        = pWindow->GetParent();
 808     mbDockable      = TRUE;
 809     mbLocked        = FALSE;
 810     mnFloatBits     = WB_BORDER | WB_CLOSEABLE | WB_SIZEABLE | (pWindow->GetStyle() & DOCKWIN_FLOATSTYLES);
 811     DockingWindow *pDockWin = dynamic_cast< DockingWindow* > ( mpDockingWindow );
 812     if( pDockWin )
 813         mnFloatBits = pDockWin->GetFloatStyle();
 814
 815     // must be enabled in Window::Notify to prevent permanent docking during mouse move
 816     mbStartDockingEnabled = FALSE;
 817 }
 818
 819 ImplDockingWindowWrapper::~ImplDockingWindowWrapper()
 820 {
 821     if ( IsFloatingMode() )
 822     {
 823         GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
 824         SetFloatingMode( FALSE );
 825     }
 826 }
 827
 828 // -----------------------------------------------------------------------
 829
 830 BOOL ImplDockingWindowWrapper::ImplStartDocking( const Point& rPos )
 831 {
 832     if ( !mbDockable )
 833         return FALSE;
 834
 835     if( !mbStartDockingEnabled )
 836         return FALSE;
 837
 838     maMouseOff      = rPos;
 839     maMouseStart    = maMouseOff;
 840     mbDocking       = TRUE;
 841     mbLastFloatMode = IsFloatingMode();
 842     mbStartFloat    = mbLastFloatMode;
 843
 844     // FloatingBorder berechnen
 845     FloatingWindow* pWin;
 846     if ( mpFloatWin )
 847         pWin = mpFloatWin;
 848     else
 849         pWin = new ImplDockFloatWin2( mpParent, mnFloatBits, NULL );
 850     pWin->GetBorder( mnDockLeft, mnDockTop, mnDockRight, mnDockBottom );
 851     if ( !mpFloatWin )
 852         delete pWin;
 853
 854     Point   aPos    = GetWindow()->ImplOutputToFrame( Point() );
 855     Size    aSize   = GetWindow()->GetOutputSizePixel();
 856     mnTrackX        = aPos.X();
 857     mnTrackY        = aPos.Y();
 858     mnTrackWidth    = aSize.Width();
 859     mnTrackHeight   = aSize.Height();
 860
 861     if ( mbLastFloatMode )
 862     {
 863         maMouseOff.X()  += mnDockLeft;
 864         maMouseOff.Y()  += mnDockTop;
 865         mnTrackX        -= mnDockLeft;
 866         mnTrackY        -= mnDockTop;
 867         mnTrackWidth    += mnDockLeft+mnDockRight;
 868         mnTrackHeight   += mnDockTop+mnDockBottom;
 869     }
 870
 871     Window *pDockingArea = GetWindow()->GetParent();
 872     Window::PointerState aState = pDockingArea->GetPointerState();
 873
 874     // mouse pos in screen pixels
 875     Point aMousePos = pDockingArea->OutputToScreenPixel( aState.maPos );
 876     Point aDockPos = Point( pDockingArea->AbsoluteScreenToOutputPixel( GetWindow()->OutputToAbsoluteScreenPixel( GetWindow()->GetPosPixel() ) ) );
 877     Rectangle aDockRect( aDockPos, GetWindow()->GetSizePixel() );
 878     StartDocking( aMousePos, aDockRect );
 879
 880     GetWindow()->ImplUpdateAll();
 881     GetWindow()->ImplGetFrameWindow()->ImplUpdateAll();
 882
 883     GetWindow()->StartTracking( STARTTRACK_KEYMOD );
 884     return TRUE;
 885 }
 886
 887 // =======================================================================
 888
 889 void ImplDockingWindowWrapper::ImplInitData()
 890 {
 891     mpDockingWindow     = NULL;
 892
 893     //GetWindow()->mpWindowImpl->mbDockWin  = TRUE;     // TODO: must be eliminated
 894     mpFloatWin          = NULL;
 895     mbDockCanceled      = FALSE;
 896     mbFloatPrevented    = FALSE;
 897     mbDocking           = FALSE;
 898     mbPined             = FALSE;
 899     mbRollUp            = FALSE;
 900     mbDockBtn           = FALSE;
 901     mbHideBtn           = FALSE;
 902     maMaxOutSize        = Size( SHRT_MAX, SHRT_MAX );
 903 }
 904
 905 // -----------------------------------------------------------------------
 906
 907 void ImplDockingWindowWrapper::Tracking( const TrackingEvent& rTEvt )
 908 {
 909     // used during docking of a currently docked window
 910     if ( mbDocking )
 911     {
 912         if ( rTEvt.IsTrackingEnded() )
 913         {
 914             mbDocking = FALSE;
 915             GetWindow()->HideTracking();
 916             if ( rTEvt.IsTrackingCanceled() )
 917             {
 918                 mbDockCanceled = TRUE;
 919                 EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
 920                 mbDockCanceled = FALSE;
 921             }
 922             else
 923                 EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode );
 924         }
 925         // Docking only upon non-synthetic MouseEvents
 926         else if ( !rTEvt.GetMouseEvent().IsSynthetic() || rTEvt.GetMouseEvent().IsModifierChanged() )
 927         {
 928             Point   aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
 929             Point   aFrameMousePos = GetWindow()->ImplOutputToFrame( aMousePos );
 930             Size    aFrameSize = GetWindow()->ImplGetFrameWindow()->GetOutputSizePixel();
 931             if ( aFrameMousePos.X() < 0 )
 932                 aFrameMousePos.X() = 0;
 933             if ( aFrameMousePos.Y() < 0 )
 934                 aFrameMousePos.Y() = 0;
 935             if ( aFrameMousePos.X() > aFrameSize.Width()-1 )
 936                 aFrameMousePos.X() = aFrameSize.Width()-1;
 937             if ( aFrameMousePos.Y() > aFrameSize.Height()-1 )
 938                 aFrameMousePos.Y() = aFrameSize.Height()-1;
 939             aMousePos = GetWindow()->ImplFrameToOutput( aFrameMousePos );
 940             aMousePos.X() -= maMouseOff.X();
 941             aMousePos.Y() -= maMouseOff.Y();
 942             Point aPos = GetWindow()->ImplOutputToFrame( aMousePos );
 943             Rectangle aTrackRect( aPos, Size( mnTrackWidth, mnTrackHeight ) );
 944             Rectangle aCompRect = aTrackRect;
 945             aPos.X()    += maMouseOff.X();
 946             aPos.Y()    += maMouseOff.Y();
 947
 948             BOOL bFloatMode = Docking( aPos, aTrackRect );
 949
 950             mbFloatPrevented = FALSE;
 951             if ( mbLastFloatMode != bFloatMode )
 952             {
 953                 if ( bFloatMode )
 954                 {
 955                     aTrackRect.Left()   -= mnDockLeft;
 956                     aTrackRect.Top()    -= mnDockTop;
 957                     aTrackRect.Right()  += mnDockRight;
 958                     aTrackRect.Bottom() += mnDockBottom;
 959                 }
 960                 else
 961                 {
 962                     if ( aCompRect == aTrackRect )
 963                     {
 964                         aTrackRect.Left()   += mnDockLeft;
 965                         aTrackRect.Top()    += mnDockTop;
 966                         aTrackRect.Right()  -= mnDockRight;
 967                         aTrackRect.Bottom() -= mnDockBottom;
 968                     }
 969                 }
 970                 mbLastFloatMode = bFloatMode;
 971             }
 972
 973             USHORT nTrackStyle;
 974             if ( bFloatMode )
 975                 nTrackStyle = SHOWTRACK_OBJECT;
 976             else
 977                 nTrackStyle = SHOWTRACK_BIG;
 978             Rectangle aShowTrackRect = aTrackRect;
 979             aShowTrackRect.SetPos( GetWindow()->ImplFrameToOutput( aShowTrackRect.TopLeft() ) );
 980             //if( bFloatMode )
 981                 GetWindow()->ShowTracking( aShowTrackRect, nTrackStyle );
 982             /*else
 983             {
 984                 GetWindow()->HideTracking();
 985                 Point aPt( GetWindow()->GetParent()->ScreenToOutputPixel( aTrackRect.TopLeft() ) );
 986                 GetWindow()->SetPosPixel( aPt );
 987             }*/
 988
 989             // Maus-Offset neu berechnen, da Rechteck veraendert werden
 990             // konnte
 991             maMouseOff.X()  = aPos.X() - aTrackRect.Left();
 992             maMouseOff.Y()  = aPos.Y() - aTrackRect.Top();
 993
 994             mnTrackX        = aTrackRect.Left();
 995             mnTrackY        = aTrackRect.Top();
 996             mnTrackWidth    = aTrackRect.GetWidth();
 997             mnTrackHeight   = aTrackRect.GetHeight();
 998         }
 999     }
1000 }
1001
1002
1003 // -----------------------------------------------------------------------
1004
1005 void ImplDockingWindowWrapper::StartDocking( const Point& rPoint, Rectangle& rRect )
1006 {
1007     DockingData data( rPoint, rRect, IsFloatingMode() );
1008
1009     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_STARTDOCKING, &data );
1010     mbDocking = TRUE;
1011 }
1012
1013 // -----------------------------------------------------------------------
1014
1015 BOOL ImplDockingWindowWrapper::Docking( const Point& rPoint, Rectangle& rRect )
1016 {
1017     DockingData data( rPoint, rRect, IsFloatingMode() );
1018
1019     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_DOCKING, &data );
1020     rRect = data.maTrackRect;
1021     return data.mbFloating;
1022 }
1023
1024 // -----------------------------------------------------------------------
1025
1026 void ImplDockingWindowWrapper::EndDocking( const Rectangle& rRect, BOOL bFloatMode )
1027 {
1028     Rectangle aRect( rRect );
1029
1030     if ( !IsDockingCanceled() )
1031     {
1032         BOOL bShow = FALSE;
1033         if ( bFloatMode != IsFloatingMode() )
1034         {
1035             GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
1036             SetFloatingMode( bFloatMode );
1037             bShow = TRUE;
1038             if ( bFloatMode )
1039             {
1040                 // #i44800# always use outputsize - as in all other places
1041                 mpFloatWin->SetOutputSizePixel( aRect.GetSize() );
1042                 mpFloatWin->SetPosPixel( aRect.TopLeft() );
1043             }
1044         }
1045         if ( !bFloatMode )
1046         {
1047             Point aPos = aRect.TopLeft();
1048             aPos = GetWindow()->GetParent()->ScreenToOutputPixel( aPos );
1049             GetWindow()->SetPosSizePixel( aPos, aRect.GetSize() );
1050         }
1051
1052         if ( bShow )
1053             GetWindow()->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1054     }
1055
1056     EndDockingData data( aRect, IsFloatingMode(), IsDockingCanceled() );
1057     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_ENDDOCKING, &data );
1058
1059     mbDocking = FALSE;
1060
1061     // must be enabled in Window::Notify to prevent permanent docking during mouse move
1062     mbStartDockingEnabled = FALSE;
1063 }
1064
1065 // -----------------------------------------------------------------------
1066
1067 BOOL ImplDockingWindowWrapper::PrepareToggleFloatingMode()
1068 {
1069     BOOL bFloating = TRUE;
1070     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_PREPARETOGGLEFLOATING, &bFloating );
1071     return bFloating;
1072 }
1073
1074 // -----------------------------------------------------------------------
1075
1076 BOOL ImplDockingWindowWrapper::Close()
1077 {
1078     // TODO: send event
1079 /*
1080     ImplDelData aDelData;
1081     ImplAddDel( &aDelData );
1082     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE );
1083     if ( aDelData.IsDelete() )
1084         return FALSE;
1085     ImplRemoveDel( &aDelData );
1086
1087     if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() )
1088         return FALSE;
1089
1090     GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
1091     */
1092     return TRUE;
1093 }
1094
1095 // -----------------------------------------------------------------------
1096
1097 void ImplDockingWindowWrapper::ToggleFloatingMode()
1098 {
1099     // notify dockingwindow/toolbox
1100     // note: this must be done *before* notifying the
1101     //       listeners to have the toolbox in the proper state
1102     if( GetWindow()->ImplIsDockingWindow() )
1103         ((DockingWindow*) GetWindow())->ToggleFloatingMode();
1104
1105     // now notify listeners
1106     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_TOGGLEFLOATING );
1107
1108     // must be enabled in Window::Notify to prevent permanent docking during mouse move
1109     mbStartDockingEnabled = FALSE;
1110 }
1111
1112 // -----------------------------------------------------------------------
1113
1114 void ImplDockingWindowWrapper::TitleButtonClick( USHORT nType )
1115 {
1116     if( nType == TITLE_BUTTON_MENU )
1117     {
1118         ToolBox *pToolBox = dynamic_cast< ToolBox* >( GetWindow() );
1119         if( pToolBox )
1120         {
1121             pToolBox->ExecuteCustomMenu();
1122         }
1123     }
1124     if( nType == TITLE_BUTTON_DOCKING )
1125     {
1126         SetFloatingMode( !IsFloatingMode() );
1127     }
1128 }
1129
1130 // -----------------------------------------------------------------------
1131
1132 void ImplDockingWindowWrapper::Pin()
1133 {
1134     // TODO: send event
1135 }
1136
1137 // -----------------------------------------------------------------------
1138
1139 void ImplDockingWindowWrapper::Roll()
1140 {
1141     // TODO: send event
1142 }
1143
1144 // -----------------------------------------------------------------------
1145
1146 void ImplDockingWindowWrapper::PopupModeEnd()
1147 {
1148     // TODO: send event
1149 }
1150
1151 // -----------------------------------------------------------------------
1152
1153 void ImplDockingWindowWrapper::Resizing( Size& rSize )
1154 {
1155     // TODO: add virtual Resizing() to class Window, so we can get rid of class DockingWindow
1156     DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >( GetWindow() );
1157     if( pDockingWindow )
1158         pDockingWindow->Resizing( rSize );
1159 }
1160
1161 // -----------------------------------------------------------------------
1162
1163 void ImplDockingWindowWrapper::ShowTitleButton( USHORT nButton, BOOL bVisible )
1164 {
1165     if ( mpFloatWin )
1166         mpFloatWin->ShowTitleButton( nButton, bVisible );
1167     else
1168     {
1169         if ( nButton == TITLE_BUTTON_DOCKING )
1170             mbDockBtn = bVisible;
1171         else // if ( nButton == TITLE_BUTTON_HIDE )
1172             mbHideBtn = bVisible;
1173     }
1174 }
1175
1176 // -----------------------------------------------------------------------
1177
1178 BOOL ImplDockingWindowWrapper::IsTitleButtonVisible( USHORT nButton ) const
1179 {
1180     if ( mpFloatWin )
1181         return mpFloatWin->IsTitleButtonVisible( nButton );
1182     else
1183     {
1184         if ( nButton == TITLE_BUTTON_DOCKING )
1185             return mbDockBtn;
1186         else // if ( nButton == TITLE_BUTTON_HIDE )
1187             return mbHideBtn;
1188     }
1189 }
1190
1191 // -----------------------------------------------------------------------
1192
1193 void ImplDockingWindowWrapper::StartPopupMode( ToolBox *pParentToolBox )
1194 {
1195     // do nothing if window is floating
1196     if( IsFloatingMode() )
1197         return;
1198
1199     GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
1200
1201     // prepare reparenting
1202     Window* pRealParent = GetWindow()->GetWindow( WINDOW_PARENT );
1203     mpOldBorderWin = GetWindow()->GetWindow( WINDOW_BORDER );
1204     if( mpOldBorderWin == GetWindow() )
1205         mpOldBorderWin = NULL;  // no border window found
1206
1207     // the new parent for popup mode
1208     ImplPopupFloatWin* pWin = new ImplPopupFloatWin( mpParent, this );
1209
1210     pWin->SetPopupModeEndHdl( LINK( this, ImplDockingWindowWrapper, PopupModeEnd ) );
1211     pWin->SetText( GetWindow()->GetText() );
1212
1213     pWin->SetOutputSizePixel( GetWindow()->GetSizePixel() );
1214
1215     GetWindow()->mpWindowImpl->mpBorderWindow  = NULL;
1216     GetWindow()->mpWindowImpl->mnLeftBorder    = 0;
1217     GetWindow()->mpWindowImpl->mnTopBorder     = 0;
1218     GetWindow()->mpWindowImpl->mnRightBorder   = 0;
1219     GetWindow()->mpWindowImpl->mnBottomBorder  = 0;
1220
1221     // position toolbox below dragrect
1222     GetWindow()->SetPosPixel( pWin->GetToolboxPosition() );
1223
1224     // reparent borderwindow and window
1225     if ( mpOldBorderWin )
1226         mpOldBorderWin->SetParent( pWin );
1227     GetWindow()->SetParent( pWin );
1228
1229     // correct border window pointers
1230     GetWindow()->mpWindowImpl->mpBorderWindow = pWin;
1231     pWin->mpWindowImpl->mpClientWindow = GetWindow();
1232     GetWindow()->mpWindowImpl->mpRealParent = pRealParent;
1233
1234     // set mpFloatWin not until all window positioning is done !!!
1235     // (SetPosPixel etc. check for valid mpFloatWin pointer)
1236     mpFloatWin = pWin;
1237
1238     ULONG nFlags =  FLOATWIN_POPUPMODE_ALLOWTEAROFF         |
1239                     FLOATWIN_POPUPMODE_NOFOCUSCLOSE         |
1240                     FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE  |
1241                     FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE       |
1242                     FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE;
1243
1244     // if the subtoolbar was opened via keyboard make sure that key events
1245     // will go into subtoolbar
1246     if( pParentToolBox->IsKeyEvent() )
1247         nFlags |= FLOATWIN_POPUPMODE_GRABFOCUS;
1248
1249     mpFloatWin->StartPopupMode( pParentToolBox, nFlags );
1250     GetWindow()->Show();
1251
1252     if( pParentToolBox->IsKeyEvent() )
1253     {
1254         // send HOME key to subtoolbar in order to select first item
1255         KeyEvent aEvent( 0, KeyCode( KEY_HOME ) );
1256         mpFloatWin->GetPreferredKeyInputWindow()->KeyInput( aEvent );
1257     }
1258 }
1259
1260 IMPL_LINK( ImplDockingWindowWrapper, PopupModeEnd, void*, EMPTYARG )
1261 {
1262     GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
1263
1264     // set parameter for handler before destroying floating window
1265     ImplPopupFloatWin *pPopupFloatWin = (ImplPopupFloatWin*) mpFloatWin;
1266     EndPopupModeData aData( pPopupFloatWin->GetTearOffPosition(), mpFloatWin->IsPopupModeTearOff() );
1267
1268     // before deleting change parent back, so we can delete the floating window alone
1269     Window* pRealParent = GetWindow()->GetWindow( WINDOW_PARENT );
1270     GetWindow()->mpWindowImpl->mpBorderWindow = NULL;
1271     if ( mpOldBorderWin )
1272     {
1273         GetWindow()->SetParent( mpOldBorderWin );
1274         ((ImplBorderWindow*)mpOldBorderWin)->GetBorder(
1275             GetWindow()->mpWindowImpl->mnLeftBorder, GetWindow()->mpWindowImpl->mnTopBorder,
1276             GetWindow()->mpWindowImpl->mnRightBorder, GetWindow()->mpWindowImpl->mnBottomBorder );
1277         mpOldBorderWin->Resize();
1278     }
1279     GetWindow()->mpWindowImpl->mpBorderWindow = mpOldBorderWin;
1280     GetWindow()->SetParent( pRealParent );
1281     GetWindow()->mpWindowImpl->mpRealParent = pRealParent;
1282
1283     delete mpFloatWin;
1284     mpFloatWin = NULL;
1285
1286     // call handler - which will destroy the window and thus the wrapper as well !
1287     GetWindow()->ImplCallEventListeners( VCLEVENT_WINDOW_ENDPOPUPMODE, &aData );
1288
1289     return 0;
1290 }
1291
1292
1293 BOOL ImplDockingWindowWrapper::IsInPopupMode() const
1294 {
1295     if( GetFloatingWindow() )
1296         return GetFloatingWindow()->IsInPopupMode();
1297     else
1298         return FALSE;
1299 }
1300
1301 // -----------------------------------------------------------------------
1302
1303 void ImplDockingWindowWrapper::SetFloatingMode( BOOL bFloatMode )
1304 {
1305     // do nothing if window is docked and locked
1306     if( !IsFloatingMode() && IsLocked() )
1307         return;
1308
1309     if ( IsFloatingMode() != bFloatMode )
1310     {
1311         if ( PrepareToggleFloatingMode() )
1312         {
1313             BOOL bVisible = GetWindow()->IsVisible();
1314
1315             if ( bFloatMode )
1316             {
1317                 GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
1318
1319                 maDockPos = GetWindow()->GetPosPixel();
1320
1321                 Window* pRealParent = GetWindow()->GetWindow( WINDOW_PARENT );
1322                 mpOldBorderWin = GetWindow()->GetWindow( WINDOW_BORDER );
1323                 if( mpOldBorderWin == mpDockingWindow )
1324                     mpOldBorderWin = NULL;  // no border window found
1325
1326                 ImplDockFloatWin2* pWin =
1327                     new ImplDockFloatWin2(
1328                                          mpParent,
1329                                          mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ?
1330                                           mnFloatBits | WB_SYSTEMWINDOW
1331 //#ifdef __USE_OWNERDRAWDECORATION__
1332                                           | WB_OWNERDRAWDECORATION
1333 //#endif
1334                                           : mnFloatBits,
1335                                          this );
1336
1337                 // reduce the border width for seamless NWF painting
1338                 // (especially for the toolbar gradient on Windows XP)
1339                 /*AllSettings aSettings( pWin->GetSettings() );
1340                 StyleSettings aStyleSettings( aSettings.GetStyleSettings() );
1341                 aStyleSettings.SetBorderSize( 0 );
1342                 aSettings.SetStyleSettings( aStyleSettings );
1343                 pWin->SetSettings( aSettings );*/
1344
1345                 mpFloatWin      = pWin;
1346
1347
1348                 GetWindow()->mpWindowImpl->mpBorderWindow  = NULL;
1349                 GetWindow()->mpWindowImpl->mnLeftBorder    = 0;
1350                 GetWindow()->mpWindowImpl->mnTopBorder     = 0;
1351                 GetWindow()->mpWindowImpl->mnRightBorder   = 0;
1352                 GetWindow()->mpWindowImpl->mnBottomBorder  = 0;
1353
1354                 // Falls Parent zerstoert wird, muessen wir auch vom
1355                 // BorderWindow den Parent umsetzen
1356                 if ( mpOldBorderWin )
1357                     mpOldBorderWin->SetParent( pWin );
1358                 GetWindow()->SetParent( pWin );
1359                 pWin->SetPosPixel( Point() );
1360
1361                 GetWindow()->mpWindowImpl->mpBorderWindow = pWin;
1362                 pWin->mpWindowImpl->mpClientWindow = mpDockingWindow;
1363                 GetWindow()->mpWindowImpl->mpRealParent = pRealParent;
1364
1365                 pWin->SetText( GetWindow()->GetText() );
1366                 pWin->SetOutputSizePixel( GetWindow()->GetSizePixel() );
1367                 pWin->SetPosPixel( maFloatPos );
1368                 // DockingDaten ans FloatingWindow weiterreichen
1369                 pWin->ShowTitleButton( TITLE_BUTTON_DOCKING, mbDockBtn );
1370                 pWin->ShowTitleButton( TITLE_BUTTON_HIDE, mbHideBtn );
1371                 pWin->SetPin( mbPined );
1372                 if ( mbRollUp )
1373                     pWin->RollUp();
1374                 else
1375                     pWin->RollDown();
1376                 pWin->SetRollUpOutputSizePixel( maRollUpOutSize );
1377                 pWin->SetMinOutputSizePixel( maMinOutSize );
1378                 pWin->SetMaxOutputSizePixel( maMaxOutSize );
1379
1380                 if ( bVisible )
1381                     GetWindow()->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1382
1383                 ToggleFloatingMode();
1384             }
1385             else
1386             {
1387                 GetWindow()->Show( FALSE, SHOW_NOFOCUSCHANGE );
1388
1389                 // FloatingDaten wird im FloatingWindow speichern
1390                 maFloatPos      = mpFloatWin->GetPosPixel();
1391                 mbDockBtn       = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_DOCKING );
1392                 mbHideBtn       = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_HIDE );
1393                 mbPined         = mpFloatWin->IsPined();
1394                 mbRollUp        = mpFloatWin->IsRollUp();
1395                 maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel();
1396                 maMinOutSize    = mpFloatWin->GetMinOutputSizePixel();
1397                 maMaxOutSize    = mpFloatWin->GetMaxOutputSizePixel();
1398
1399                 Window* pRealParent = GetWindow()->GetWindow( WINDOW_PARENT ); //mpWindowImpl->mpRealParent;
1400                 GetWindow()->mpWindowImpl->mpBorderWindow = NULL;
1401                 if ( mpOldBorderWin )
1402                 {
1403                     GetWindow()->SetParent( mpOldBorderWin );
1404                     ((ImplBorderWindow*)mpOldBorderWin)->GetBorder(
1405                         GetWindow()->mpWindowImpl->mnLeftBorder, GetWindow()->mpWindowImpl->mnTopBorder,
1406                         GetWindow()->mpWindowImpl->mnRightBorder, GetWindow()->mpWindowImpl->mnBottomBorder );
1407                     mpOldBorderWin->Resize();
1408                 }
1409                 GetWindow()->mpWindowImpl->mpBorderWindow = mpOldBorderWin;
1410                 GetWindow()->SetParent( pRealParent );
1411                 GetWindow()->mpWindowImpl->mpRealParent = pRealParent;
1412
1413                 delete static_cast<ImplDockFloatWin2*>(mpFloatWin);
1414                 mpFloatWin = NULL;
1415                 GetWindow()->SetPosPixel( maDockPos );
1416
1417                 if ( bVisible )
1418                     GetWindow()->Show();
1419
1420                 ToggleFloatingMode();
1421
1422             }
1423         }
1424     }
1425 }
1426
1427 // -----------------------------------------------------------------------
1428
1429 void ImplDockingWindowWrapper::SetFloatStyle( WinBits nStyle )
1430 {
1431     mnFloatBits = nStyle;
1432 }
1433
1434 // -----------------------------------------------------------------------
1435
1436 WinBits ImplDockingWindowWrapper::GetFloatStyle() const
1437 {
1438     return mnFloatBits;
1439 }
1440
1441 // -----------------------------------------------------------------------
1442
1443 void ImplDockingWindowWrapper::SetTabStop()
1444 {
1445     GetWindow()->SetStyle( GetWindow()->GetStyle() | (WB_GROUP | WB_TABSTOP) );
1446 }
1447
1448 // -----------------------------------------------------------------------
1449
1450 void ImplDockingWindowWrapper::SetPosSizePixel( long nX, long nY,
1451                                      long nWidth, long nHeight,
1452                                      USHORT nFlags )
1453 {
1454     if ( mpFloatWin )
1455         mpFloatWin->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
1456     else
1457         GetWindow()->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
1458 }
1459
1460 // -----------------------------------------------------------------------
1461
1462 Point ImplDockingWindowWrapper::GetPosPixel() const
1463 {
1464     if ( mpFloatWin )
1465         return mpFloatWin->GetPosPixel();
1466     else
1467         return mpDockingWindow->GetPosPixel();
1468 }
1469
1470 // -----------------------------------------------------------------------
1471
1472 Size ImplDockingWindowWrapper::GetSizePixel() const
1473 {
1474     if ( mpFloatWin )
1475         return mpFloatWin->GetSizePixel();
1476     else
1477         return mpDockingWindow->GetSizePixel();
1478 }
1479
1480 // -----------------------------------------------------------------------
1481
1482 void ImplDockingWindowWrapper::SetOutputSizePixel( const Size& rNewSize )
1483 {
1484     if ( mpFloatWin )
1485         mpFloatWin->SetOutputSizePixel( rNewSize );
1486     else
1487         GetWindow()->SetOutputSizePixel( rNewSize );
1488 }
1489
1490 // -----------------------------------------------------------------------
1491
1492 Size ImplDockingWindowWrapper::GetOutputSizePixel() const
1493 {
1494     if ( mpFloatWin )
1495         return mpFloatWin->GetOutputSizePixel();
1496     else
1497         return mpDockingWindow->GetOutputSizePixel();
1498 }
1499
1500 Point ImplDockingWindowWrapper::GetFloatingPos() const
1501 {
1502     if ( mpFloatWin )
1503     {
1504         //Rectangle aRect = mpFloatWin->GetWindow( WINDOW_CLIENT)->GetWindowExtentsRelative( mpFloatWin->GetParent() );
1505         WindowStateData aData;
1506         aData.SetMask( WINDOWSTATE_MASK_POS );
1507         mpFloatWin->GetWindowStateData( aData );
1508         Point aPos( aData.GetX(), aData.GetY() );
1509         aPos = mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos );
1510         return aPos;
1511     }
1512     else
1513         return maFloatPos;
1514 }
1515
1516 // -----------------------------------------------------------------------
1517 // old inlines from DockingWindow
1518 // -----------------------------------------------------------------------
1519
1520 void ImplDockingWindowWrapper::SetPin( BOOL bPin )
1521 {
1522     if ( mpFloatWin )
1523         mpFloatWin->SetPin( bPin );
1524     mbPined = bPin;
1525 }
1526
1527 BOOL ImplDockingWindowWrapper::IsPined() const
1528 {
1529     if ( mpFloatWin )
1530         return mpFloatWin->IsPined();
1531     return mbPined;
1532 }
1533
1534 void ImplDockingWindowWrapper::RollUp()
1535 {
1536     if ( mpFloatWin )
1537         mpFloatWin->RollUp();
1538     mbRollUp = TRUE;
1539 }
1540
1541 void ImplDockingWindowWrapper::RollDown()
1542 {
1543     if ( mpFloatWin )
1544         mpFloatWin->RollDown();
1545     mbRollUp = FALSE;
1546 }
1547
1548 BOOL ImplDockingWindowWrapper::IsRollUp() const
1549 {
1550     if ( mpFloatWin )
1551         return mpFloatWin->IsRollUp();
1552     return mbRollUp;
1553 }
1554
1555 void ImplDockingWindowWrapper::SetRollUpOutputSizePixel( const Size& rSize )
1556 {
1557     if ( mpFloatWin )
1558         mpFloatWin->SetRollUpOutputSizePixel( rSize );
1559     maRollUpOutSize = rSize;
1560 }
1561
1562 Size ImplDockingWindowWrapper::GetRollUpOutputSizePixel() const
1563 {
1564     if ( mpFloatWin )
1565         return mpFloatWin->GetRollUpOutputSizePixel();
1566     return maRollUpOutSize;
1567 }
1568
1569 void ImplDockingWindowWrapper::SetMinOutputSizePixel( const Size& rSize )
1570 {
1571     if ( mpFloatWin )
1572         mpFloatWin->SetMinOutputSizePixel( rSize );
1573     maMinOutSize = rSize;
1574 }
1575
1576 void ImplDockingWindowWrapper::SetMaxOutputSizePixel( const Size& rSize )
1577 {
1578     if ( mpFloatWin )
1579         mpFloatWin->SetMaxOutputSizePixel( rSize );
1580     maMaxOutSize = rSize;
1581 }
1582
1583 const Size& ImplDockingWindowWrapper::GetMinOutputSizePixel() const
1584 {
1585     if ( mpFloatWin )
1586         return mpFloatWin->GetMinOutputSizePixel();
1587     return maMinOutSize;
1588 }
1589
1590 const Size& ImplDockingWindowWrapper::GetMaxOutputSizePixel() const
1591 {
1592     if ( mpFloatWin )
1593         return mpFloatWin->GetMaxOutputSizePixel();
1594     return maMaxOutSize;
1595 }
1596
1597 void ImplDockingWindowWrapper::SetFloatingPos( const Point& rNewPos )
1598 {
1599     if ( mpFloatWin )
1600         mpFloatWin->SetPosPixel( rNewPos );
1601     else
1602         maFloatPos = rNewPos;
1603 }
1604
1605 BOOL ImplDockingWindowWrapper::IsFloatingMode() const
1606 {
1607     return (mpFloatWin != NULL);
1608 }
1609
1610
1611 void    ImplDockingWindowWrapper::SetDragArea( const Rectangle& rRect )
1612 {
1613     maDragArea = rRect;
1614 }
1615
1616 Rectangle  ImplDockingWindowWrapper::GetDragArea() const
1617 {
1618     return maDragArea;
1619 }
1620
1621 void ImplDockingWindowWrapper::Lock()
1622 {
1623     mbLocked = TRUE;
1624     // only toolbars support locking
1625     ToolBox *pToolBox = dynamic_cast< ToolBox * >( GetWindow() );
1626     if( pToolBox )
1627         pToolBox->Lock( mbLocked );
1628 }
1629
1630 void ImplDockingWindowWrapper::Unlock()
1631 {
1632     mbLocked = FALSE;
1633     // only toolbars support locking
1634     ToolBox *pToolBox = dynamic_cast< ToolBox * >( GetWindow() );
1635     if( pToolBox )
1636         pToolBox->Lock( mbLocked );
1637 }
1638
1639 BOOL ImplDockingWindowWrapper::IsLocked() const
1640 {
1641     return mbLocked;
1642 }