vcl/source/window/dockmgr.cxx

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