LCOV - code coverage report
Current view: top level - vcl/source/window - dockmgr.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 730 0.0 %
Date: 2014-04-14 Functions: 0 89 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10