| /************************************************************** |
| * |
| * 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 <tools/debug.hxx> |
| |
| #include <vcl/svapp.hxx> |
| #include <vcl/menu.hxx> |
| #include <vcl/sound.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/event.hxx> |
| #include <vcl/syswin.hxx> |
| #include <vcl/taskpanelist.hxx> |
| #include <vcl/unowrap.hxx> |
| |
| #include <salframe.hxx> |
| #include <svdata.hxx> |
| #include <brdwin.hxx> |
| #include <window.h> |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| |
| // ======================================================================= |
| class SystemWindow::ImplData |
| { |
| public: |
| ImplData(); |
| ~ImplData(); |
| |
| TaskPaneList* mpTaskPaneList; |
| Size maMaxOutSize; |
| rtl::OUString maRepresentedURL; |
| }; |
| |
| SystemWindow::ImplData::ImplData() |
| { |
| mpTaskPaneList = NULL; |
| maMaxOutSize = Size( SHRT_MAX, SHRT_MAX ); |
| } |
| |
| SystemWindow::ImplData::~ImplData() |
| { |
| if( mpTaskPaneList ) |
| delete mpTaskPaneList; |
| } |
| |
| // ======================================================================= |
| |
| SystemWindow::SystemWindow( WindowType nType ) : |
| Window( nType ) |
| { |
| mpImplData = new ImplData; |
| mpWindowImpl->mbSysWin = sal_True; |
| mpWindowImpl->mnActivateMode = ACTIVATE_MODE_GRABFOCUS; |
| |
| mpMenuBar = NULL; |
| mbPined = sal_False; |
| mbRollUp = sal_False; |
| mbRollFunc = sal_False; |
| mbDockBtn = sal_False; |
| mbHideBtn = sal_False; |
| mbSysChild = sal_False; |
| mnMenuBarMode = MENUBAR_MODE_NORMAL; |
| mnIcon = 0; |
| } |
| |
| SystemWindow::~SystemWindow() |
| { |
| delete mpImplData; |
| mpImplData = NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| long SystemWindow::Notify( NotifyEvent& rNEvt ) |
| { |
| // capture KeyEvents for menu handling |
| if ( rNEvt.GetType() == EVENT_KEYINPUT ) |
| { |
| MenuBar* pMBar = mpMenuBar; |
| if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) ) |
| { |
| Window* pWin = ImplGetFrameWindow()->ImplGetWindow(); |
| if( pWin && pWin->IsSystemWindow() ) |
| pMBar = ((SystemWindow*)pWin)->GetMenuBar(); |
| } |
| if ( pMBar && pMBar->ImplHandleKeyEvent( *rNEvt.GetKeyEvent(), sal_False ) ) |
| return sal_True; |
| } |
| |
| return Window::Notify( rNEvt ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| long SystemWindow::PreNotify( NotifyEvent& rNEvt ) |
| { |
| // capture KeyEvents for taskpane cycling |
| if ( rNEvt.GetType() == EVENT_KEYINPUT ) |
| { |
| if( rNEvt.GetKeyEvent()->GetKeyCode().GetCode() == KEY_F6 && |
| rNEvt.GetKeyEvent()->GetKeyCode().IsMod1() && |
| !rNEvt.GetKeyEvent()->GetKeyCode().IsShift() ) |
| { |
| // Ctrl-F6 goes directly to the document |
| GrabFocusToDocument(); |
| return sal_True; |
| } |
| else |
| { |
| TaskPaneList *pTList = mpImplData->mpTaskPaneList; |
| if( !pTList && ( GetType() == WINDOW_FLOATINGWINDOW ) ) |
| { |
| Window* pWin = ImplGetFrameWindow()->ImplGetWindow(); |
| if( pWin && pWin->IsSystemWindow() ) |
| pTList = ((SystemWindow*)pWin)->mpImplData->mpTaskPaneList; |
| } |
| if( !pTList ) |
| { |
| // search topmost system window which is the one to handle dialog/toolbar cycling |
| SystemWindow *pSysWin = this; |
| Window *pWin = this; |
| while( pWin ) |
| { |
| pWin = pWin->GetParent(); |
| if( pWin && pWin->IsSystemWindow() ) |
| pSysWin = (SystemWindow*) pWin; |
| } |
| pTList = pSysWin->mpImplData->mpTaskPaneList; |
| } |
| if( pTList && pTList->HandleKeyEvent( *rNEvt.GetKeyEvent() ) ) |
| return sal_True; |
| } |
| } |
| return Window::PreNotify( rNEvt ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| TaskPaneList* SystemWindow::GetTaskPaneList() |
| { |
| if( mpImplData->mpTaskPaneList ) |
| return mpImplData->mpTaskPaneList ; |
| else |
| { |
| mpImplData->mpTaskPaneList = new TaskPaneList(); |
| MenuBar* pMBar = mpMenuBar; |
| if ( !pMBar && ( GetType() == WINDOW_FLOATINGWINDOW ) ) |
| { |
| Window* pWin = ImplGetFrameWindow()->ImplGetWindow(); |
| if ( pWin && pWin->IsSystemWindow() ) |
| pMBar = ((SystemWindow*)pWin)->GetMenuBar(); |
| } |
| if( pMBar ) |
| mpImplData->mpTaskPaneList->AddWindow( pMBar->ImplGetWindow() ); |
| return mpImplData->mpTaskPaneList; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SystemWindow::Close() |
| { |
| ImplDelData aDelData; |
| ImplAddDel( &aDelData ); |
| ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE ); |
| if ( aDelData.IsDelete() ) |
| return sal_False; |
| ImplRemoveDel( &aDelData ); |
| |
| if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() ) |
| return sal_False; |
| |
| // Is Window not closeable, ignore close |
| Window* pBorderWin = ImplGetBorderWindow(); |
| WinBits nStyle; |
| if ( pBorderWin ) |
| nStyle = pBorderWin->GetStyle(); |
| else |
| nStyle = GetStyle(); |
| if ( !(nStyle & WB_CLOSEABLE) ) |
| { |
| Sound::Beep( SOUND_DISABLE, this ); |
| return sal_False; |
| } |
| |
| Hide(); |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::TitleButtonClick( sal_uInt16 ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::Pin() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::Roll() |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::Resizing( Size& ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetZLevel( sal_uInt8 nLevel ) |
| { |
| Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| if ( pWindow->mpWindowImpl->mbOverlapWin && !pWindow->mpWindowImpl->mbFrame ) |
| { |
| sal_uInt8 nOldLevel = pWindow->mpWindowImpl->mpOverlapData->mnTopLevel; |
| pWindow->mpWindowImpl->mpOverlapData->mnTopLevel = nLevel; |
| // Wenn der neue Level groesser als der alte ist, schieben |
| // wir das Fenster nach hinten |
| if ( !IsReallyVisible() && (nLevel > nOldLevel) && pWindow->mpWindowImpl->mpNext ) |
| { |
| // Fenster aus der Liste entfernen |
| if ( pWindow->mpWindowImpl->mpPrev ) |
| pWindow->mpWindowImpl->mpPrev->mpWindowImpl->mpNext = pWindow->mpWindowImpl->mpNext; |
| else |
| pWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpFirstOverlap = pWindow->mpWindowImpl->mpNext; |
| pWindow->mpWindowImpl->mpNext->mpWindowImpl->mpPrev = pWindow->mpWindowImpl->mpPrev; |
| pWindow->mpWindowImpl->mpNext = NULL; |
| // und Fenster wieder in die Liste am Ende eintragen |
| pWindow->mpWindowImpl->mpPrev = pWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap; |
| pWindow->mpWindowImpl->mpOverlapWindow->mpWindowImpl->mpLastOverlap = pWindow; |
| pWindow->mpWindowImpl->mpPrev->mpWindowImpl->mpNext = pWindow; |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetRepresentedURL( const rtl::OUString& i_rURL ) |
| { |
| bool bChanged = (i_rURL != mpImplData->maRepresentedURL); |
| mpImplData->maRepresentedURL = i_rURL; |
| if ( !mbSysChild && bChanged ) |
| { |
| const Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| |
| if ( pWindow->mpWindowImpl->mbFrame ) |
| pWindow->mpWindowImpl->mpFrame->SetRepresentedURL( i_rURL ); |
| } |
| } |
| // ----------------------------------------------------------------------- |
| |
| const rtl::OUString& SystemWindow::GetRepresentedURL() const |
| { |
| return mpImplData->maRepresentedURL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetIcon( sal_uInt16 nIcon ) |
| { |
| if ( mnIcon == nIcon ) |
| return; |
| |
| mnIcon = nIcon; |
| |
| if ( !mbSysChild ) |
| { |
| const Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| |
| if ( pWindow->mpWindowImpl->mbFrame ) |
| pWindow->mpWindowImpl->mpFrame->SetIcon( nIcon ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt8 SystemWindow::GetZLevel() const |
| { |
| const Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| if ( pWindow->mpWindowImpl->mpOverlapData ) |
| return pWindow->mpWindowImpl->mpOverlapData->mnTopLevel; |
| else |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::EnableSaveBackground( sal_Bool bSave ) |
| { |
| if( ImplGetSVData()->maWinData.mbNoSaveBackground ) |
| bSave = false; |
| |
| Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| if ( pWindow->mpWindowImpl->mbOverlapWin && !pWindow->mpWindowImpl->mbFrame ) |
| { |
| pWindow->mpWindowImpl->mpOverlapData->mbSaveBack = bSave; |
| if ( !bSave ) |
| pWindow->ImplDeleteOverlapBackground(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SystemWindow::IsSaveBackgroundEnabled() const |
| { |
| const Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| if ( pWindow->mpWindowImpl->mpOverlapData ) |
| return pWindow->mpWindowImpl->mpOverlapData->mbSaveBack; |
| else |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::ShowTitleButton( sal_uInt16 nButton, sal_Bool bVisible ) |
| { |
| if ( nButton == TITLE_BUTTON_DOCKING ) |
| { |
| if ( mbDockBtn != bVisible ) |
| { |
| mbDockBtn = bVisible; |
| if ( mpWindowImpl->mpBorderWindow ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetDockButton( bVisible ); |
| } |
| } |
| else if ( nButton == TITLE_BUTTON_HIDE ) |
| { |
| if ( mbHideBtn != bVisible ) |
| { |
| mbHideBtn = bVisible; |
| if ( mpWindowImpl->mpBorderWindow ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetHideButton( bVisible ); |
| } |
| } |
| else if ( nButton == TITLE_BUTTON_MENU ) |
| { |
| if ( mpWindowImpl->mpBorderWindow ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuButton( bVisible ); |
| } |
| else |
| return; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SystemWindow::IsTitleButtonVisible( sal_uInt16 nButton ) const |
| { |
| if ( nButton == TITLE_BUTTON_DOCKING ) |
| return mbDockBtn; |
| else /* if ( nButton == TITLE_BUTTON_HIDE ) */ |
| return mbHideBtn; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetPin( sal_Bool bPin ) |
| { |
| if ( bPin != mbPined ) |
| { |
| mbPined = bPin; |
| if ( mpWindowImpl->mpBorderWindow ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetPin( bPin ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::RollUp() |
| { |
| if ( !mbRollUp ) |
| { |
| maOrgSize = GetOutputSizePixel(); |
| mbRollFunc = sal_True; |
| Size aSize = maRollUpOutSize; |
| if ( !aSize.Width() ) |
| aSize.Width() = GetOutputSizePixel().Width(); |
| mbRollUp = sal_True; |
| if ( mpWindowImpl->mpBorderWindow ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetRollUp( sal_True, aSize ); |
| else |
| SetOutputSizePixel( aSize ); |
| mbRollFunc = sal_False; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::RollDown() |
| { |
| if ( mbRollUp ) |
| { |
| mbRollUp = sal_False; |
| if ( mpWindowImpl->mpBorderWindow ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetRollUp( sal_False, maOrgSize ); |
| else |
| SetOutputSizePixel( maOrgSize ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetMinOutputSizePixel( const Size& rSize ) |
| { |
| maMinOutSize = rSize; |
| if ( mpWindowImpl->mpBorderWindow ) |
| { |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMinOutputSize( rSize.Width(), rSize.Height() ); |
| if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame ) |
| mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() ); |
| } |
| else if ( mpWindowImpl->mbFrame ) |
| mpWindowImpl->mpFrame->SetMinClientSize( rSize.Width(), rSize.Height() ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetMaxOutputSizePixel( const Size& rSize ) |
| { |
| Size aSize( rSize ); |
| if( aSize.Width() > SHRT_MAX || aSize.Width() <= 0 ) |
| aSize.Width() = SHRT_MAX; |
| if( aSize.Height() > SHRT_MAX || aSize.Height() <= 0 ) |
| aSize.Height() = SHRT_MAX; |
| |
| mpImplData->maMaxOutSize = aSize; |
| if ( mpWindowImpl->mpBorderWindow ) |
| { |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMaxOutputSize( aSize.Width(), aSize.Height() ); |
| if ( mpWindowImpl->mpBorderWindow->mpWindowImpl->mbFrame ) |
| mpWindowImpl->mpBorderWindow->mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() ); |
| } |
| else if ( mpWindowImpl->mbFrame ) |
| mpWindowImpl->mpFrame->SetMaxClientSize( aSize.Width(), aSize.Height() ); |
| } |
| |
| const Size& SystemWindow::GetMaxOutputSizePixel() const |
| { |
| return mpImplData->maMaxOutSize; |
| } |
| // ----------------------------------------------------------------------- |
| |
| Size SystemWindow::GetResizeOutputSizePixel() const |
| { |
| Size aSize = GetOutputSizePixel(); |
| if ( aSize.Width() < maMinOutSize.Width() ) |
| aSize.Width() = maMinOutSize.Width(); |
| if ( aSize.Height() < maMinOutSize.Height() ) |
| aSize.Height() = maMinOutSize.Height(); |
| return aSize; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplWindowStateFromStr( WindowStateData& rData, const ByteString& rStr ) |
| { |
| sal_uLong nValidMask = 0; |
| xub_StrLen nIndex = 0; |
| ByteString aTokenStr; |
| |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetX( aTokenStr.ToInt32() ); |
| if( rData.GetX() > -16384 && rData.GetX() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_X; |
| else |
| rData.SetX( 0 ); |
| } |
| else |
| rData.SetX( 0 ); |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetY( aTokenStr.ToInt32() ); |
| if( rData.GetY() > -16384 && rData.GetY() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_Y; |
| else |
| rData.SetY( 0 ); |
| } |
| else |
| rData.SetY( 0 ); |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetWidth( aTokenStr.ToInt32() ); |
| if( rData.GetWidth() > 0 && rData.GetWidth() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_WIDTH; |
| else |
| rData.SetWidth( 0 ); |
| } |
| else |
| rData.SetWidth( 0 ); |
| aTokenStr = rStr.GetToken( 0, ';', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetHeight( aTokenStr.ToInt32() ); |
| if( rData.GetHeight() > 0 && rData.GetHeight() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_HEIGHT; |
| else |
| rData.SetHeight( 0 ); |
| } |
| else |
| rData.SetHeight( 0 ); |
| aTokenStr = rStr.GetToken( 0, ';', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| // #94144# allow Minimize again, should be masked out when read from configuration |
| // 91625 - ignore Minimize |
| sal_uLong nState = (sal_uLong)aTokenStr.ToInt32(); |
| //nState &= ~(WINDOWSTATE_STATE_MINIMIZED); |
| rData.SetState( nState ); |
| nValidMask |= WINDOWSTATE_MASK_STATE; |
| } |
| else |
| rData.SetState( 0 ); |
| |
| // read maximized pos/size |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetMaximizedX( aTokenStr.ToInt32() ); |
| if( rData.GetMaximizedX() > -16384 && rData.GetMaximizedX() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X; |
| else |
| rData.SetMaximizedX( 0 ); |
| } |
| else |
| rData.SetMaximizedX( 0 ); |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetMaximizedY( aTokenStr.ToInt32() ); |
| if( rData.GetMaximizedY() > -16384 && rData.GetMaximizedY() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y; |
| else |
| rData.SetMaximizedY( 0 ); |
| } |
| else |
| rData.SetMaximizedY( 0 ); |
| aTokenStr = rStr.GetToken( 0, ',', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetMaximizedWidth( aTokenStr.ToInt32() ); |
| if( rData.GetMaximizedWidth() > 0 && rData.GetMaximizedWidth() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH; |
| else |
| rData.SetMaximizedWidth( 0 ); |
| } |
| else |
| rData.SetMaximizedWidth( 0 ); |
| aTokenStr = rStr.GetToken( 0, ';', nIndex ); |
| if ( aTokenStr.Len() ) |
| { |
| rData.SetMaximizedHeight( aTokenStr.ToInt32() ); |
| if( rData.GetMaximizedHeight() > 0 && rData.GetMaximizedHeight() < 16384 ) |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT; |
| else |
| rData.SetMaximizedHeight( 0 ); |
| } |
| else |
| rData.SetMaximizedHeight( 0 ); |
| |
| // mark valid fields |
| rData.SetMask( nValidMask ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplWindowStateToStr( const WindowStateData& rData, ByteString& rStr ) |
| { |
| sal_uLong nValidMask = rData.GetMask(); |
| if ( !nValidMask ) |
| return; |
| |
| if ( nValidMask & WINDOWSTATE_MASK_X ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetX() ) ); |
| rStr.Append( ',' ); |
| if ( nValidMask & WINDOWSTATE_MASK_Y ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetY() ) ); |
| rStr.Append( ',' ); |
| if ( nValidMask & WINDOWSTATE_MASK_WIDTH ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetWidth() ) ); |
| rStr.Append( ',' ); |
| if ( nValidMask & WINDOWSTATE_MASK_HEIGHT ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetHeight() ) ); |
| rStr.Append( ';' ); |
| if ( nValidMask & WINDOWSTATE_MASK_STATE ) |
| { |
| // #94144# allow Minimize again, should be masked out when read from configuration |
| // 91625 - ignore Minimize |
| sal_uLong nState = rData.GetState(); |
| //nState &= ~(WINDOWSTATE_STATE_MINIMIZED); |
| rStr.Append( ByteString::CreateFromInt32( (long)nState ) ); |
| } |
| rStr.Append( ';' ); |
| if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_X ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedX() ) ); |
| rStr.Append( ',' ); |
| if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_Y ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedY() ) ); |
| rStr.Append( ',' ); |
| if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_WIDTH ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedWidth() ) ); |
| rStr.Append( ',' ); |
| if ( nValidMask & WINDOWSTATE_MASK_MAXIMIZED_HEIGHT ) |
| rStr.Append( ByteString::CreateFromInt32( rData.GetMaximizedHeight() ) ); |
| rStr.Append( ';' ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::ImplMoveToScreen( long& io_rX, long& io_rY, long i_nWidth, long i_nHeight, Window* i_pConfigureWin ) |
| { |
| Rectangle aScreenRect; |
| if( Application::IsMultiDisplay() ) |
| { |
| aScreenRect = Application::GetScreenPosSizePixel( GetScreenNumber() ); |
| } |
| else |
| { |
| aScreenRect = Application::GetScreenPosSizePixel( 0 ); |
| for( unsigned int i = 1; i < Application::GetScreenCount(); i++ ) |
| aScreenRect.Union( Application::GetScreenPosSizePixel( i ) ); |
| } |
| // unfortunately most of the time width and height are not really known |
| if( i_nWidth < 1 ) |
| i_nWidth = 50; |
| if( i_nHeight < 1 ) |
| i_nHeight = 50; |
| |
| // check left border |
| bool bMove = false; |
| if( io_rX + i_nWidth < aScreenRect.Left() ) |
| { |
| bMove = true; |
| io_rX = aScreenRect.Left(); |
| } |
| // check right border |
| if( io_rX > aScreenRect.Right() - i_nWidth ) |
| { |
| bMove = true; |
| io_rX = aScreenRect.Right() - i_nWidth; |
| } |
| // check top border |
| if( io_rY + i_nHeight < aScreenRect.Top() ) |
| { |
| bMove = true; |
| io_rY = aScreenRect.Top(); |
| } |
| // check bottom border |
| if( io_rY > aScreenRect.Bottom() - i_nHeight ) |
| { |
| bMove = true; |
| io_rY = aScreenRect.Bottom() - i_nHeight; |
| } |
| Window* pParent = i_pConfigureWin->GetParent(); |
| if( bMove && pParent ) |
| { |
| // calculate absolute screen pos here, since that is what is contained in WindowState |
| Point aParentAbsPos( pParent->OutputToAbsoluteScreenPixel( Point(0,0) ) ); |
| Size aParentSizePixel( pParent->GetOutputSizePixel() ); |
| Point aPos( (aParentSizePixel.Width() - i_nWidth) / 2, |
| (aParentSizePixel.Height() - i_nHeight) / 2 ); |
| io_rX = aParentAbsPos.X() + aPos.X(); |
| io_rY = aParentAbsPos.Y() + aPos.Y(); |
| } |
| } |
| |
| void SystemWindow::SetWindowStateData( const WindowStateData& rData ) |
| { |
| sal_uLong nValidMask = rData.GetMask(); |
| if ( !nValidMask ) |
| return; |
| |
| if ( mbSysChild ) |
| return; |
| |
| Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| |
| if ( pWindow->mpWindowImpl->mbFrame ) |
| { |
| sal_uLong nState = rData.GetState(); |
| SalFrameState aState; |
| aState.mnMask = rData.GetMask(); |
| aState.mnX = rData.GetX(); |
| aState.mnY = rData.GetY(); |
| aState.mnWidth = rData.GetWidth(); |
| aState.mnHeight = rData.GetHeight(); |
| |
| if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) ) |
| { |
| // #i43799# adjust window state sizes if a minimial output size was set |
| // otherwise the frame and the client might get different sizes |
| if( maMinOutSize.Width() > aState.mnWidth ) |
| aState.mnWidth = maMinOutSize.Width(); |
| if( maMinOutSize.Height() > aState.mnHeight ) |
| aState.mnHeight = maMinOutSize.Height(); |
| } |
| |
| aState.mnMaximizedX = rData.GetMaximizedX(); |
| aState.mnMaximizedY = rData.GetMaximizedY(); |
| aState.mnMaximizedWidth = rData.GetMaximizedWidth(); |
| aState.mnMaximizedHeight = rData.GetMaximizedHeight(); |
| // #94144# allow Minimize again, should be masked out when read from configuration |
| // 91625 - ignore Minimize |
| //nState &= ~(WINDOWSTATE_STATE_MINIMIZED); |
| aState.mnState = nState & SAL_FRAMESTATE_SYSTEMMASK; |
| |
| // normalize window positions onto screen |
| ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow ); |
| ImplMoveToScreen( aState.mnMaximizedX, aState.mnMaximizedY, aState.mnMaximizedWidth, aState.mnMaximizedHeight, pWindow ); |
| |
| // #96568# avoid having multiple frames at the same screen location |
| // do the check only if not maximized |
| if( !((rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) ) |
| if( rData.GetMask() & (WINDOWSTATE_MASK_POS|WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) ) |
| { |
| Rectangle aDesktop = GetDesktopRectPixel(); |
| ImplSVData *pSVData = ImplGetSVData(); |
| Window *pWin = pSVData->maWinData.mpFirstFrame; |
| sal_Bool bWrapped = sal_False; |
| while( pWin ) |
| { |
| if( !pWin->ImplIsRealParentPath( this ) && ( pWin != this ) && |
| pWin->ImplGetWindow()->IsTopWindow() && pWin->mpWindowImpl->mbReallyVisible ) |
| { |
| SalFrameGeometry g = pWin->mpWindowImpl->mpFrame->GetGeometry(); |
| if( abs(g.nX-aState.mnX) < 2 && abs(g.nY-aState.mnY) < 5 ) |
| { |
| long displacement = g.nTopDecoration ? g.nTopDecoration : 20; |
| if( (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.nRight || |
| (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.nBottom ) |
| { |
| // displacing would leave screen |
| aState.mnX = g.nLeftDecoration ? g.nLeftDecoration : 10; // should result in (0,0) |
| aState.mnY = displacement; |
| if( bWrapped || |
| (unsigned long) (aState.mnX + displacement + aState.mnWidth + g.nRightDecoration) > (unsigned long) aDesktop.nRight || |
| (unsigned long) (aState.mnY + displacement + aState.mnHeight + g.nBottomDecoration) > (unsigned long) aDesktop.nBottom ) |
| break; // further displacement not possible -> break |
| // avoid endless testing |
| bWrapped = sal_True; |
| } |
| else |
| { |
| // displace |
| aState.mnX += displacement; |
| aState.mnY += displacement; |
| } |
| pWin = pSVData->maWinData.mpFirstFrame; // check new pos again |
| } |
| } |
| pWin = pWin->mpWindowImpl->mpFrameData->mpNextFrame; |
| } |
| } |
| |
| mpWindowImpl->mpFrame->SetWindowState( &aState ); |
| |
| // do a synchronous resize for layout reasons |
| // but use rData only when the window is not to be maximized (#i38089#) |
| // otherwise we have no useful size information |
| if( (rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED) ) |
| { |
| // query maximized size from frame |
| SalFrameGeometry aGeometry = mpWindowImpl->mpFrame->GetGeometry(); |
| |
| // but use it only if it is different from the restore size (rData) |
| // as currently only on windows the exact size of a maximized window |
| // can be computed without actually showing the window |
| if( aGeometry.nWidth != rData.GetWidth() || aGeometry.nHeight != rData.GetHeight() ) |
| ImplHandleResize( pWindow, aGeometry.nWidth, aGeometry.nHeight ); |
| } |
| else |
| if( rData.GetMask() & (WINDOWSTATE_MASK_WIDTH|WINDOWSTATE_MASK_HEIGHT) ) |
| ImplHandleResize( pWindow, aState.mnWidth, aState.mnHeight ); // #i43799# use aState and not rData, see above |
| } |
| else |
| { |
| sal_uInt16 nPosSize = 0; |
| if ( nValidMask & WINDOWSTATE_MASK_X ) |
| nPosSize |= WINDOW_POSSIZE_X; |
| if ( nValidMask & WINDOWSTATE_MASK_Y ) |
| nPosSize |= WINDOW_POSSIZE_Y; |
| if ( nValidMask & WINDOWSTATE_MASK_WIDTH ) |
| nPosSize |= WINDOW_POSSIZE_WIDTH; |
| if ( nValidMask & WINDOWSTATE_MASK_HEIGHT ) |
| nPosSize |= WINDOW_POSSIZE_HEIGHT; |
| |
| if( IsRollUp() ) |
| RollDown(); |
| |
| long nX = rData.GetX(); |
| long nY = rData.GetY(); |
| long nWidth = rData.GetWidth(); |
| long nHeight = rData.GetHeight(); |
| const SalFrameGeometry& rGeom = pWindow->mpWindowImpl->mpFrame->GetGeometry(); |
| if( nX < 0 ) |
| nX = 0; |
| if( nX + nWidth > (long) rGeom.nWidth ) |
| nX = rGeom.nWidth - nWidth; |
| if( nY < 0 ) |
| nY = 0; |
| if( nY + nHeight > (long) rGeom.nHeight ) |
| nY = rGeom.nHeight - nHeight; |
| SetPosSizePixel( nX, nY, nWidth, nHeight, nPosSize ); |
| maOrgSize = Size( nWidth, nHeight ); |
| |
| // 91625 - ignore Minimize |
| if ( nValidMask & WINDOWSTATE_MASK_STATE ) |
| { |
| sal_uLong nState = rData.GetState(); |
| if ( nState & WINDOWSTATE_STATE_ROLLUP ) |
| RollUp(); |
| else |
| RollDown(); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::GetWindowStateData( WindowStateData& rData ) const |
| { |
| sal_uLong nValidMask = rData.GetMask(); |
| if ( !nValidMask ) |
| return; |
| |
| if ( mbSysChild ) |
| return; |
| |
| const Window* pWindow = this; |
| while ( pWindow->mpWindowImpl->mpBorderWindow ) |
| pWindow = pWindow->mpWindowImpl->mpBorderWindow; |
| |
| if ( pWindow->mpWindowImpl->mbFrame ) |
| { |
| SalFrameState aState; |
| aState.mnMask = 0xFFFFFFFF; |
| if ( mpWindowImpl->mpFrame->GetWindowState( &aState ) ) |
| { |
| if ( nValidMask & WINDOWSTATE_MASK_X ) |
| rData.SetX( aState.mnX ); |
| if ( nValidMask & WINDOWSTATE_MASK_Y ) |
| rData.SetY( aState.mnY ); |
| if ( nValidMask & WINDOWSTATE_MASK_WIDTH ) |
| rData.SetWidth( aState.mnWidth ); |
| if ( nValidMask & WINDOWSTATE_MASK_HEIGHT ) |
| rData.SetHeight( aState.mnHeight ); |
| if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_X ) |
| { |
| rData.SetMaximizedX( aState.mnMaximizedX ); |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_X; |
| } |
| if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_Y ) |
| { |
| rData.SetMaximizedY( aState.mnMaximizedY ); |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_Y; |
| } |
| if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH ) |
| { |
| rData.SetMaximizedWidth( aState.mnMaximizedWidth ); |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_WIDTH; |
| } |
| if ( aState.mnMask & SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT ) |
| { |
| rData.SetMaximizedHeight( aState.mnMaximizedHeight ); |
| nValidMask |= WINDOWSTATE_MASK_MAXIMIZED_HEIGHT; |
| } |
| if ( nValidMask & WINDOWSTATE_MASK_STATE ) |
| { |
| // #94144# allow Minimize again, should be masked out when read from configuration |
| // 91625 - ignore Minimize |
| if ( !(nValidMask&WINDOWSTATE_MASK_MINIMIZED) ) |
| aState.mnState &= ~(WINDOWSTATE_STATE_MINIMIZED); |
| rData.SetState( aState.mnState ); |
| } |
| rData.SetMask( nValidMask ); |
| } |
| else |
| rData.SetMask( 0 ); |
| } |
| else |
| { |
| Point aPos = GetPosPixel(); |
| Size aSize = GetSizePixel(); |
| sal_uLong nState = 0; |
| |
| if ( IsRollUp() ) |
| { |
| aSize.Height() += maOrgSize.Height(); |
| nState |= WINDOWSTATE_STATE_ROLLUP; |
| } |
| |
| if ( nValidMask & WINDOWSTATE_MASK_X ) |
| rData.SetX( aPos.X() ); |
| if ( nValidMask & WINDOWSTATE_MASK_Y ) |
| rData.SetY( aPos.Y() ); |
| if ( nValidMask & WINDOWSTATE_MASK_WIDTH ) |
| rData.SetWidth( aSize.Width() ); |
| if ( nValidMask & WINDOWSTATE_MASK_HEIGHT ) |
| rData.SetHeight( aSize.Height() ); |
| if ( nValidMask & WINDOWSTATE_MASK_STATE ) |
| rData.SetState( nState ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetWindowState( const ByteString& rStr ) |
| { |
| if ( !rStr.Len() ) |
| return; |
| |
| WindowStateData aData; |
| ImplWindowStateFromStr( aData, rStr ); |
| SetWindowStateData( aData ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| ByteString SystemWindow::GetWindowState( sal_uLong nMask ) const |
| { |
| WindowStateData aData; |
| aData.SetMask( nMask ); |
| GetWindowStateData( aData ); |
| |
| ByteString aStr; |
| ImplWindowStateToStr( aData, aStr ); |
| return aStr; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetMenuBar( MenuBar* pMenuBar ) |
| { |
| if ( mpMenuBar != pMenuBar ) |
| { |
| MenuBar* pOldMenuBar = mpMenuBar; |
| Window* pOldWindow = NULL; |
| Window* pNewWindow=NULL; |
| mpMenuBar = pMenuBar; |
| |
| if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) ) |
| { |
| if ( pOldMenuBar ) |
| pOldWindow = pOldMenuBar->ImplGetWindow(); |
| else |
| pOldWindow = NULL; |
| if ( pOldWindow ) |
| { |
| ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARREMOVED, (void*) pOldMenuBar ); |
| pOldWindow->SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >() ); |
| } |
| if ( pMenuBar ) |
| { |
| DBG_ASSERT( !pMenuBar->pWindow, "SystemWindow::SetMenuBar() - MenuBars can only set in one SystemWindow at time" ); |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( pNewWindow = MenuBar::ImplCreate( mpWindowImpl->mpBorderWindow, pOldWindow, pMenuBar ) ); |
| ImplCallEventListeners( VCLEVENT_WINDOW_MENUBARADDED, (void*) pMenuBar ); |
| } |
| else |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarWindow( NULL ); |
| ImplToBottomChild(); |
| if ( pOldMenuBar ) |
| { |
| sal_Bool bDelete = (pMenuBar == 0) ? sal_True : sal_False; |
| if( bDelete && pOldWindow ) |
| { |
| if( mpImplData->mpTaskPaneList ) |
| mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow ); |
| } |
| MenuBar::ImplDestroy( pOldMenuBar, bDelete ); |
| if( bDelete ) |
| pOldWindow = NULL; // will be deleted in MenuBar::ImplDestroy, |
| } |
| |
| } |
| else |
| { |
| if( pMenuBar ) |
| pNewWindow = pMenuBar->ImplGetWindow(); |
| if( pOldMenuBar ) |
| pOldWindow = pOldMenuBar->ImplGetWindow(); |
| } |
| |
| // update taskpane list to make menubar accessible |
| if( mpImplData->mpTaskPaneList ) |
| { |
| if( pOldWindow ) |
| mpImplData->mpTaskPaneList->RemoveWindow( pOldWindow ); |
| if( pNewWindow ) |
| mpImplData->mpTaskPaneList->AddWindow( pNewWindow ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetMenuBarMode( sal_uInt16 nMode ) |
| { |
| if ( mnMenuBarMode != nMode ) |
| { |
| mnMenuBarMode = nMode; |
| if ( mpWindowImpl->mpBorderWindow && (mpWindowImpl->mpBorderWindow->GetType() == WINDOW_BORDERWINDOW) ) |
| { |
| if ( nMode == MENUBAR_MODE_HIDE ) |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarMode( sal_True ); |
| else |
| ((ImplBorderWindow*)mpWindowImpl->mpBorderWindow)->SetMenuBarMode( sal_False ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SystemWindow::ImplIsInTaskPaneList( Window* pWin ) |
| { |
| if( mpImplData && mpImplData->mpTaskPaneList ) |
| return mpImplData->mpTaskPaneList->IsInList( pWin ); |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| unsigned int SystemWindow::GetScreenNumber() const |
| { |
| return mpWindowImpl->mpFrame->maGeometry.nScreenNumber; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SystemWindow::SetScreenNumber( unsigned int nScreen) |
| { |
| mpWindowImpl->mpFrame->SetScreenNumber( nScreen ); |
| } |
