diff options
Diffstat (limited to 'vcl/source/window/dockwin.cxx')
| -rw-r--r-- | vcl/source/window/dockwin.cxx | 1123 |
1 files changed, 1123 insertions, 0 deletions
diff --git a/vcl/source/window/dockwin.cxx b/vcl/source/window/dockwin.cxx new file mode 100644 index 000000000000..4709c3b20c6f --- /dev/null +++ b/vcl/source/window/dockwin.cxx @@ -0,0 +1,1123 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: dockwin.cxx,v $ + * $Revision: 1.29 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_vcl.hxx" + +#ifndef _SV_SVSYS_HXX +#include <svsys.h> +#endif +#include <tools/time.hxx> +#ifndef _SV_RC_H +#include <tools/rc.h> +#endif +#include <vcl/event.hxx> +#include <vcl/brdwin.hxx> +#include <vcl/floatwin.hxx> +#include <vcl/dockwin.hxx> +#include <vcl/svapp.hxx> +#include <vcl/svdata.hxx> +#include <vcl/timer.hxx> +#include <vcl/window.h> +#include <vcl/unowrap.hxx> +#include <vcl/salframe.hxx> + + + +// ======================================================================= + +#define DOCKWIN_FLOATSTYLES (WB_SIZEABLE | WB_MOVEABLE | WB_CLOSEABLE | WB_STANDALONE | WB_PINABLE | WB_ROLLABLE ) + +// ======================================================================= + +// ----------------------------------------------------------------------- + +class DockingWindow::ImplData +{ +public: + ImplData(); + ~ImplData(); + + Window* mpParent; + Size maMaxOutSize; +}; + +DockingWindow::ImplData::ImplData() +{ + mpParent = NULL; + maMaxOutSize = Size( SHRT_MAX, SHRT_MAX ); +} + +DockingWindow::ImplData::~ImplData() +{ +} + +// ----------------------------------------------------------------------- + +class ImplDockFloatWin : public FloatingWindow +{ +private: + DockingWindow* mpDockWin; + ULONG mnLastTicks; + Timer maDockTimer; + Point maDockPos; + Rectangle maDockRect; + BOOL mbInMove; + ULONG mnLastUserEvent; + + DECL_LINK( DockingHdl, ImplDockFloatWin* ); + DECL_LINK( DockTimerHdl, ImplDockFloatWin* ); +public: + ImplDockFloatWin( Window* pParent, WinBits nWinBits, + DockingWindow* pDockingWin ); + ~ImplDockFloatWin(); + + virtual void Move(); + virtual void Resize(); + virtual void TitleButtonClick( USHORT nButton ); + virtual void Pin(); + virtual void Roll(); + virtual void PopupModeEnd(); + virtual void Resizing( Size& rSize ); + virtual BOOL Close(); + + ULONG GetLastTicks() const { return mnLastTicks; } +}; + + +ImplDockFloatWin::ImplDockFloatWin( Window* pParent, WinBits nWinBits, + DockingWindow* pDockingWin ) : + FloatingWindow( pParent, nWinBits ), + mpDockWin( pDockingWin ), + mnLastTicks( Time::GetSystemTicks() ), + mbInMove( FALSE ), + mnLastUserEvent( 0 ) +{ + // Daten vom DockingWindow uebernehmen + if ( pDockingWin ) + { + SetSettings( pDockingWin->GetSettings() ); + Enable( pDockingWin->IsEnabled(), FALSE ); + EnableInput( pDockingWin->IsInputEnabled(), FALSE ); + AlwaysEnableInput( pDockingWin->IsAlwaysEnableInput(), FALSE ); + EnableAlwaysOnTop( pDockingWin->IsAlwaysOnTopEnabled() ); + SetActivateMode( pDockingWin->GetActivateMode() ); + } + + SetBackground(); + + maDockTimer.SetTimeoutHdl( LINK( this, ImplDockFloatWin, DockTimerHdl ) ); + maDockTimer.SetTimeout( 50 ); +} + +// ----------------------------------------------------------------------- + +ImplDockFloatWin::~ImplDockFloatWin() +{ + if( mnLastUserEvent ) + Application::RemoveUserEvent( mnLastUserEvent ); +} + +// ----------------------------------------------------------------------- + +IMPL_LINK( ImplDockFloatWin, DockTimerHdl, ImplDockFloatWin*, EMPTYARG ) +{ + DBG_ASSERT( mpDockWin->IsFloatingMode(), "docktimer called but not floating" ); + + maDockTimer.Stop(); + PointerState aState = GetPointerState(); + + if( aState.mnState & KEY_MOD1 ) + { + // i43499 CTRL disables docking now + mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking(); + mpDockWin->EndDocking( maDockRect, TRUE ); + if( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) + maDockTimer.Start(); + } + else if( ! ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) ) + { + mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking(); + mpDockWin->EndDocking( maDockRect, FALSE ); + } + else + { + mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_BIG | SHOWTRACK_WINDOW ); + maDockTimer.Start(); + } + + return 0; +} + +IMPL_LINK( ImplDockFloatWin, DockingHdl, ImplDockFloatWin*, EMPTYARG ) +{ + PointerState aState = mpDockWin->GetParent()->GetPointerState(); + + mnLastUserEvent = 0; + if( mpDockWin->IsDockable() && + (Time::GetSystemTicks() - mnLastTicks > 500) && + ( aState.mnState & ( MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT ) ) && + !(aState.mnState & KEY_MOD1) ) // i43499 CTRL disables docking now + { + maDockPos = Point( mpDockWin->GetParent()->AbsoluteScreenToOutputPixel( OutputToAbsoluteScreenPixel( Point() ) ) ); + maDockPos = mpDockWin->GetParent()->OutputToScreenPixel( maDockPos ); // sfx expects screen coordinates + + if( ! mpDockWin->IsDocking() ) + mpDockWin->StartDocking(); + maDockRect = Rectangle( maDockPos, mpDockWin->GetSizePixel() ); + + // mouse pos also in screen pixels + Point aMousePos = mpDockWin->GetParent()->OutputToScreenPixel( aState.maPos ); + + BOOL bFloatMode = mpDockWin->Docking( aMousePos, maDockRect ); + if( ! bFloatMode ) + { + mpDockWin->GetParent()->ImplGetFrameWindow()->ShowTracking( maDockRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW ); + DockTimerHdl( this ); + } + else + { + mpDockWin->GetParent()->ImplGetFrameWindow()->HideTracking(); + maDockTimer.Stop(); + mpDockWin->EndDocking( maDockRect, TRUE ); + } + } + mbInMove = FALSE; + return 0; +} +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::Move() +{ + if( mbInMove ) + return; + + mbInMove = TRUE; + FloatingWindow::Move(); + mpDockWin->Move(); + + /* + * note: the window should only dock if + * the user releases all mouse buttons. The real problem here + * is that we don't get mouse events (at least not on X) + * if the mouse is on the decoration. So we have to start an + * awkward timer based process that polls the modifier/buttons + * to see whether they are in the right condition shortly after the + * last Move message. + */ + if( ! mnLastUserEvent ) + mnLastUserEvent = Application::PostUserEvent( LINK( this, ImplDockFloatWin, DockingHdl ) ); +} + +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::Resize() +{ + FloatingWindow::Resize(); + Size aSize( GetSizePixel() ); + mpDockWin->ImplPosSizeWindow( 0, 0, aSize.Width(), aSize.Height(), WINDOW_POSSIZE_POSSIZE ); +} + +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::TitleButtonClick( USHORT nButton ) +{ + FloatingWindow::TitleButtonClick( nButton ); + mpDockWin->TitleButtonClick( nButton ); +} + +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::Pin() +{ + FloatingWindow::Pin(); + mpDockWin->Pin(); +} + +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::Roll() +{ + FloatingWindow::Roll(); + mpDockWin->Roll(); +} + +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::PopupModeEnd() +{ + FloatingWindow::PopupModeEnd(); + mpDockWin->PopupModeEnd(); +} + +// ----------------------------------------------------------------------- + +void ImplDockFloatWin::Resizing( Size& rSize ) +{ + FloatingWindow::Resizing( rSize ); + mpDockWin->Resizing( rSize ); +} + +// ----------------------------------------------------------------------- + +BOOL ImplDockFloatWin::Close() +{ + return mpDockWin->Close(); +} + +// ======================================================================= + +BOOL DockingWindow::ImplStartDocking( const Point& rPos ) +{ + if ( !mbDockable ) + return FALSE; + + maMouseOff = rPos; + maMouseStart = maMouseOff; + mbDocking = TRUE; + mbLastFloatMode = IsFloatingMode(); + mbStartFloat = mbLastFloatMode; + + // FloatingBorder berechnen + FloatingWindow* pWin; + if ( mpFloatWin ) + pWin = mpFloatWin; + else + pWin = new ImplDockFloatWin( mpImplData->mpParent, mnFloatBits, NULL ); + pWin->GetBorder( mnDockLeft, mnDockTop, mnDockRight, mnDockBottom ); + if ( !mpFloatWin ) + delete pWin; + + Point aPos = ImplOutputToFrame( Point() ); + Size aSize = Window::GetOutputSizePixel(); + mnTrackX = aPos.X(); + mnTrackY = aPos.Y(); + mnTrackWidth = aSize.Width(); + mnTrackHeight = aSize.Height(); + + if ( mbLastFloatMode ) + { + maMouseOff.X() += mnDockLeft; + maMouseOff.Y() += mnDockTop; + mnTrackX -= mnDockLeft; + mnTrackY -= mnDockTop; + mnTrackWidth += mnDockLeft+mnDockRight; + mnTrackHeight += mnDockTop+mnDockBottom; + } + + if ( GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_DOCKING && + !( mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ) ) // no full drag when migrating to system window + mbDragFull = TRUE; + else + { + StartDocking(); + mbDragFull = FALSE; + ImplUpdateAll(); + ImplGetFrameWindow()->ImplUpdateAll(); + } + + StartTracking( STARTTRACK_KEYMOD ); + return TRUE; +} + +// ======================================================================= + +void DockingWindow::ImplInitDockingWindowData() +{ + mpImplData = new ImplData; + mpWindowImpl->mbDockWin = TRUE; + + mpFloatWin = NULL; + mbDockCanceled = FALSE; + mbDockPrevented = FALSE; + mbFloatPrevented = FALSE; + mbDocking = FALSE; + mbPined = FALSE; + mbRollUp = FALSE; + mbDockBtn = FALSE; + mbHideBtn = FALSE; +} + +// ----------------------------------------------------------------------- + +void DockingWindow::ImplInit( Window* pParent, WinBits nStyle ) +{ + if ( !(nStyle & WB_NODIALOGCONTROL) ) + nStyle |= WB_DIALOGCONTROL; + + mpImplData->mpParent = pParent; + mbDockable = (nStyle & WB_DOCKABLE) != 0; + mnFloatBits = WB_BORDER | (nStyle & DOCKWIN_FLOATSTYLES); + nStyle &= ~(DOCKWIN_FLOATSTYLES | WB_BORDER); + if ( nStyle & WB_DOCKBORDER ) + nStyle |= WB_BORDER; + + Window::ImplInit( pParent, nStyle, NULL ); + + ImplInitSettings(); +} + +// ----------------------------------------------------------------------- + +void DockingWindow::ImplInitSettings() +{ + // Hack, damit man auch DockingWindows ohne Hintergrund bauen kann + // und noch nicht alles umgestellt ist + if ( IsBackground() ) + { + const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); + + Color aColor; + if ( IsControlBackground() ) + aColor = GetControlBackground(); + else if ( Window::GetStyle() & WB_3DLOOK ) + aColor = rStyleSettings.GetFaceColor(); + else + aColor = rStyleSettings.GetWindowColor(); + SetBackground( aColor ); + } +} + +// ----------------------------------------------------------------------- + +void DockingWindow::ImplLoadRes( const ResId& rResId ) +{ + Window::ImplLoadRes( rResId ); + + ULONG nMask = ReadLongRes(); + + if ( (RSC_DOCKINGWINDOW_XYMAPMODE | RSC_DOCKINGWINDOW_X | + RSC_DOCKINGWINDOW_Y) & nMask ) + { + // Groessenangabe aus der Resource verwenden + Point aPos; + MapUnit ePosMap = MAP_PIXEL; + + if ( RSC_DOCKINGWINDOW_XYMAPMODE & nMask ) + ePosMap = (MapUnit)ReadLongRes(); + + if ( RSC_DOCKINGWINDOW_X & nMask ) + { + aPos.X() = ReadShortRes(); + aPos.X() = ImplLogicUnitToPixelX( aPos.X(), ePosMap ); + } + + if ( RSC_DOCKINGWINDOW_Y & nMask ) + { + aPos.Y() = ReadShortRes(); + aPos.Y() = ImplLogicUnitToPixelY( aPos.Y(), ePosMap ); + } + + SetFloatingPos( aPos ); + } + + if ( nMask & RSC_DOCKINGWINDOW_FLOATING ) + { + if ( (BOOL)ReadShortRes() ) + SetFloatingMode( TRUE ); + } +} + +// ----------------------------------------------------------------------- + +DockingWindow::DockingWindow( WindowType nType ) : + Window( nType ) +{ + ImplInitDockingWindowData(); +} + +// ----------------------------------------------------------------------- + +DockingWindow::DockingWindow( Window* pParent, WinBits nStyle ) : + Window( WINDOW_DOCKINGWINDOW ) +{ + ImplInitDockingWindowData(); + ImplInit( pParent, nStyle ); +} + +// ----------------------------------------------------------------------- + +DockingWindow::DockingWindow( Window* pParent, const ResId& rResId ) : + Window( WINDOW_DOCKINGWINDOW ) +{ + ImplInitDockingWindowData(); + rResId.SetRT( RSC_DOCKINGWINDOW ); + WinBits nStyle = ImplInitRes( rResId ); + ImplInit( pParent, nStyle ); + ImplLoadRes( rResId ); + + if ( !(nStyle & WB_HIDE) ) + Show(); +} + +// ----------------------------------------------------------------------- + +DockingWindow::~DockingWindow() +{ + if ( IsFloatingMode() ) + { + Show( FALSE, SHOW_NOFOCUSCHANGE ); + SetFloatingMode( FALSE ); + } + delete mpImplData; +} + +// ----------------------------------------------------------------------- + +void DockingWindow::Tracking( const TrackingEvent& rTEvt ) +{ + if( GetDockingManager()->IsDockable( this ) ) // new docking interface + return Window::Tracking( rTEvt ); + + if ( mbDocking ) + { + if ( rTEvt.IsTrackingEnded() ) + { + mbDocking = FALSE; + if ( mbDragFull ) + { + // Bei Abbruch alten Zustand wieder herstellen + if ( rTEvt.IsTrackingCanceled() ) + { + StartDocking(); + Rectangle aRect( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ); + EndDocking( aRect, mbStartFloat ); + } + } + else + { + HideTracking(); + if ( rTEvt.IsTrackingCanceled() ) + { + mbDockCanceled = TRUE; + EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode ); + mbDockCanceled = FALSE; + } + else + EndDocking( Rectangle( Point( mnTrackX, mnTrackY ), Size( mnTrackWidth, mnTrackHeight ) ), mbLastFloatMode ); + } + } + // Docking nur bei nicht synthetischen MouseEvents + else if ( !rTEvt.GetMouseEvent().IsSynthetic() || rTEvt.GetMouseEvent().IsModifierChanged() ) + { + Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel(); + Point aFrameMousePos = ImplOutputToFrame( aMousePos ); + Size aFrameSize = mpWindowImpl->mpFrameWindow->GetOutputSizePixel(); + if ( aFrameMousePos.X() < 0 ) + aFrameMousePos.X() = 0; + if ( aFrameMousePos.Y() < 0 ) + aFrameMousePos.Y() = 0; + if ( aFrameMousePos.X() > aFrameSize.Width()-1 ) + aFrameMousePos.X() = aFrameSize.Width()-1; + if ( aFrameMousePos.Y() > aFrameSize.Height()-1 ) + aFrameMousePos.Y() = aFrameSize.Height()-1; + aMousePos = ImplFrameToOutput( aFrameMousePos ); + aMousePos.X() -= maMouseOff.X(); + aMousePos.Y() -= maMouseOff.Y(); + Point aFramePos = ImplOutputToFrame( aMousePos ); + Rectangle aTrackRect( aFramePos, Size( mnTrackWidth, mnTrackHeight ) ); + Rectangle aCompRect = aTrackRect; + aFramePos.X() += maMouseOff.X(); + aFramePos.Y() += maMouseOff.Y(); + if ( mbDragFull ) + StartDocking(); + BOOL bFloatMode = Docking( aFramePos, aTrackRect ); + mbDockPrevented = FALSE; + mbFloatPrevented = FALSE; + if ( mbLastFloatMode != bFloatMode ) + { + if ( bFloatMode ) + { + aTrackRect.Left() -= mnDockLeft; + aTrackRect.Top() -= mnDockTop; + aTrackRect.Right() += mnDockRight; + aTrackRect.Bottom() += mnDockBottom; + } + else + { + if ( aCompRect == aTrackRect ) + { + aTrackRect.Left() += mnDockLeft; + aTrackRect.Top() += mnDockTop; + aTrackRect.Right() -= mnDockRight; + aTrackRect.Bottom() -= mnDockBottom; + } + } + mbLastFloatMode = bFloatMode; + } + if ( mbDragFull ) + { + Point aPos; + Point aOldPos = OutputToScreenPixel( aPos ); + EndDocking( aTrackRect, mbLastFloatMode ); + // Wenn der Status bzw. die Position sich + // geaendert hat, dann neu ausgeben + if ( aOldPos != OutputToScreenPixel( aPos ) ) + { + ImplUpdateAll(); + ImplGetFrameWindow()->ImplUpdateAll(); + } +// EndDocking( aTrackRect, mbLastFloatMode ); + } + else + { + USHORT nTrackStyle; + if ( bFloatMode ) + nTrackStyle = SHOWTRACK_BIG; + else + nTrackStyle = SHOWTRACK_OBJECT; + Rectangle aShowTrackRect = aTrackRect; + aShowTrackRect.SetPos( ImplFrameToOutput( aShowTrackRect.TopLeft() ) ); + ShowTracking( aShowTrackRect, nTrackStyle ); + + // Maus-Offset neu berechnen, da Rechteck veraendert werden + // konnte + maMouseOff.X() = aFramePos.X() - aTrackRect.Left(); + maMouseOff.Y() = aFramePos.Y() - aTrackRect.Top(); + } + + mnTrackX = aTrackRect.Left(); + mnTrackY = aTrackRect.Top(); + mnTrackWidth = aTrackRect.GetWidth(); + mnTrackHeight = aTrackRect.GetHeight(); + } + } +} + +// ----------------------------------------------------------------------- + +long DockingWindow::Notify( NotifyEvent& rNEvt ) +{ + if( GetDockingManager()->IsDockable( this ) ) // new docking interface + return Window::Notify( rNEvt ); + + if ( mbDockable ) + { + if ( rNEvt.GetType() == EVENT_MOUSEBUTTONDOWN ) + { + const MouseEvent* pMEvt = rNEvt.GetMouseEvent(); + if ( pMEvt->IsLeft() ) + { + if ( pMEvt->IsMod1() && (pMEvt->GetClicks() == 2) ) + { + SetFloatingMode( !IsFloatingMode() ); + return TRUE; + } + else if ( pMEvt->GetClicks() == 1 ) + { + // check if window is floating standalone (IsFloating()) + // or only partially floating and still docked with one border + // ( !mpWindowImpl->mbFrame) + if( ! IsFloatingMode() || ! mpFloatWin->mpWindowImpl->mbFrame ) + { + Point aPos = pMEvt->GetPosPixel(); + Window* pWindow = rNEvt.GetWindow(); + if ( pWindow != this ) + { + aPos = pWindow->OutputToScreenPixel( aPos ); + aPos = ScreenToOutputPixel( aPos ); + } + ImplStartDocking( aPos ); + } + return TRUE; + } + } + } + else if( rNEvt.GetType() == EVENT_KEYINPUT ) + { + const KeyCode& rKey = rNEvt.GetKeyEvent()->GetKeyCode(); + if( rKey.GetCode() == KEY_F10 && rKey.GetModifier() && + rKey.IsShift() && rKey.IsMod1() ) + { + SetFloatingMode( !IsFloatingMode() ); + return TRUE; + } + } + } + + return Window::Notify( rNEvt ); +} + +// ----------------------------------------------------------------------- + +void DockingWindow::StartDocking() +{ + mbDocking = TRUE; +} + +// ----------------------------------------------------------------------- + +BOOL DockingWindow::Docking( const Point&, Rectangle& ) +{ + return IsFloatingMode(); +} + +// ----------------------------------------------------------------------- + +void DockingWindow::EndDocking( const Rectangle& rRect, BOOL bFloatMode ) +{ + if ( !IsDockingCanceled() ) + { + BOOL bShow = FALSE; + if ( bFloatMode != IsFloatingMode() ) + { + Show( FALSE, SHOW_NOFOCUSCHANGE ); + SetFloatingMode( bFloatMode ); + bShow = TRUE; + if ( bFloatMode && mpFloatWin ) + mpFloatWin->SetPosSizePixel( rRect.TopLeft(), rRect.GetSize() ); + } + if ( !bFloatMode ) + { + Point aPos = rRect.TopLeft(); + aPos = GetParent()->ScreenToOutputPixel( aPos ); + Window::SetPosSizePixel( aPos, rRect.GetSize() ); + } + + if ( bShow ) + Show(); + } + mbDocking = FALSE; +} + +// ----------------------------------------------------------------------- + +BOOL DockingWindow::PrepareToggleFloatingMode() +{ + return TRUE; +} + +// ----------------------------------------------------------------------- + +BOOL DockingWindow::Close() +{ + ImplDelData aDelData; + ImplAddDel( &aDelData ); + ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE ); + if ( aDelData.IsDelete() ) + return FALSE; + ImplRemoveDel( &aDelData ); + + if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() ) + return FALSE; + + Show( FALSE, SHOW_NOFOCUSCHANGE ); + return TRUE; +} + +// ----------------------------------------------------------------------- + +void DockingWindow::ToggleFloatingMode() +{ +} + +// ----------------------------------------------------------------------- + +void DockingWindow::TitleButtonClick( USHORT ) +{ +} + +// ----------------------------------------------------------------------- + +void DockingWindow::Pin() +{ +} + +// ----------------------------------------------------------------------- + +void DockingWindow::Roll() +{ +} + +// ----------------------------------------------------------------------- + +void DockingWindow::PopupModeEnd() +{ +} + +// ----------------------------------------------------------------------- + +void DockingWindow::Resizing( Size& ) +{ +} + +// ----------------------------------------------------------------------- + +void DockingWindow::StateChanged( StateChangedType nType ) +{ + if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) + { + ImplInitSettings(); + Invalidate(); + } + + Window::StateChanged( nType ); +} + +// ----------------------------------------------------------------------- + +void DockingWindow::DataChanged( const DataChangedEvent& rDCEvt ) +{ + if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && + (rDCEvt.GetFlags() & SETTINGS_STYLE) ) + { + ImplInitSettings(); + Invalidate(); + } + else + Window::DataChanged( rDCEvt ); +} + +// ----------------------------------------------------------------------- + +void DockingWindow::ShowTitleButton( USHORT nButton, BOOL bVisible ) +{ + if ( mpFloatWin ) + mpFloatWin->ShowTitleButton( nButton, bVisible ); + else + { + if ( nButton == TITLE_BUTTON_DOCKING ) + mbDockBtn = bVisible; + else /* if ( nButton == TITLE_BUTTON_HIDE ) */ + mbHideBtn = bVisible; + } +} + +// ----------------------------------------------------------------------- + +BOOL DockingWindow::IsTitleButtonVisible( USHORT nButton ) const +{ + if ( mpFloatWin ) + return mpFloatWin->IsTitleButtonVisible( nButton ); + else + { + if ( nButton == TITLE_BUTTON_DOCKING ) + return mbDockBtn; + else /* if ( nButton == TITLE_BUTTON_HIDE ) */ + return mbHideBtn; + } +} + +// ----------------------------------------------------------------------- + +void DockingWindow::SetFloatingMode( BOOL bFloatMode ) +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + pWrapper->SetFloatingMode( bFloatMode ); + return; + } + if ( IsFloatingMode() != bFloatMode ) + { + if ( PrepareToggleFloatingMode() ) // changes to floating mode can be vetoed + { + BOOL bVisible = IsVisible(); + + if ( bFloatMode ) + { + Show( FALSE, SHOW_NOFOCUSCHANGE ); + + maDockPos = Window::GetPosPixel(); + + Window* pRealParent = mpWindowImpl->mpRealParent; + mpOldBorderWin = mpWindowImpl->mpBorderWindow; + + ImplDockFloatWin* pWin = + new ImplDockFloatWin( + mpImplData->mpParent, + mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ? mnFloatBits | WB_SYSTEMWINDOW : mnFloatBits, + this ); + mpFloatWin = pWin; + mpWindowImpl->mpBorderWindow = NULL; + mpWindowImpl->mnLeftBorder = 0; + mpWindowImpl->mnTopBorder = 0; + mpWindowImpl->mnRightBorder = 0; + mpWindowImpl->mnBottomBorder = 0; + // Falls Parent zerstoert wird, muessen wir auch vom + // BorderWindow den Parent umsetzen + if ( mpOldBorderWin ) + mpOldBorderWin->SetParent( pWin ); + SetParent( pWin ); + SetPosPixel( Point() ); + mpWindowImpl->mpBorderWindow = pWin; + pWin->mpWindowImpl->mpClientWindow = this; + mpWindowImpl->mpRealParent = pRealParent; + pWin->SetText( Window::GetText() ); + pWin->SetOutputSizePixel( Window::GetSizePixel() ); + pWin->SetPosPixel( maFloatPos ); + // DockingDaten ans FloatingWindow weiterreichen + pWin->ShowTitleButton( TITLE_BUTTON_DOCKING, mbDockBtn ); + pWin->ShowTitleButton( TITLE_BUTTON_HIDE, mbHideBtn ); + pWin->SetPin( mbPined ); + if ( mbRollUp ) + pWin->RollUp(); + else + pWin->RollDown(); + pWin->SetRollUpOutputSizePixel( maRollUpOutSize ); + pWin->SetMinOutputSizePixel( maMinOutSize ); + pWin->SetMaxOutputSizePixel( mpImplData->maMaxOutSize ); + + ToggleFloatingMode(); + + if ( bVisible ) + Show(); + } + else + { + Show( FALSE, SHOW_NOFOCUSCHANGE ); + + // FloatingDaten wird im FloatingWindow speichern + maFloatPos = mpFloatWin->GetPosPixel(); + mbDockBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_DOCKING ); + mbHideBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_HIDE ); + mbPined = mpFloatWin->IsPined(); + mbRollUp = mpFloatWin->IsRollUp(); + maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel(); + maMinOutSize = mpFloatWin->GetMinOutputSizePixel(); + mpImplData->maMaxOutSize = mpFloatWin->GetMaxOutputSizePixel(); + + Window* pRealParent = mpWindowImpl->mpRealParent; + mpWindowImpl->mpBorderWindow = NULL; + if ( mpOldBorderWin ) + { + SetParent( mpOldBorderWin ); + ((ImplBorderWindow*)mpOldBorderWin)->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder ); + mpOldBorderWin->Resize(); + } + mpWindowImpl->mpBorderWindow = mpOldBorderWin; + SetParent( pRealParent ); + mpWindowImpl->mpRealParent = pRealParent; + delete static_cast<ImplDockFloatWin*>(mpFloatWin); + mpFloatWin = NULL; + SetPosPixel( maDockPos ); + + ToggleFloatingMode(); + + if ( bVisible ) + Show(); + } + } + } +} + +// ----------------------------------------------------------------------- + +void DockingWindow::SetFloatStyle( WinBits nStyle ) +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + pWrapper->SetFloatStyle( nStyle ); + return; + } + + mnFloatBits = nStyle; +} + +// ----------------------------------------------------------------------- + +WinBits DockingWindow::GetFloatStyle() const +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + return pWrapper->GetFloatStyle(); + } + + return mnFloatBits; +} + +// ----------------------------------------------------------------------- + +void DockingWindow::SetTabStop() +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + pWrapper->SetTabStop(); + return; + } + + mpWindowImpl->mnStyle |= WB_GROUP | WB_TABSTOP; +} + +// ----------------------------------------------------------------------- + +void DockingWindow::SetPosSizePixel( long nX, long nY, + long nWidth, long nHeight, + USHORT nFlags ) +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + if ( pWrapper->mpFloatWin ) + pWrapper->mpFloatWin->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags ); + else + Window::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags ); + return; + } + + if ( mpFloatWin ) + mpFloatWin->SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags ); + else + Window::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags ); +} + +// ----------------------------------------------------------------------- + +Point DockingWindow::GetPosPixel() const +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + if ( pWrapper->mpFloatWin ) + return pWrapper->mpFloatWin->GetPosPixel(); + else + return Window::GetPosPixel(); + } + + if ( mpFloatWin ) + return mpFloatWin->GetPosPixel(); + else + return Window::GetPosPixel(); +} + +// ----------------------------------------------------------------------- + +Size DockingWindow::GetSizePixel() const +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + if ( pWrapper->mpFloatWin ) + return pWrapper->mpFloatWin->GetSizePixel(); + else + return Window::GetSizePixel(); + } + + if ( mpFloatWin ) + return mpFloatWin->GetSizePixel(); + else + return Window::GetSizePixel(); +} + +// ----------------------------------------------------------------------- + +void DockingWindow::SetOutputSizePixel( const Size& rNewSize ) +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + if ( pWrapper->mpFloatWin ) + pWrapper->mpFloatWin->SetOutputSizePixel( rNewSize ); + else + Window::SetOutputSizePixel( rNewSize ); + return; + } + + if ( mpFloatWin ) + mpFloatWin->SetOutputSizePixel( rNewSize ); + else + Window::SetOutputSizePixel( rNewSize ); +} + +// ----------------------------------------------------------------------- + +Size DockingWindow::GetOutputSizePixel() const +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + if ( pWrapper->mpFloatWin ) + return pWrapper->mpFloatWin->GetOutputSizePixel(); + else + return Window::GetOutputSizePixel(); + } + + if ( mpFloatWin ) + return mpFloatWin->GetOutputSizePixel(); + else + return Window::GetOutputSizePixel(); +} + +Point DockingWindow::GetFloatingPos() const +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + { + if ( pWrapper->mpFloatWin ) + { + WindowStateData aData; + aData.SetMask( WINDOWSTATE_MASK_POS ); + pWrapper->mpFloatWin->GetWindowStateData( aData ); + Point aPos( aData.GetX(), aData.GetY() ); + aPos = pWrapper->mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos ); + return aPos; + } + else + return maFloatPos; + } + + if ( mpFloatWin ) + { + WindowStateData aData; + aData.SetMask( WINDOWSTATE_MASK_POS ); + mpFloatWin->GetWindowStateData( aData ); + Point aPos( aData.GetX(), aData.GetY() ); + aPos = mpFloatWin->GetParent()->ImplGetFrameWindow()->AbsoluteScreenToOutputPixel( aPos ); + return aPos; + } + else + return maFloatPos; +} + +BOOL DockingWindow::IsFloatingMode() const +{ + ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this ); + if( pWrapper ) + return pWrapper->IsFloatingMode(); + else + return (mpFloatWin != NULL); +} + +void DockingWindow::SetMaxOutputSizePixel( const Size& rSize ) +{ + if ( mpFloatWin ) + mpFloatWin->SetMaxOutputSizePixel( rSize ); + mpImplData->maMaxOutSize = rSize; +} + +const Size& DockingWindow::GetMaxOutputSizePixel() const +{ + if ( mpFloatWin ) + return mpFloatWin->GetMaxOutputSizePixel(); + return mpImplData->maMaxOutSize; +} |