| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_vcl.hxx" | |
| #include <svdata.hxx> | |
| #include <brdwin.hxx> | |
| #include <window.h> | |
| #include <salframe.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <vcl/wrkwin.hxx> | |
| #include <vcl/event.hxx> | |
| #include <vcl/toolbox.hxx> | |
| #include <vcl/floatwin.hxx> | |
| #include <tools/rc.h> | |
| #include <tools/debug.hxx> | |
| // ======================================================================= | |
| class FloatingWindow::ImplData | |
| { | |
| public: | |
| ImplData(); | |
| ~ImplData(); | |
| ToolBox* mpBox; | |
| Rectangle maItemEdgeClipRect; // used to clip the common edge between a toolbar item and the border of this window | |
| }; | |
| FloatingWindow::ImplData::ImplData() | |
| { | |
| mpBox = NULL; | |
| } | |
| FloatingWindow::ImplData::~ImplData() | |
| { | |
| } | |
| Rectangle& FloatingWindow::ImplGetItemEdgeClipRect() | |
| { | |
| return mpImplData->maItemEdgeClipRect; | |
| } | |
| // ======================================================================= | |
| void FloatingWindow::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| mpImplData = new ImplData; | |
| mpWindowImpl->mbFloatWin = sal_True; | |
| mbInCleanUp = sal_False; | |
| mbGrabFocus = sal_False; | |
| DBG_ASSERT( pParent, "FloatWindow::FloatingWindow(): - pParent == NULL!" ); | |
| if ( !pParent ) | |
| pParent = ImplGetSVData()->maWinData.mpAppWin; | |
| DBG_ASSERT( pParent, "FloatWindow::FloatingWindow(): - pParent == NULL and no AppWindow exists" ); | |
| // no Border, then we don't need a border window | |
| if ( !nStyle ) | |
| { | |
| mpWindowImpl->mbOverlapWin = sal_True; | |
| nStyle |= WB_DIALOGCONTROL; | |
| SystemWindow::ImplInit( pParent, nStyle, NULL ); | |
| } | |
| else | |
| { | |
| if ( !(nStyle & WB_NODIALOGCONTROL) ) | |
| nStyle |= WB_DIALOGCONTROL; | |
| if( nStyle & (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_CLOSEABLE | WB_STANDALONE) | |
| && !(nStyle & WB_OWNERDRAWDECORATION) ) | |
| { | |
| WinBits nFloatWinStyle = nStyle; | |
| // #99154# floaters are not closeable by default anymore, e.g. fullscreen floater | |
| // nFloatWinStyle |= WB_CLOSEABLE; | |
| mpWindowImpl->mbFrame = sal_True; | |
| mpWindowImpl->mbOverlapWin = sal_True; | |
| SystemWindow::ImplInit( pParent, nFloatWinStyle & ~WB_BORDER, NULL ); | |
| } | |
| else | |
| { | |
| ImplBorderWindow* pBorderWin; | |
| sal_uInt16 nBorderStyle = BORDERWINDOW_STYLE_BORDER | BORDERWINDOW_STYLE_FLOAT; | |
| if( nStyle & WB_OWNERDRAWDECORATION ) nBorderStyle |= BORDERWINDOW_STYLE_FRAME; | |
| else nBorderStyle |= BORDERWINDOW_STYLE_OVERLAP; | |
| if ( (nStyle & WB_SYSTEMWINDOW) && !(nStyle & (WB_MOVEABLE | WB_SIZEABLE)) ) | |
| { | |
| nBorderStyle |= BORDERWINDOW_STYLE_FRAME; | |
| nStyle |= WB_CLOSEABLE; // make undecorated floaters closeable | |
| } | |
| pBorderWin = new ImplBorderWindow( pParent, nStyle, nBorderStyle ); | |
| SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL ); | |
| pBorderWin->mpWindowImpl->mpClientWindow = this; | |
| pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder ); | |
| pBorderWin->SetDisplayActive( sal_True ); | |
| mpWindowImpl->mpBorderWindow = pBorderWin; | |
| mpWindowImpl->mpRealParent = pParent; | |
| } | |
| } | |
| SetActivateMode( 0 ); | |
| mpNextFloat = NULL; | |
| mpFirstPopupModeWin = NULL; | |
| mnPostId = 0; | |
| mnTitle = (nStyle & WB_MOVEABLE) ? FLOATWIN_TITLE_NORMAL : FLOATWIN_TITLE_NONE; | |
| mnOldTitle = mnTitle; | |
| mnPopupModeFlags = 0; | |
| mbInPopupMode = sal_False; | |
| mbPopupMode = sal_False; | |
| mbPopupModeCanceled = sal_False; | |
| mbPopupModeTearOff = sal_False; | |
| mbMouseDown = sal_False; | |
| ImplInitSettings(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::ImplInitSettings() | |
| { | |
| 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 ); | |
| } | |
| // ======================================================================= | |
| FloatingWindow::FloatingWindow( Window* pParent, WinBits nStyle ) : | |
| SystemWindow( WINDOW_FLOATINGWINDOW ) | |
| { | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| FloatingWindow::FloatingWindow( Window* pParent, const ResId& rResId ) : | |
| SystemWindow( WINDOW_FLOATINGWINDOW ) | |
| { | |
| rResId.SetRT( RSC_FLOATINGWINDOW ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::ImplLoadRes( const ResId& rResId ) | |
| { | |
| SystemWindow::ImplLoadRes( rResId ); | |
| sal_uLong nObjMask = ReadLongRes(); | |
| if ( (RSC_FLOATINGWINDOW_WHMAPMODE | RSC_FLOATINGWINDOW_WIDTH | | |
| RSC_FLOATINGWINDOW_HEIGHT) & nObjMask ) | |
| { | |
| // Groessenangabe aus der Resource verwenden | |
| Size aSize; | |
| MapUnit eSizeMap = MAP_PIXEL; | |
| if ( RSC_FLOATINGWINDOW_WHMAPMODE & nObjMask ) | |
| eSizeMap = (MapUnit) ReadShortRes(); | |
| if ( RSC_FLOATINGWINDOW_WIDTH & nObjMask ) | |
| aSize.Width() = ReadShortRes(); | |
| if ( RSC_FLOATINGWINDOW_HEIGHT & nObjMask ) | |
| aSize.Height() = ReadShortRes(); | |
| SetRollUpOutputSizePixel( LogicToPixel( aSize, eSizeMap ) ); | |
| } | |
| if (nObjMask & RSC_FLOATINGWINDOW_ZOOMIN ) | |
| { | |
| if ( ReadShortRes() ) | |
| RollUp(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| FloatingWindow::~FloatingWindow() | |
| { | |
| if( mbPopupModeCanceled ) | |
| // indicates that ESC key was pressed | |
| // will be handled in Window::ImplGrabFocus() | |
| SetDialogControlFlags( GetDialogControlFlags() | WINDOW_DLGCTRL_FLOATWIN_POPUPMODEEND_CANCEL ); | |
| if ( IsInPopupMode() ) | |
| EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL | FLOATWIN_POPUPMODEEND_DONTCALLHDL ); | |
| if ( mnPostId ) | |
| Application::RemoveUserEvent( mnPostId ); | |
| delete mpImplData; | |
| } | |
| // ----------------------------------------------------------------------- | |
| Point FloatingWindow::CalcFloatingPosition( Window* pWindow, const Rectangle& rRect, sal_uLong nFlags, sal_uInt16& rArrangeIndex ) | |
| { | |
| return ImplCalcPos( pWindow, rRect, nFlags, rArrangeIndex ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Point FloatingWindow::ImplCalcPos( Window* pWindow, | |
| const Rectangle& rRect, sal_uLong nFlags, | |
| sal_uInt16& rArrangeIndex ) | |
| { | |
| // Fenster-Position ermitteln | |
| Point aPos; | |
| Size aSize = pWindow->GetSizePixel(); | |
| Rectangle aScreenRect = pWindow->ImplGetFrameWindow()->GetDesktopRectPixel(); | |
| FloatingWindow *pFloatingWindow = dynamic_cast<FloatingWindow*>( pWindow ); | |
| // convert... | |
| Window* pW = pWindow; | |
| if ( pW->mpWindowImpl->mpRealParent ) | |
| pW = pW->mpWindowImpl->mpRealParent; | |
| Rectangle normRect( rRect ); // rRect is already relative to top-level window | |
| normRect.SetPos( pW->ScreenToOutputPixel( normRect.TopLeft() ) ); | |
| sal_Bool bRTL = Application::GetSettings().GetLayoutRTL(); | |
| Rectangle devRect( pW->OutputToAbsoluteScreenPixel( normRect.TopLeft() ), | |
| pW->OutputToAbsoluteScreenPixel( normRect.BottomRight() ) ); | |
| Rectangle devRectRTL( devRect ); | |
| if( bRTL ) | |
| // create a rect that can be compared to desktop coordinates | |
| devRectRTL = pW->ImplOutputToUnmirroredAbsoluteScreenPixel( normRect ); | |
| if( Application::GetScreenCount() > 1 && ! Application::IsMultiDisplay() ) | |
| aScreenRect = Application::GetScreenPosSizePixel( | |
| Application::GetBestScreen( bRTL ? devRectRTL : devRect ) ); | |
| sal_uInt16 nArrangeAry[5]; | |
| sal_uInt16 nArrangeIndex; | |
| sal_Bool bBreak; | |
| Point e1,e2; // the common edge between the item rect and the floating window | |
| if ( nFlags & FLOATWIN_POPUPMODE_LEFT ) | |
| { | |
| nArrangeAry[0] = FLOATWIN_POPUPMODE_LEFT; | |
| nArrangeAry[1] = FLOATWIN_POPUPMODE_RIGHT; | |
| nArrangeAry[2] = FLOATWIN_POPUPMODE_UP; | |
| nArrangeAry[3] = FLOATWIN_POPUPMODE_DOWN; | |
| nArrangeAry[4] = FLOATWIN_POPUPMODE_LEFT; | |
| } | |
| else if ( nFlags & FLOATWIN_POPUPMODE_RIGHT ) | |
| { | |
| nArrangeAry[0] = FLOATWIN_POPUPMODE_RIGHT; | |
| nArrangeAry[1] = FLOATWIN_POPUPMODE_LEFT; | |
| nArrangeAry[2] = FLOATWIN_POPUPMODE_UP; | |
| nArrangeAry[3] = FLOATWIN_POPUPMODE_DOWN; | |
| nArrangeAry[4] = FLOATWIN_POPUPMODE_RIGHT; | |
| } | |
| else if ( nFlags & FLOATWIN_POPUPMODE_UP ) | |
| { | |
| nArrangeAry[0] = FLOATWIN_POPUPMODE_UP; | |
| nArrangeAry[1] = FLOATWIN_POPUPMODE_DOWN; | |
| nArrangeAry[2] = FLOATWIN_POPUPMODE_RIGHT; | |
| nArrangeAry[3] = FLOATWIN_POPUPMODE_LEFT; | |
| nArrangeAry[4] = FLOATWIN_POPUPMODE_UP; | |
| } | |
| else | |
| { | |
| nArrangeAry[0] = FLOATWIN_POPUPMODE_DOWN; | |
| nArrangeAry[1] = FLOATWIN_POPUPMODE_UP; | |
| nArrangeAry[2] = FLOATWIN_POPUPMODE_RIGHT; | |
| nArrangeAry[3] = FLOATWIN_POPUPMODE_LEFT; | |
| nArrangeAry[4] = FLOATWIN_POPUPMODE_DOWN; | |
| } | |
| if ( nFlags & FLOATWIN_POPUPMODE_NOAUTOARRANGE ) | |
| nArrangeIndex = 4; | |
| else | |
| nArrangeIndex = 0; | |
| for ( ; nArrangeIndex < 5; nArrangeIndex++ ) | |
| { | |
| bBreak = sal_True; | |
| switch ( nArrangeAry[nArrangeIndex] ) | |
| { | |
| case FLOATWIN_POPUPMODE_LEFT: | |
| aPos.X() = devRect.Left()-aSize.Width()+1; | |
| aPos.Y() = devRect.Top(); | |
| aPos.Y() -= pWindow->mpWindowImpl->mnTopBorder; | |
| if( bRTL ) // --- RTL --- we're comparing screen coordinates here | |
| { | |
| if( (devRectRTL.Right()+aSize.Width()) > aScreenRect.Right() ) | |
| bBreak = sal_False; | |
| } | |
| else | |
| { | |
| if ( aPos.X() < aScreenRect.Left() ) | |
| bBreak = sal_False; | |
| } | |
| if( bBreak ) | |
| { | |
| e1 = devRect.TopLeft(); | |
| e2 = devRect.BottomLeft(); | |
| // set non-zero width | |
| e2.X()++; | |
| // don't clip corners | |
| e1.Y()++; | |
| e2.Y()--; | |
| } | |
| break; | |
| case FLOATWIN_POPUPMODE_RIGHT: | |
| aPos = devRect.TopRight(); | |
| aPos.Y() -= pWindow->mpWindowImpl->mnTopBorder; | |
| if( bRTL ) // --- RTL --- we're comparing screen coordinates here | |
| { | |
| if( (devRectRTL.Left() - aSize.Width()) < aScreenRect.Left() ) | |
| bBreak = sal_False; | |
| } | |
| else | |
| { | |
| if ( aPos.X()+aSize.Width() > aScreenRect.Right() ) | |
| bBreak = sal_False; | |
| } | |
| if( bBreak ) | |
| { | |
| e1 = devRect.TopRight(); | |
| e2 = devRect.BottomRight(); | |
| // set non-zero width | |
| e2.X()++; | |
| // don't clip corners | |
| e1.Y()++; | |
| e2.Y()--; | |
| } | |
| break; | |
| case FLOATWIN_POPUPMODE_UP: | |
| aPos.X() = devRect.Left(); | |
| aPos.Y() = devRect.Top()-aSize.Height()+1; | |
| if ( aPos.Y() < aScreenRect.Top() ) | |
| bBreak = sal_False; | |
| if( bBreak ) | |
| { | |
| e1 = devRect.TopLeft(); | |
| e2 = devRect.TopRight(); | |
| // set non-zero height | |
| e2.Y()++; | |
| // don't clip corners | |
| e1.X()++; | |
| e2.X()--; | |
| } | |
| break; | |
| case FLOATWIN_POPUPMODE_DOWN: | |
| aPos = devRect.BottomLeft(); | |
| if ( aPos.Y()+aSize.Height() > aScreenRect.Bottom() ) | |
| bBreak = sal_False; | |
| if( bBreak ) | |
| { | |
| e1 = devRect.BottomLeft(); | |
| e2 = devRect.BottomRight(); | |
| // set non-zero height | |
| e2.Y()++; | |
| // don't clip corners | |
| e1.X()++; | |
| e2.X()--; | |
| } | |
| break; | |
| } | |
| // Evt. noch anpassen | |
| if ( bBreak && !(nFlags & FLOATWIN_POPUPMODE_NOAUTOARRANGE) ) | |
| { | |
| if ( (nArrangeAry[nArrangeIndex] == FLOATWIN_POPUPMODE_LEFT) || | |
| (nArrangeAry[nArrangeIndex] == FLOATWIN_POPUPMODE_RIGHT) ) | |
| { | |
| if ( aPos.Y()+aSize.Height() > aScreenRect.Bottom() ) | |
| { | |
| aPos.Y() = devRect.Bottom()-aSize.Height()+1; | |
| if ( aPos.Y() < aScreenRect.Top() ) | |
| aPos.Y() = aScreenRect.Top(); | |
| } | |
| } | |
| else | |
| { | |
| if( bRTL ) // --- RTL --- we're comparing screen coordinates here | |
| { | |
| if( devRectRTL.Right()-aSize.Width()+1 < aScreenRect.Left() ) | |
| aPos.X() -= aScreenRect.Left() - devRectRTL.Right() + aSize.Width() - 1; | |
| else if( aPos.X() + aSize.Width() > aScreenRect.Right() ) | |
| { | |
| aPos.X() -= aSize.Width()-2; // popup to left instead | |
| aPos.Y() -= 2; | |
| } | |
| } | |
| else if ( aPos.X()+aSize.Width() > aScreenRect.Right() ) | |
| { | |
| aPos.X() = devRect.Right()-aSize.Width()+1; | |
| if ( aPos.X() < aScreenRect.Left() ) | |
| aPos.X() = aScreenRect.Left(); | |
| } | |
| } | |
| } | |
| if ( bBreak ) | |
| break; | |
| } | |
| if ( nArrangeIndex > 4 ) | |
| nArrangeIndex = 4; | |
| rArrangeIndex = nArrangeIndex; | |
| aPos = pW->AbsoluteScreenToOutputPixel( aPos ); | |
| // store a cliprect that can be used to clip the common edge of the itemrect and the floating window | |
| if( pFloatingWindow ) | |
| { | |
| pFloatingWindow->mpImplData->maItemEdgeClipRect = | |
| Rectangle( e1, e2 ); | |
| } | |
| // caller expects coordinates relative to top-level win | |
| return pW->OutputToScreenPixel( aPos ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| FloatingWindow* FloatingWindow::ImplFloatHitTest( Window* pReference, const Point& rPos, sal_uInt16& rHitTest ) | |
| { | |
| FloatingWindow* pWin = this; | |
| Point aAbsolute( rPos ); | |
| // compare coordinates in absolute screen coordinates | |
| if( pReference->ImplHasMirroredGraphics() ) | |
| { | |
| if(!pReference->IsRTLEnabled() ) | |
| // --- RTL --- re-mirror back to get device coordinates | |
| pReference->ImplReMirror( aAbsolute ); | |
| Rectangle aRect( pReference->ScreenToOutputPixel(aAbsolute), Size(1,1) ) ; | |
| aRect = pReference->ImplOutputToUnmirroredAbsoluteScreenPixel( aRect ); | |
| aAbsolute = aRect.TopLeft(); | |
| } | |
| else | |
| aAbsolute = Point( pReference->OutputToAbsoluteScreenPixel( | |
| pReference->ScreenToOutputPixel(rPos) ) ); | |
| do | |
| { | |
| // compute the floating window's size in absolute screen coordinates | |
| // use the border window to have the exact position | |
| Window *pBorderWin = pWin->GetWindow( WINDOW_BORDER ); | |
| Point aPt; // the top-left corner in output coordinates i.e. (0,0) | |
| Rectangle devRect( pBorderWin->ImplOutputToUnmirroredAbsoluteScreenPixel( Rectangle( aPt, pBorderWin->GetSizePixel()) ) ) ; | |
| if ( devRect.IsInside( aAbsolute ) ) | |
| { | |
| rHitTest = IMPL_FLOATWIN_HITTEST_WINDOW; | |
| return pWin; | |
| } | |
| // test, if mouse is in rectangle, (this is typically the rect of the active | |
| // toolbox item or similar) | |
| // note: maFloatRect is set in FloatingWindow::StartPopupMode() and | |
| // is already in absolute device coordinates | |
| if ( pWin->maFloatRect.IsInside( aAbsolute ) ) | |
| { | |
| rHitTest = IMPL_FLOATWIN_HITTEST_RECT; | |
| return pWin; | |
| } | |
| pWin = pWin->mpNextFloat; | |
| } | |
| while ( pWin ); | |
| rHitTest = IMPL_FLOATWIN_HITTEST_OUTSIDE; | |
| return NULL; | |
| } | |
| // ----------------------------------------------------------------------- | |
| FloatingWindow* FloatingWindow::ImplFindLastLevelFloat() | |
| { | |
| FloatingWindow* pWin = this; | |
| FloatingWindow* pLastFoundWin = pWin; | |
| do | |
| { | |
| if ( pWin->GetPopupModeFlags() & FLOATWIN_POPUPMODE_NEWLEVEL ) | |
| pLastFoundWin = pWin; | |
| pWin = pWin->mpNextFloat; | |
| } | |
| while ( pWin ); | |
| return pLastFoundWin; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool FloatingWindow::ImplIsFloatPopupModeWindow( const Window* pWindow ) | |
| { | |
| FloatingWindow* pWin = this; | |
| do | |
| { | |
| if ( pWin->mpFirstPopupModeWin == pWindow ) | |
| return sal_True; | |
| pWin = pWin->mpNextFloat; | |
| } | |
| while ( pWin ); | |
| return sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| IMPL_LINK( FloatingWindow, ImplEndPopupModeHdl, void*, EMPTYARG ) | |
| { | |
| mnPostId = 0; | |
| mnPopupModeFlags = 0; | |
| mbPopupMode = sal_False; | |
| PopupModeEnd(); | |
| return 0; | |
| } | |
| // ----------------------------------------------------------------------- | |
| long FloatingWindow::Notify( NotifyEvent& rNEvt ) | |
| { | |
| // Zuerst Basisklasse rufen wegen TabSteuerung | |
| long nRet = SystemWindow::Notify( rNEvt ); | |
| if ( !nRet ) | |
| { | |
| if ( rNEvt.GetType() == EVENT_KEYINPUT ) | |
| { | |
| const KeyEvent* pKEvt = rNEvt.GetKeyEvent(); | |
| KeyCode aKeyCode = pKEvt->GetKeyCode(); | |
| sal_uInt16 nKeyCode = aKeyCode.GetCode(); | |
| if ( (nKeyCode == KEY_ESCAPE) && (GetStyle() & WB_CLOSEABLE) ) | |
| { | |
| Close(); | |
| return sal_True; | |
| } | |
| } | |
| } | |
| return nRet; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::StateChanged( StateChangedType nType ) | |
| { | |
| SystemWindow::StateChanged( nType ); | |
| if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) | |
| { | |
| ImplInitSettings(); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::DataChanged( const DataChangedEvent& rDCEvt ) | |
| { | |
| SystemWindow::DataChanged( rDCEvt ); | |
| if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && | |
| (rDCEvt.GetFlags() & SETTINGS_STYLE) ) | |
| { | |
| ImplInitSettings(); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::ImplCallPopupModeEnd() | |
| { | |
| // PopupMode wurde beendet | |
| mbInPopupMode = sal_False; | |
| // Handler asyncron rufen | |
| if ( !mnPostId ) | |
| Application::PostUserEvent( mnPostId, LINK( this, FloatingWindow, ImplEndPopupModeHdl ) ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::PopupModeEnd() | |
| { | |
| maPopupModeEndHdl.Call( this ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::SetTitleType( sal_uInt16 nTitle ) | |
| { | |
| if ( (mnTitle != nTitle) && mpWindowImpl->mpBorderWindow ) | |
| { | |
| mnTitle = nTitle; | |
| Size aOutSize = GetOutputSizePixel(); | |
| sal_uInt16 nTitleStyle; | |
| if ( nTitle == FLOATWIN_TITLE_NORMAL ) | |
| nTitleStyle = BORDERWINDOW_TITLE_SMALL; | |
| else if ( nTitle == FLOATWIN_TITLE_TEAROFF ) | |
| nTitleStyle = BORDERWINDOW_TITLE_TEAROFF; | |
| else // nTitle == FLOATWIN_TITLE_NONE | |
| nTitleStyle = BORDERWINDOW_TITLE_NONE; | |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetTitleType( nTitleStyle, aOutSize ); | |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::StartPopupMode( const Rectangle& rRect, sal_uLong nFlags ) | |
| { | |
| // avoid flickering | |
| if ( IsVisible() ) | |
| Show( sal_False, SHOW_NOFOCUSCHANGE ); | |
| if ( IsRollUp() ) | |
| RollDown(); | |
| // remove title | |
| mnOldTitle = mnTitle; | |
| if ( nFlags & FLOATWIN_POPUPMODE_ALLOWTEAROFF ) | |
| SetTitleType( FLOATWIN_TITLE_TEAROFF ); | |
| else | |
| SetTitleType( FLOATWIN_TITLE_NONE ); | |
| // avoid close on focus change for decorated floating windows only | |
| if( mpWindowImpl->mbFrame && (GetStyle() & WB_MOVEABLE) ) | |
| nFlags |= FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE; | |
| // #102010# For debugging Accessibility | |
| static const char* pEnv = getenv("SAL_FLOATWIN_NOAPPFOCUSCLOSE" ); | |
| if( pEnv && *pEnv ) | |
| nFlags |= FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE; | |
| // compute window position according to flags and arrangement | |
| sal_uInt16 nArrangeIndex; | |
| SetPosPixel( ImplCalcPos( this, rRect, nFlags, nArrangeIndex ) ); | |
| // set data and display window | |
| // convert maFloatRect to absolute device coordinates | |
| // so they can be compared across different frames | |
| // !!! rRect is expected to be in screen coordinates of the parent frame window !!! | |
| maFloatRect = rRect; | |
| if( GetParent()->ImplHasMirroredGraphics() ) | |
| { | |
| maFloatRect.SetPos( GetParent()->ScreenToOutputPixel( rRect.TopLeft() ) ); | |
| maFloatRect = GetParent()->ImplOutputToUnmirroredAbsoluteScreenPixel( maFloatRect ); | |
| } | |
| else | |
| maFloatRect.SetPos( GetParent()->OutputToAbsoluteScreenPixel( GetParent()->ScreenToOutputPixel( rRect.TopLeft() ) ) ); | |
| maFloatRect.Left() -= 2; | |
| maFloatRect.Top() -= 2; | |
| maFloatRect.Right() += 2; | |
| maFloatRect.Bottom() += 2; | |
| mnPopupModeFlags = nFlags; | |
| mbInPopupMode = sal_True; | |
| mbPopupMode = sal_True; | |
| mbPopupModeCanceled = sal_False; | |
| mbPopupModeTearOff = sal_False; | |
| mbMouseDown = sal_False; | |
| mbOldSaveBackMode = IsSaveBackgroundEnabled(); | |
| EnableSaveBackground(); | |
| // add FloatingWindow to list of windows that are in popup mode | |
| ImplSVData* pSVData = ImplGetSVData(); | |
| mpNextFloat = pSVData->maWinData.mpFirstFloat; | |
| pSVData->maWinData.mpFirstFloat = this; | |
| if( nFlags & FLOATWIN_POPUPMODE_GRABFOCUS ) | |
| { | |
| // force key input even without focus (useful for menus) | |
| mbGrabFocus = sal_True; | |
| } | |
| Show( sal_True, SHOW_NOACTIVATE ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::StartPopupMode( ToolBox* pBox, sal_uLong nFlags ) | |
| { | |
| // get selected button | |
| sal_uInt16 nItemId = pBox->GetDownItemId(); | |
| if ( !nItemId ) | |
| return; | |
| mpImplData->mpBox = pBox; | |
| pBox->ImplFloatControl( sal_True, this ); | |
| // retrieve some data from the ToolBox | |
| Rectangle aRect = pBox->GetItemRect( nItemId ); | |
| Point aPos; | |
| // convert to parent's screen coordinates | |
| aPos = GetParent()->OutputToScreenPixel( GetParent()->AbsoluteScreenToOutputPixel( pBox->OutputToAbsoluteScreenPixel( aRect.TopLeft() ) ) ); | |
| aRect.SetPos( aPos ); | |
| nFlags |= | |
| FLOATWIN_POPUPMODE_NOFOCUSCLOSE | | |
| // FLOATWIN_POPUPMODE_NOMOUSECLOSE | | |
| FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE | | |
| // FLOATWIN_POPUPMODE_NOMOUSERECTCLOSE | // #105968# floating toolboxes should close when clicked in (parent's) float rect | |
| FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE; | |
| // | FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE; | |
| /* | |
| * FLOATWIN_POPUPMODE_NOKEYCLOSE | | |
| * don't set since it disables closing floaters with escape | |
| */ | |
| // Flags fuer Positionierung bestimmen | |
| if ( !(nFlags & (FLOATWIN_POPUPMODE_DOWN | FLOATWIN_POPUPMODE_UP | | |
| FLOATWIN_POPUPMODE_LEFT | FLOATWIN_POPUPMODE_RIGHT | | |
| FLOATWIN_POPUPMODE_NOAUTOARRANGE)) ) | |
| { | |
| if ( pBox->IsHorizontal() ) | |
| nFlags |= FLOATWIN_POPUPMODE_DOWN; | |
| else | |
| nFlags |= FLOATWIN_POPUPMODE_RIGHT; | |
| } | |
| // FloatingModus starten | |
| StartPopupMode( aRect, nFlags ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::ImplEndPopupMode( sal_uInt16 nFlags, sal_uLong nFocusId ) | |
| { | |
| if ( !mbInPopupMode ) | |
| return; | |
| ImplSVData* pSVData = ImplGetSVData(); | |
| mbInCleanUp = sal_True; // prevent killing this window due to focus change while working with it | |
| // Bei allen nachfolgenden PopupMode-Fenster den Modus auch beenden | |
| while ( pSVData->maWinData.mpFirstFloat && pSVData->maWinData.mpFirstFloat != this ) | |
| pSVData->maWinData.mpFirstFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL ); | |
| // Fenster aus der Liste austragen | |
| pSVData->maWinData.mpFirstFloat = mpNextFloat; | |
| mpNextFloat = NULL; | |
| sal_uLong nPopupModeFlags = mnPopupModeFlags; | |
| // Wenn nicht abgerissen wurde, dann Fenster wieder Hiden | |
| if ( !(nFlags & FLOATWIN_POPUPMODEEND_TEAROFF) || | |
| !(nPopupModeFlags & FLOATWIN_POPUPMODE_ALLOWTEAROFF) ) | |
| { | |
| Show( sal_False, SHOW_NOFOCUSCHANGE ); | |
| // Focus evt. auf ein entsprechendes FloatingWindow weiterschalten | |
| if ( nFocusId ) | |
| Window::EndSaveFocus( nFocusId ); | |
| else if ( pSVData->maWinData.mpFocusWin && pSVData->maWinData.mpFirstFloat && | |
| ImplIsWindowOrChild( pSVData->maWinData.mpFocusWin ) ) | |
| pSVData->maWinData.mpFirstFloat->GrabFocus(); | |
| mbPopupModeTearOff = sal_False; | |
| } | |
| else | |
| { | |
| mbPopupModeTearOff = sal_True; | |
| if ( nFocusId ) | |
| Window::EndSaveFocus( nFocusId, sal_False ); | |
| } | |
| EnableSaveBackground( mbOldSaveBackMode ); | |
| mbPopupModeCanceled = (nFlags & FLOATWIN_POPUPMODEEND_CANCEL) != 0; | |
| // Gegebenenfalls den Title wieder herstellen | |
| SetTitleType( mnOldTitle ); | |
| // ToolBox wieder auf normal schalten | |
| if ( mpImplData->mpBox ) | |
| { | |
| mpImplData->mpBox->ImplFloatControl( sal_False, this ); | |
| mpImplData->mpBox = NULL; | |
| } | |
| // Je nach Parameter den PopupModeEnd-Handler rufen | |
| if ( !(nFlags & FLOATWIN_POPUPMODEEND_DONTCALLHDL) ) | |
| ImplCallPopupModeEnd(); | |
| // Je nach Parameter die restlichen Fenster auch noch schliessen | |
| if ( nFlags & FLOATWIN_POPUPMODEEND_CLOSEALL ) | |
| { | |
| if ( !(nPopupModeFlags & FLOATWIN_POPUPMODE_NEWLEVEL) ) | |
| { | |
| if ( pSVData->maWinData.mpFirstFloat ) | |
| { | |
| FloatingWindow* pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat(); | |
| pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL ); | |
| } | |
| } | |
| } | |
| mbInCleanUp = sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::EndPopupMode( sal_uInt16 nFlags ) | |
| { | |
| ImplEndPopupMode( nFlags ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::AddPopupModeWindow( Window* pWindow ) | |
| { | |
| // !!! bisher erst 1 Fenster und noch keine Liste | |
| mpFirstPopupModeWin = pWindow; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void FloatingWindow::RemovePopupModeWindow( Window* pWindow ) | |
| { | |
| // !!! bisher erst 1 Fenster und noch keine Liste | |
| if ( mpFirstPopupModeWin == pWindow ) | |
| mpFirstPopupModeWin = NULL; | |
| } |