/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // ======================================================================= DBG_NAMEEX( Window ) // ======================================================================= #define IMPL_MAXSAVEBACKSIZE (640*480) #define IMPL_MAXALLSAVEBACKSIZE (800*600*2) // ======================================================================= struct ImplFocusDelData : public ImplDelData { Window* mpFocusWin; }; // ======================================================================= sal_Bool Window::ImplIsWindowInFront( const Window* pTestWindow ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); DBG_CHKOBJ( pTestWindow, Window, ImplDbgCheckWindow ); // Testen, ob es Fenster untereinander liegen pTestWindow = pTestWindow->ImplGetFirstOverlapWindow(); const Window* pTempWindow = pTestWindow; const Window* pThisWindow = ImplGetFirstOverlapWindow(); if ( pTempWindow == pThisWindow ) return sal_False; do { if ( pTempWindow == pThisWindow ) return sal_True; if ( pTempWindow->mpWindowImpl->mbFrame ) break; pTempWindow = pTempWindow->mpWindowImpl->mpOverlapWindow; } while ( pTempWindow ); pTempWindow = pThisWindow; do { if ( pTempWindow == pTestWindow ) return sal_False; if ( pTempWindow->mpWindowImpl->mbFrame ) break; pTempWindow = pTempWindow->mpWindowImpl->mpOverlapWindow; } while ( pTempWindow ); // Fenster auf gleiche Ebene bringen if ( pThisWindow->mpWindowImpl->mpOverlapWindow != pTestWindow->mpWindowImpl->mpOverlapWindow ) { sal_uInt16 nThisLevel = 0; sal_uInt16 nTestLevel = 0; pTempWindow = pThisWindow; do { nThisLevel++; pTempWindow = pTempWindow->mpWindowImpl->mpOverlapWindow; } while ( !pTempWindow->mpWindowImpl->mbFrame ); pTempWindow = pTestWindow; do { nTestLevel++; pTempWindow = pTempWindow->mpWindowImpl->mpOverlapWindow; } while ( !pTempWindow->mpWindowImpl->mbFrame ); if ( nThisLevel < nTestLevel ) { do { if ( pTestWindow->mpWindowImpl->mpOverlapWindow == pThisWindow->mpWindowImpl->mpOverlapWindow ) break; if ( pTestWindow->mpWindowImpl->mbFrame ) break; pTestWindow = pTestWindow->mpWindowImpl->mpOverlapWindow; } while ( pTestWindow ); } else { do { if ( pThisWindow->mpWindowImpl->mpOverlapWindow == pTempWindow->mpWindowImpl->mpOverlapWindow ) break; if ( pThisWindow->mpWindowImpl->mbFrame ) break; pThisWindow = pThisWindow->mpWindowImpl->mpOverlapWindow; } while ( pThisWindow ); } } // Wenn TestWindow vor ThisWindow kommt, liegt es vorne pTempWindow = pTestWindow; do { if ( pTempWindow == pThisWindow ) return sal_True; pTempWindow = pTempWindow->mpWindowImpl->mpNext; } while ( pTempWindow ); return sal_False; } // ======================================================================= void Window::ImplSaveOverlapBackground() { DBG_ASSERT( !mpWindowImpl->mpOverlapData->mpSaveBackDev, "Window::ImplSaveOverlapBackground() - Background already saved" ); if ( !mpWindowImpl->mbFrame ) { sal_uLong nSaveBackSize = mnOutWidth*mnOutHeight; if ( nSaveBackSize <= IMPL_MAXSAVEBACKSIZE ) { if ( nSaveBackSize+mpWindowImpl->mpFrameData->mnAllSaveBackSize <= IMPL_MAXALLSAVEBACKSIZE ) { Size aOutSize( mnOutWidth, mnOutHeight ); mpWindowImpl->mpOverlapData->mpSaveBackDev = new VirtualDevice( *mpWindowImpl->mpFrameWindow ); if ( mpWindowImpl->mpOverlapData->mpSaveBackDev->SetOutputSizePixel( aOutSize ) ) { mpWindowImpl->mpFrameWindow->ImplUpdateAll(); if ( mpWindowImpl->mbInitWinClipRegion ) ImplInitWinClipRegion(); mpWindowImpl->mpOverlapData->mnSaveBackSize = nSaveBackSize; mpWindowImpl->mpFrameData->mnAllSaveBackSize += nSaveBackSize; Point aDevPt; mpWindowImpl->mpFrameWindow->ImplGetFrameDev( Point( mnOutOffX, mnOutOffY ), aDevPt, aOutSize, *(mpWindowImpl->mpOverlapData->mpSaveBackDev) ); mpWindowImpl->mpOverlapData->mpNextBackWin = mpWindowImpl->mpFrameData->mpFirstBackWin; mpWindowImpl->mpFrameData->mpFirstBackWin = this; } else { delete mpWindowImpl->mpOverlapData->mpSaveBackDev; mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL; } } } } } // ----------------------------------------------------------------------- sal_Bool Window::ImplRestoreOverlapBackground( Region& rInvRegion ) { if ( mpWindowImpl->mpOverlapData->mpSaveBackDev ) { if ( mpWindowImpl->mbInitWinClipRegion ) ImplInitWinClipRegion(); if ( mpWindowImpl->mpOverlapData->mpSaveBackDev ) { Point aDevPt; Point aDestPt( mnOutOffX, mnOutOffY ); Size aDevSize = mpWindowImpl->mpOverlapData->mpSaveBackDev->GetOutputSizePixel(); if ( mpWindowImpl->mpOverlapData->mpSaveBackRgn ) { mpWindowImpl->mpOverlapData->mpSaveBackRgn->Intersect( mpWindowImpl->maWinClipRegion ); rInvRegion = mpWindowImpl->maWinClipRegion; rInvRegion.Exclude( *mpWindowImpl->mpOverlapData->mpSaveBackRgn ); mpWindowImpl->mpFrameWindow->ImplDrawFrameDev( aDestPt, aDevPt, aDevSize, *(mpWindowImpl->mpOverlapData->mpSaveBackDev), *mpWindowImpl->mpOverlapData->mpSaveBackRgn ); } else { mpWindowImpl->mpFrameWindow->ImplDrawFrameDev( aDestPt, aDevPt, aDevSize, *(mpWindowImpl->mpOverlapData->mpSaveBackDev), mpWindowImpl->maWinClipRegion ); } ImplDeleteOverlapBackground(); } return sal_True; } return sal_False; } // ----------------------------------------------------------------------- void Window::ImplDeleteOverlapBackground() { if ( mpWindowImpl->mpOverlapData->mpSaveBackDev ) { mpWindowImpl->mpFrameData->mnAllSaveBackSize -= mpWindowImpl->mpOverlapData->mnSaveBackSize; delete mpWindowImpl->mpOverlapData->mpSaveBackDev; mpWindowImpl->mpOverlapData->mpSaveBackDev = NULL; if ( mpWindowImpl->mpOverlapData->mpSaveBackRgn ) { delete mpWindowImpl->mpOverlapData->mpSaveBackRgn; mpWindowImpl->mpOverlapData->mpSaveBackRgn = NULL; } // Fenster aus der Liste entfernen if ( mpWindowImpl->mpFrameData->mpFirstBackWin == this ) mpWindowImpl->mpFrameData->mpFirstBackWin = mpWindowImpl->mpOverlapData->mpNextBackWin; else { Window* pTemp = mpWindowImpl->mpFrameData->mpFirstBackWin; while ( pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin != this ) pTemp = pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin; pTemp->mpWindowImpl->mpOverlapData->mpNextBackWin = mpWindowImpl->mpOverlapData->mpNextBackWin; } mpWindowImpl->mpOverlapData->mpNextBackWin = NULL; } } // ----------------------------------------------------------------------- void Window::ImplInvalidateAllOverlapBackgrounds() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); Window* pWindow = mpWindowImpl->mpFrameData->mpFirstBackWin; while ( pWindow ) { // Naechstes Fenster schon hier merken, da dieses Fenster in // der if-Abfrage aus der Liste entfernt werden kann Window* pNext = pWindow->mpWindowImpl->mpOverlapData->mpNextBackWin; if ( ImplIsWindowInFront( pWindow ) ) { Rectangle aRect1( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) ); Rectangle aRect2( Point( pWindow->mnOutOffX, pWindow->mnOutOffY ), Size( pWindow->mnOutWidth, pWindow->mnOutHeight ) ); aRect1.Intersection( aRect2 ); if ( !aRect1.IsEmpty() ) { if ( !pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn ) pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn = new Region( aRect2 ); pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->Exclude( aRect1 ); if ( pWindow->mpWindowImpl->mpOverlapData->mpSaveBackRgn->IsEmpty() ) pWindow->ImplDeleteOverlapBackground(); } } pWindow = pNext; } } // ======================================================================= Bitmap Window::SnapShot( sal_Bool bBorder ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); Bitmap aBmp; if ( IsReallyVisible() ) { if ( bBorder && mpWindowImpl->mpBorderWindow ) aBmp = mpWindowImpl->mpBorderWindow->SnapShot(); else { ((Window*)this)->Update(); if ( bBorder && mpWindowImpl->mbFrame ) { SalBitmap* pSalBmp = mpWindowImpl->mpFrame->SnapShot(); if ( pSalBmp ) { ImpBitmap* pImpBmp = new ImpBitmap; pImpBmp->ImplSetSalBitmap( pSalBmp ); aBmp.ImplSetImpBitmap( pImpBmp ); return aBmp; } } mpWindowImpl->mpFrameWindow->ImplGetFrameBitmap( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ), aBmp ); } } return aBmp; } // ----------------------------------------------------------------------- Bitmap Window::SnapShot() const { // Should be merged in the next top level build !!! return SnapShot( sal_True ); } // ----------------------------------------------------------------------- void Window::ShowFocus( const Rectangle& rRect ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if( mpWindowImpl->mbInShowFocus ) return; mpWindowImpl->mbInShowFocus = sal_True; ImplWinData* pWinData = ImplGetWinData(); // native themeing suggest not to use focus rects if( ! ( mpWindowImpl->mbUseNativeFocus && IsNativeWidgetEnabled() ) ) { if ( !mpWindowImpl->mbInPaint ) { if ( mpWindowImpl->mbFocusVisible ) { if ( *(pWinData->mpFocusRect) == rRect ) { mpWindowImpl->mbInShowFocus = sal_False; return; } ImplInvertFocus( *(pWinData->mpFocusRect) ); } ImplInvertFocus( rRect ); } if ( !pWinData->mpFocusRect ) pWinData->mpFocusRect = new Rectangle( rRect ); else *(pWinData->mpFocusRect) = rRect; mpWindowImpl->mbFocusVisible = sal_True; } else { if( ! mpWindowImpl->mbNativeFocusVisible ) { mpWindowImpl->mbNativeFocusVisible = sal_True; if ( !mpWindowImpl->mbInPaint ) Invalidate(); } } mpWindowImpl->mbInShowFocus = sal_False; } // ----------------------------------------------------------------------- void Window::HideFocus() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if( mpWindowImpl->mbInHideFocus ) return; mpWindowImpl->mbInHideFocus = sal_True; // native themeing can suggest not to use focus rects if( ! ( mpWindowImpl->mbUseNativeFocus && IsNativeWidgetEnabled() ) ) { if ( !mpWindowImpl->mbFocusVisible ) { mpWindowImpl->mbInHideFocus = sal_False; return; } if ( !mpWindowImpl->mbInPaint ) ImplInvertFocus( *(ImplGetWinData()->mpFocusRect) ); mpWindowImpl->mbFocusVisible = sal_False; } else { if( mpWindowImpl->mbNativeFocusVisible ) { mpWindowImpl->mbNativeFocusVisible = sal_False; if ( !mpWindowImpl->mbInPaint ) Invalidate(); } } mpWindowImpl->mbInHideFocus = sal_False; } // ----------------------------------------------------------------------- void Window::Invert( const Rectangle& rRect, sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( !IsDeviceOutputNecessary() ) return; Rectangle aRect( ImplLogicToDevicePixel( rRect ) ); if ( aRect.IsEmpty() ) return; aRect.Justify(); // we need a graphics if ( !mpGraphics ) { if ( !ImplGetGraphics() ) return; } if ( mbInitClipRegion ) ImplInitClipRegion(); if ( mbOutputClipped ) return; SalInvert nSalFlags = 0; if ( nFlags & INVERT_HIGHLIGHT ) nSalFlags |= SAL_INVERT_HIGHLIGHT; if ( nFlags & INVERT_50 ) nSalFlags |= SAL_INVERT_50; mpGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), nSalFlags, this ); } // ----------------------------------------------------------------------- void Window::Invert( const Polygon& rPoly, sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( !IsDeviceOutputNecessary() ) return; sal_uInt16 nPoints = rPoly.GetSize(); if ( nPoints < 2 ) return; Polygon aPoly( ImplLogicToDevicePixel( rPoly ) ); // we need a graphics if ( !mpGraphics ) { if ( !ImplGetGraphics() ) return; } if ( mbInitClipRegion ) ImplInitClipRegion(); if ( mbOutputClipped ) return; SalInvert nSalFlags = 0; if ( nFlags & INVERT_HIGHLIGHT ) nSalFlags |= SAL_INVERT_HIGHLIGHT; if ( nFlags & INVERT_50 ) nSalFlags |= SAL_INVERT_50; const SalPoint* pPtAry = (const SalPoint*)aPoly.GetConstPointAry(); mpGraphics->Invert( nPoints, pPtAry, nSalFlags, this ); } // ----------------------------------------------------------------------- void Window::ShowTracking( const Rectangle& rRect, sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); ImplWinData* pWinData = ImplGetWinData(); if ( !mpWindowImpl->mbInPaint || !(nFlags & SHOWTRACK_WINDOW) ) { if ( mpWindowImpl->mbTrackVisible ) { if ( (*(pWinData->mpTrackRect) == rRect) && (pWinData->mnTrackFlags == nFlags) ) return; InvertTracking( *(pWinData->mpTrackRect), pWinData->mnTrackFlags ); } InvertTracking( rRect, nFlags ); } if ( !pWinData->mpTrackRect ) pWinData->mpTrackRect = new Rectangle( rRect ); else *(pWinData->mpTrackRect) = rRect; pWinData->mnTrackFlags = nFlags; mpWindowImpl->mbTrackVisible = sal_True; } // ----------------------------------------------------------------------- void Window::HideTracking() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->mbTrackVisible ) { ImplWinData* pWinData = ImplGetWinData(); if ( !mpWindowImpl->mbInPaint || !(pWinData->mnTrackFlags & SHOWTRACK_WINDOW) ) InvertTracking( *(pWinData->mpTrackRect), pWinData->mnTrackFlags ); mpWindowImpl->mbTrackVisible = sal_False; } } // ----------------------------------------------------------------------- void Window::InvertTracking( const Rectangle& rRect, sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); Rectangle aRect( ImplLogicToDevicePixel( rRect ) ); if ( aRect.IsEmpty() ) return; aRect.Justify(); SalGraphics* pGraphics; if ( nFlags & SHOWTRACK_WINDOW ) { if ( !IsDeviceOutputNecessary() ) return; // we need a graphics if ( !mpGraphics ) { if ( !ImplGetGraphics() ) return; } if ( mbInitClipRegion ) ImplInitClipRegion(); if ( mbOutputClipped ) return; pGraphics = mpGraphics; } else { pGraphics = ImplGetFrameGraphics(); if ( nFlags & SHOWTRACK_CLIP ) { Point aPoint( mnOutOffX, mnOutOffY ); Region aRegion( Rectangle( aPoint, Size( mnOutWidth, mnOutHeight ) ) ); ImplClipBoundaries( aRegion, sal_False, sal_False ); ImplSelectClipRegion( aRegion, pGraphics ); } } sal_uInt16 nStyle = nFlags & SHOWTRACK_STYLE; if ( nStyle == SHOWTRACK_OBJECT ) pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SAL_INVERT_TRACKFRAME, this ); else if ( nStyle == SHOWTRACK_SPLIT ) pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SAL_INVERT_50, this ); else { long nBorder = 1; if ( nStyle == SHOWTRACK_BIG ) nBorder = 5; pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), nBorder, SAL_INVERT_50, this ); pGraphics->Invert( aRect.Left(), aRect.Bottom()-nBorder+1, aRect.GetWidth(), nBorder, SAL_INVERT_50, this ); pGraphics->Invert( aRect.Left(), aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SAL_INVERT_50, this ); pGraphics->Invert( aRect.Right()-nBorder+1, aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SAL_INVERT_50, this ); } } // ----------------------------------------------------------------------- void Window::InvertTracking( const Polygon& rPoly, sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); sal_uInt16 nPoints = rPoly.GetSize(); if ( nPoints < 2 ) return; Polygon aPoly( ImplLogicToDevicePixel( rPoly ) ); SalGraphics* pGraphics; if ( nFlags & SHOWTRACK_WINDOW ) { if ( !IsDeviceOutputNecessary() ) return; // we need a graphics if ( !mpGraphics ) { if ( !ImplGetGraphics() ) return; } if ( mbInitClipRegion ) ImplInitClipRegion(); if ( mbOutputClipped ) return; pGraphics = mpGraphics; } else { pGraphics = ImplGetFrameGraphics(); if ( nFlags & SHOWTRACK_CLIP ) { Point aPoint( mnOutOffX, mnOutOffY ); Region aRegion( Rectangle( aPoint, Size( mnOutWidth, mnOutHeight ) ) ); ImplClipBoundaries( aRegion, sal_False, sal_False ); ImplSelectClipRegion( aRegion, pGraphics ); } } const SalPoint* pPtAry = (const SalPoint*)aPoly.GetConstPointAry(); pGraphics->Invert( nPoints, pPtAry, SAL_INVERT_TRACKFRAME, this ); } // ----------------------------------------------------------------------- IMPL_LINK( Window, ImplTrackTimerHdl, Timer*, pTimer ) { ImplSVData* pSVData = ImplGetSVData(); // Bei Button-Repeat muessen wir den Timeout umsetzen if ( pSVData->maWinData.mnTrackFlags & STARTTRACK_BUTTONREPEAT ) pTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonRepeat() ); // Tracking-Event erzeugen Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY ); if( ImplIsAntiparallel() ) { // - RTL - re-mirror frame pos at pChild ImplReMirror( aMousePos ); } MouseEvent aMEvt( ImplFrameToOutput( aMousePos ), mpWindowImpl->mpFrameData->mnClickCount, 0, mpWindowImpl->mpFrameData->mnMouseCode, mpWindowImpl->mpFrameData->mnMouseCode ); TrackingEvent aTEvt( aMEvt, TRACKING_REPEAT ); Tracking( aTEvt ); return 0; } // ----------------------------------------------------------------------- void Window::StartTracking( sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); ImplSVData* pSVData = ImplGetSVData(); if ( pSVData->maWinData.mpTrackWin != this ) { if ( pSVData->maWinData.mpTrackWin ) pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL ); } if ( nFlags & (STARTTRACK_SCROLLREPEAT | STARTTRACK_BUTTONREPEAT) ) { pSVData->maWinData.mpTrackTimer = new AutoTimer; if ( nFlags & STARTTRACK_SCROLLREPEAT ) pSVData->maWinData.mpTrackTimer->SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() ); else pSVData->maWinData.mpTrackTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonStartRepeat() ); pSVData->maWinData.mpTrackTimer->SetTimeoutHdl( LINK( this, Window, ImplTrackTimerHdl ) ); pSVData->maWinData.mpTrackTimer->Start(); } pSVData->maWinData.mpTrackWin = this; pSVData->maWinData.mnTrackFlags = nFlags; CaptureMouse(); } // ----------------------------------------------------------------------- void Window::EndTracking( sal_uInt16 nFlags ) { ImplSVData* pSVData = ImplGetSVData(); if ( pSVData->maWinData.mpTrackWin == this ) { // Hier wegen DbgChkThis geklammert, da Window im Handler zerstoert // werden kann { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( pSVData->maWinData.mpTrackTimer ) { delete pSVData->maWinData.mpTrackTimer; pSVData->maWinData.mpTrackTimer = NULL; } pSVData->maWinData.mpTrackWin = NULL; pSVData->maWinData.mnTrackFlags = 0; ReleaseMouse(); } // EndTracking rufen, wenn es gerufen werden soll if ( !(nFlags & ENDTRACK_DONTCALLHDL) ) { Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY ); if( ImplIsAntiparallel() ) { // - RTL - re-mirror frame pos at pChild ImplReMirror( aMousePos ); } MouseEvent aMEvt( ImplFrameToOutput( aMousePos ), mpWindowImpl->mpFrameData->mnClickCount, 0, mpWindowImpl->mpFrameData->mnMouseCode, mpWindowImpl->mpFrameData->mnMouseCode ); TrackingEvent aTEvt( aMEvt, nFlags | ENDTRACK_END ); Tracking( aTEvt ); } } } // ----------------------------------------------------------------------- sal_Bool Window::IsTracking() const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); return (ImplGetSVData()->maWinData.mpTrackWin == this); } // ----------------------------------------------------------------------- void Window::StartAutoScroll( sal_uInt16 nFlags ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); ImplSVData* pSVData = ImplGetSVData(); if ( pSVData->maWinData.mpAutoScrollWin != this ) { if ( pSVData->maWinData.mpAutoScrollWin ) pSVData->maWinData.mpAutoScrollWin->EndAutoScroll(); } pSVData->maWinData.mpAutoScrollWin = this; pSVData->maWinData.mnAutoScrollFlags = nFlags; pSVData->maAppData.mpWheelWindow = new ImplWheelWindow( this ); } // ----------------------------------------------------------------------- void Window::EndAutoScroll() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); ImplSVData* pSVData = ImplGetSVData(); if ( pSVData->maWinData.mpAutoScrollWin == this ) { pSVData->maWinData.mpAutoScrollWin = NULL; pSVData->maWinData.mnAutoScrollFlags = 0; pSVData->maAppData.mpWheelWindow->ImplStop(); pSVData->maAppData.mpWheelWindow->doLazyDelete(); pSVData->maAppData.mpWheelWindow = NULL; } } // ----------------------------------------------------------------------- sal_Bool Window::IsAutoScroll() const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); return (ImplGetSVData()->maWinData.mpAutoScrollWin == this); } // ----------------------------------------------------------------------- void Window::SaveBackground( const Point& rPos, const Size& rSize, const Point& rDestOff, VirtualDevice& rSaveDevice ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->mpPaintRegion ) { Region aClip( *mpWindowImpl->mpPaintRegion ); const Point aPixPos( LogicToPixel( rPos ) ); aClip.Move( -mnOutOffX, -mnOutOffY ); aClip.Intersect( Rectangle( aPixPos, LogicToPixel( rSize ) ) ); if ( !aClip.IsEmpty() ) { const Region aOldClip( rSaveDevice.GetClipRegion() ); const Point aPixOffset( rSaveDevice.LogicToPixel( rDestOff ) ); const sal_Bool bMap = rSaveDevice.IsMapModeEnabled(); // move clip region to have the same distance to DestOffset aClip.Move( aPixOffset.X() - aPixPos.X(), aPixOffset.Y() - aPixPos.Y() ); // set pixel clip region rSaveDevice.EnableMapMode( sal_False ); rSaveDevice.SetClipRegion( aClip ); rSaveDevice.EnableMapMode( bMap ); rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *this ); rSaveDevice.SetClipRegion( aOldClip ); } } else rSaveDevice.DrawOutDev( rDestOff, rSize, rPos, rSize, *this ); } // ----------------------------------------------------------------------- sal_uIntPtr Window::SaveFocus() { ImplSVData* pSVData = ImplGetSVData(); if ( pSVData->maWinData.mpFocusWin ) { ImplFocusDelData* pDelData = new ImplFocusDelData; pSVData->maWinData.mpFocusWin->ImplAddDel( pDelData ); pDelData->mpFocusWin = pSVData->maWinData.mpFocusWin; return (sal_uIntPtr)(void*)pDelData; } else return 0; } // ----------------------------------------------------------------------- sal_Bool Window::EndSaveFocus( sal_uIntPtr nSaveId, sal_Bool bRestore ) { if ( !nSaveId ) return sal_False; else { sal_Bool bOK = sal_True; ImplFocusDelData* pDelData = (ImplFocusDelData*)(void*)nSaveId; if ( !pDelData->IsDelete() ) { pDelData->mpFocusWin->ImplRemoveDel( pDelData ); if ( bRestore ) pDelData->mpFocusWin->GrabFocus(); } else bOK = !bRestore; delete pDelData; return bOK; } } // ----------------------------------------------------------------------- void Window::SetZoom( const Fraction& rZoom ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->maZoom != rZoom ) { mpWindowImpl->maZoom = rZoom; StateChanged( STATE_CHANGE_ZOOM ); } } // ----------------------------------------------------------------------- inline long WinFloatRound( double fVal ) { return( fVal > 0.0 ? (long) ( fVal + 0.5 ) : -(long) ( -fVal + 0.5 ) ); } // ----------------------------------------------------------------------- void Window::SetZoomedPointFont( const Font& rFont ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); const Fraction& rZoom = GetZoom(); if ( rZoom.GetNumerator() != rZoom.GetDenominator() ) { Font aFont( rFont ); Size aSize = aFont.GetSize(); double n = (double)aSize.Width(); n *= (double)rZoom.GetNumerator(); n /= (double)rZoom.GetDenominator(); aSize.Width() = WinFloatRound( n ); n = (double)aSize.Height(); n *= (double)rZoom.GetNumerator(); n /= (double)rZoom.GetDenominator(); aSize.Height() = WinFloatRound( n ); aFont.SetSize( aSize ); SetPointFont( aFont ); // Wenn Darstellung skaliert wird, nehmen wir gegebenenfalls // einen anderen Font, wenn der aktuelle nicht skalierbar ist FontMetric aMetric = GetFontMetric(); long nFontDiff = Abs( GetFont().GetSize().Height()-aMetric.GetSize().Height() ); if ( (aMetric.GetType() == TYPE_RASTER) && (nFontDiff >= 2) ) { sal_uInt16 nType; if ( aMetric.GetPitch() == PITCH_FIXED ) nType = DEFAULTFONT_FIXED; else nType = DEFAULTFONT_UI_SANS; Font aTempFont = GetDefaultFont( nType, GetSettings().GetLanguage(), 0 ); aFont.SetName( aTempFont.GetName() ); SetPointFont( aFont ); } } else SetPointFont( rFont ); } // ----------------------------------------------------------------------- long Window::CalcZoom( long nCalc ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); const Fraction& rZoom = GetZoom(); if ( rZoom.GetNumerator() != rZoom.GetDenominator() ) { double n = (double)nCalc; n *= (double)rZoom.GetNumerator(); n /= (double)rZoom.GetDenominator(); nCalc = WinFloatRound( n ); } return nCalc; } // ----------------------------------------------------------------------- void Window::SetControlFont() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->mpControlFont ) { delete mpWindowImpl->mpControlFont; mpWindowImpl->mpControlFont = NULL; StateChanged( STATE_CHANGE_CONTROLFONT ); } } // ----------------------------------------------------------------------- void Window::SetControlFont( const Font& rFont ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( rFont == Font() ) { SetControlFont(); return; } if ( mpWindowImpl->mpControlFont ) { if ( *mpWindowImpl->mpControlFont == rFont ) return; *mpWindowImpl->mpControlFont = rFont; } else mpWindowImpl->mpControlFont = new Font( rFont ); StateChanged( STATE_CHANGE_CONTROLFONT ); } // ----------------------------------------------------------------------- Font Window::GetControlFont() const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->mpControlFont ) return *mpWindowImpl->mpControlFont; else { Font aFont; return aFont; } } // ----------------------------------------------------------------------- void Window::SetControlForeground() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->mbControlForeground ) { mpWindowImpl->maControlForeground = Color( COL_TRANSPARENT ); mpWindowImpl->mbControlForeground = sal_False; StateChanged( STATE_CHANGE_CONTROLFOREGROUND ); } } // ----------------------------------------------------------------------- void Window::SetControlForeground( const Color& rColor ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( rColor.GetTransparency() ) { if ( mpWindowImpl->mbControlForeground ) { mpWindowImpl->maControlForeground = Color( COL_TRANSPARENT ); mpWindowImpl->mbControlForeground = sal_False; StateChanged( STATE_CHANGE_CONTROLFOREGROUND ); } } else { if ( mpWindowImpl->maControlForeground != rColor ) { mpWindowImpl->maControlForeground = rColor; mpWindowImpl->mbControlForeground = sal_True; StateChanged( STATE_CHANGE_CONTROLFOREGROUND ); } } } // ----------------------------------------------------------------------- void Window::SetControlBackground() { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( mpWindowImpl->mbControlBackground ) { mpWindowImpl->maControlBackground = Color( COL_TRANSPARENT ); mpWindowImpl->mbControlBackground = sal_False; StateChanged( STATE_CHANGE_CONTROLBACKGROUND ); } } // ----------------------------------------------------------------------- void Window::SetControlBackground( const Color& rColor ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); if ( rColor.GetTransparency() ) { if ( mpWindowImpl->mbControlBackground ) { mpWindowImpl->maControlBackground = Color( COL_TRANSPARENT ); mpWindowImpl->mbControlBackground = sal_False; StateChanged( STATE_CHANGE_CONTROLBACKGROUND ); } } else { if ( mpWindowImpl->maControlBackground != rColor ) { mpWindowImpl->maControlBackground = rColor; mpWindowImpl->mbControlBackground = sal_True; StateChanged( STATE_CHANGE_CONTROLBACKGROUND ); } } } // ----------------------------------------------------------------------- Size Window::CalcWindowSize( const Size& rOutSz ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); Size aSz = rOutSz; aSz.Width() += mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder; aSz.Height() += mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder; return aSz; } // ----------------------------------------------------------------------- Size Window::CalcOutputSize( const Size& rWinSz ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); Size aSz = rWinSz; aSz.Width() -= mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder; aSz.Height() -= mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder; return aSz; } // ----------------------------------------------------------------------- Font Window::GetDrawPixelFont( OutputDevice* pDev ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); Font aFont = GetPointFont(); Size aFontSize = aFont.GetSize(); MapMode aPtMapMode( MAP_POINT ); aFontSize = pDev->LogicToPixel( aFontSize, aPtMapMode ); aFont.SetSize( aFontSize ); return aFont; } // ----------------------------------------------------------------------- long Window::GetDrawPixel( OutputDevice* pDev, long nPixels ) const { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); long nP = nPixels; if ( pDev->GetOutDevType() != OUTDEV_WINDOW ) { MapMode aMap( MAP_100TH_MM ); Size aSz( nP, 0 ); aSz = PixelToLogic( aSz, aMap ); aSz = pDev->LogicToPixel( aSz, aMap ); nP = aSz.Width(); } return nP; } // ----------------------------------------------------------------------- sal_Bool Window::HandleScrollCommand( const CommandEvent& rCmd, ScrollBar* pHScrl, ScrollBar* pVScrl ) { DBG_CHKTHIS( Window, ImplDbgCheckWindow ); sal_Bool bRet = sal_False; if ( pHScrl || pVScrl ) { switch( rCmd.GetCommand() ) { case COMMAND_STARTAUTOSCROLL: { sal_uInt16 nFlags = 0; if ( pHScrl ) { if ( (pHScrl->GetVisibleSize() < pHScrl->GetRangeMax()) && pHScrl->IsEnabled() && pHScrl->IsInputEnabled() && ! pHScrl->IsInModalMode() ) nFlags |= AUTOSCROLL_HORZ; } if ( pVScrl ) { if ( (pVScrl->GetVisibleSize() < pVScrl->GetRangeMax()) && pVScrl->IsEnabled() && pVScrl->IsInputEnabled() && ! pVScrl->IsInModalMode() ) nFlags |= AUTOSCROLL_VERT; } if ( nFlags ) { StartAutoScroll( nFlags ); bRet = sal_True; } } break; case COMMAND_WHEEL: { const CommandWheelData* pData = rCmd.GetWheelData(); if ( pData && (COMMAND_WHEEL_SCROLL == pData->GetMode()) ) { sal_uLong nScrollLines = pData->GetScrollLines(); long nLines; if ( nScrollLines == COMMAND_WHEEL_PAGESCROLL ) { if ( pData->GetDelta() < 0 ) nLines = -LONG_MAX; else nLines = LONG_MAX; } else nLines = pData->GetNotchDelta() * (long)nScrollLines; if ( nLines ) { ImplHandleScroll( NULL, 0L, pData->IsHorz() ? pHScrl : pVScrl, nLines ); bRet = sal_True; } } } break; case COMMAND_AUTOSCROLL: { const CommandScrollData* pData = rCmd.GetAutoScrollData(); if ( pData && (pData->GetDeltaX() || pData->GetDeltaY()) ) { ImplHandleScroll( pHScrl, pData->GetDeltaX(), pVScrl, pData->GetDeltaY() ); bRet = sal_True; } } break; default: break; } } return bRet; } // ----------------------------------------------------------------------- void Window::ImplHandleScroll( ScrollBar* pHScrl, long nX, ScrollBar* pVScrl, long nY ) { if ( pHScrl && nX && pHScrl->IsEnabled() && pHScrl->IsInputEnabled() && ! pHScrl->IsInModalMode() ) { long nNewPos = pHScrl->GetThumbPos(); if ( nX == -LONG_MAX ) nNewPos += pHScrl->GetPageSize(); else if ( nX == LONG_MAX ) nNewPos -= pHScrl->GetPageSize(); else { const double fVal = (double)nNewPos - ((double)nX * pHScrl->GetLineSize()); if ( fVal < LONG_MIN ) nNewPos = LONG_MIN; else if ( fVal > LONG_MAX ) nNewPos = LONG_MAX; else nNewPos = (long)fVal; } pHScrl->DoScroll( nNewPos ); } if ( pVScrl && nY && pVScrl->IsEnabled() && pVScrl->IsInputEnabled() && ! pVScrl->IsInModalMode() ) { long nNewPos = pVScrl->GetThumbPos(); if ( nY == -LONG_MAX ) nNewPos += pVScrl->GetPageSize(); else if ( nY == LONG_MAX ) nNewPos -= pVScrl->GetPageSize(); else { const double fVal = (double)nNewPos - ((double)nY * pVScrl->GetLineSize()); if ( fVal < LONG_MIN ) nNewPos = LONG_MIN; else if ( fVal > LONG_MAX ) nNewPos = LONG_MAX; else nNewPos = (long)fVal; } pVScrl->DoScroll( nNewPos ); } } // support for docking // this is currently handled in ImplDockingWindowWrapper /* void Window::ImplSetFloatingMode( sal_Bool bFloatMode ) { // if the window is docked, put it into a flaoting window // if it is floating put it back in the old frame ImplDockingWindowWrapper *pWrapper = pDockingMgr->GetDockingWindowWrapper( this ); if( !pDockingData ) return; if ( pWrapper->IsFloatingMode() != bFloatMode ) { if ( pWrapper->PrepareToggleFloatingMode() ) { sal_Bool bVisible = IsVisible(); if ( bFloatMode ) { Show( sal_False, SHOW_NOFOCUSCHANGE ); pWrapper->maDockPos = GetPosPixel(); Window* pRealParent = mpWindowImpl->mpRealParent; pWrapper->mpOldBorderWin = mpWindowImpl->mpBorderWindow; ImplDockFloatWin* pWin = new ImplDockFloatWin2( mpWindowImpl->mpParent, mnFloatBits & ( WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE ) ? mnFloatBits | WB_SYSTEMWINDOW : mnFloatBits, pWrapper ); pWrapper->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 ( pWrapper->mpOldBorderWin ) pWrapper->mpOldBorderWin->SetParent( pWin ); SetParent( pWin ); pWin->SetPosPixel( Point() ); mpWindowImpl->mpBorderWindow = pWin; pWin->mpWindowImpl->mpClientWindow = this; mpWindowImpl->mpRealParent = pRealParent; pWin->SetText( GetText() ); pWin->SetOutputSizePixel( GetSizePixel() ); pWin->SetPosPixel( pWrapper->maFloatPos ); // DockingDaten ans FloatingWindow weiterreichen pWin->ShowTitleButton( TITLE_BUTTON_DOCKING, pWrapper->mbDockBtn ); pWin->ShowTitleButton( TITLE_BUTTON_HIDE, pWrapper->mbHideBtn ); pWin->SetPin( pWrapper->mbPined ); if ( pWrapper->mbRollUp ) pWin->RollUp(); else pWin->RollDown(); pWin->SetRollUpOutputSizePixel( pWrapper->maRollUpOutSize ); pWin->SetMinOutputSizePixel( pWrapper->maMinOutSize ); pWrapper->ToggleFloatingMode(); if ( bVisible ) Show(); } else { Show( sal_False, SHOW_NOFOCUSCHANGE ); // FloatingDaten wird im FloatingWindow speichern pWrapper->maFloatPos = mpFloatWin->GetPosPixel(); pWrapper->mbDockBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_DOCKING ); pWrapper->mbHideBtn = mpFloatWin->IsTitleButtonVisible( TITLE_BUTTON_HIDE ); pWrapper->mbPined = mpFloatWin->IsPined(); pWrapper->mbRollUp = mpFloatWin->IsRollUp(); pWrapper->maRollUpOutSize = mpFloatWin->GetRollUpOutputSizePixel(); pWrapper->maMinOutSize = mpFloatWin->GetMinOutputSizePixel(); Window* pRealParent = mpWindowImpl->mpRealParent; mpWindowImpl->mpBorderWindow = NULL; if ( pWrapper->mpOldBorderWin ) { SetParent( pWrapper->mpOldBorderWin ); ((ImplBorderWindow*)pWrapper->mpOldBorderWin)->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder ); pWrapper->mpOldBorderWin->Resize(); } mpWindowImpl->mpBorderWindow = pWrapper->mpOldBorderWin; SetParent( pRealParent ); mpWindowImpl->mpRealParent = pRealParent; delete static_cast(mpFloatWin); pWrapper->mpFloatWin = NULL; SetPosPixel( maDockPos ); pWrapper->ToggleFloatingMode(); if ( bVisible ) Show(); } } } } */ DockingManager* Window::GetDockingManager() { return ImplGetDockingManager(); } void Window::EnableDocking( sal_Bool bEnable ) { // update list of dockable windows if( bEnable ) ImplGetDockingManager()->AddWindow( this ); else ImplGetDockingManager()->RemoveWindow( this ); } // retrieves the list of owner draw decorated windows for this window hiearchy ::std::vector& Window::ImplGetOwnerDrawList() { return ImplGetTopmostFrameWindow()->mpWindowImpl->mpFrameData->maOwnerDrawList; } Window* Window::ImplGetTopmostFrameWindow() { Window *pTopmostParent = this; while( pTopmostParent->ImplGetParent() ) pTopmostParent = pTopmostParent->ImplGetParent(); return pTopmostParent->mpWindowImpl->mpFrameWindow; } void Window::SetHelpId( const rtl::OString& rHelpId ) { mpWindowImpl->maHelpId = rHelpId; } const rtl::OString& Window::GetHelpId() const { return mpWindowImpl->maHelpId; } void Window::SetUniqueId( const rtl::OString& rUniqueId ) { mpWindowImpl->maUniqId = rUniqueId; } const rtl::OString& Window::GetUniqueId() const { return mpWindowImpl->maUniqId; } const rtl::OString& Window::GetUniqueOrHelpId() const { return mpWindowImpl->maUniqId.getLength() ? mpWindowImpl->maUniqId : mpWindowImpl->maHelpId; } // --------- old inline methods --------------- Window* Window::ImplGetWindow() { if ( mpWindowImpl->mpClientWindow ) return mpWindowImpl->mpClientWindow; else return this; } ImplFrameData* Window::ImplGetFrameData() { return mpWindowImpl->mpFrameData; } SalFrame* Window::ImplGetFrame() const { return mpWindowImpl->mpFrame; } Window* Window::ImplGetParent() const { return mpWindowImpl->mpParent; } Window* Window::ImplGetClientWindow() const { return mpWindowImpl->mpClientWindow; } Window* Window::ImplGetBorderWindow() const { return mpWindowImpl->mpBorderWindow; } Window* Window::ImplGetFirstOverlapWindow() { if ( mpWindowImpl->mbOverlapWin ) return this; else return mpWindowImpl->mpOverlapWindow; } const Window* Window::ImplGetFirstOverlapWindow() const { if ( mpWindowImpl->mbOverlapWin ) return this; else return mpWindowImpl->mpOverlapWindow; } Window* Window::ImplGetFrameWindow() const { return mpWindowImpl->mpFrameWindow; } sal_Bool Window::ImplIsDockingWindow() const { return mpWindowImpl->mbDockWin; } sal_Bool Window::ImplIsFloatingWindow() const { return mpWindowImpl->mbFloatWin; } sal_Bool Window::ImplIsToolbox() const { return mpWindowImpl->mbToolBox; } sal_Bool Window::ImplIsSplitter() const { return mpWindowImpl->mbSplitter; } sal_Bool Window::ImplIsPushButton() const { return mpWindowImpl->mbPushButton; } sal_Bool Window::ImplIsOverlapWindow() const { return mpWindowImpl->mbOverlapWin; } void Window::ImplSetActive( sal_Bool bActive ) { mpWindowImpl->mbActive = bActive; } sal_Bool Window::ImplIsMouseTransparent() const { return mpWindowImpl->mbMouseTransparent; } void Window::ImplSetMouseTransparent( sal_Bool bTransparent ) { mpWindowImpl->mbMouseTransparent = bTransparent; } Point Window::ImplOutputToFrame( const Point& rPos ) { return Point( rPos.X()+mnOutOffX, rPos.Y()+mnOutOffY ); } Point Window::ImplFrameToOutput( const Point& rPos ) { return Point( rPos.X()-mnOutOffX, rPos.Y()-mnOutOffY ); } void Window::ImplOutputToFrame( Rectangle& rRect ) { rRect.Left()+=mnOutOffX; rRect.Top()+=mnOutOffY; rRect.Right()+=mnOutOffX; rRect.Bottom()+=mnOutOffY; } void Window::ImplFrameToOutput( Rectangle& rRect ) { rRect.Left()-=mnOutOffX; rRect.Top()-=mnOutOffY; rRect.Right()-=mnOutOffX; rRect.Bottom()-=mnOutOffY; } void Window::SetCompoundControl( sal_Bool bCompound ) { mpWindowImpl->mbCompoundControl = bCompound; } void Window::IncrementLockCount() { mpWindowImpl->mnLockCount++; } void Window::DecrementLockCount() { mpWindowImpl->mnLockCount--; } WinBits Window::GetStyle() const { return mpWindowImpl->mnStyle; } WinBits Window::GetPrevStyle() const { return mpWindowImpl->mnPrevStyle; } WinBits Window::GetExtendedStyle() const { return mpWindowImpl->mnExtendedStyle; } WinBits Window::GetPrevExtendedStyle() const { return mpWindowImpl->mnExtendedStyle; } void Window::SetType( WindowType nType ) { mpWindowImpl->mnType = nType; } WindowType Window::GetType() const { return mpWindowImpl->mnType; } sal_Bool Window::IsSystemWindow() const { return mpWindowImpl->mbSysWin; } sal_Bool Window::IsDialog() const { return mpWindowImpl->mbDialog; } sal_Bool Window::IsMenuFloatingWindow() const { return mpWindowImpl->mbMenuFloatingWindow; } sal_Bool Window::IsToolbarFloatingWindow() const { return mpWindowImpl->mbToolbarFloatingWindow; } void Window::EnableAllResize( sal_Bool bEnable ) { mpWindowImpl->mbAllResize = bEnable; } sal_Bool Window::IsAllResizeEnabled() const { return mpWindowImpl->mbAllResize; } sal_Bool Window::IsClipSiblingsEnabled() const { return mpWindowImpl->mbClipSiblings; } void Window::EnableChildTransparentMode( sal_Bool bEnable ) { mpWindowImpl->mbChildTransparent = bEnable; } sal_Bool Window::IsChildTransparentModeEnabled() const { return mpWindowImpl->mbChildTransparent; } sal_Bool Window::IsMouseTransparent() const { return mpWindowImpl->mbMouseTransparent; } sal_Bool Window::IsPaintTransparent() const { return mpWindowImpl->mbPaintTransparent; } void Window::SetDialogControlStart( sal_Bool bStart ) { mpWindowImpl->mbDlgCtrlStart = bStart; } sal_Bool Window::IsDialogControlStart() const { return mpWindowImpl->mbDlgCtrlStart; } void Window::SetDialogControlFlags( sal_uInt16 nFlags ) { mpWindowImpl->mnDlgCtrlFlags = nFlags; } sal_uInt16 Window::GetDialogControlFlags() const { return mpWindowImpl->mnDlgCtrlFlags; } const InputContext& Window::GetInputContext() const { return mpWindowImpl->maInputContext; } sal_Bool Window::IsExtTextInput() const { return mpWindowImpl->mbExtTextInput; } void Window::EnableChildNotify( sal_Bool bEnable ) { mpWindowImpl->mbChildNotify = bEnable; } sal_Bool Window::IsChildNotify() const { return mpWindowImpl->mbChildNotify; } sal_Bool Window::IsControlFont() const { return (mpWindowImpl->mpControlFont != 0); } Color Window::GetControlForeground() const { return mpWindowImpl->maControlForeground; } sal_Bool Window::IsControlForeground() const { return mpWindowImpl->mbControlForeground; } Color Window::GetControlBackground() const { return mpWindowImpl->maControlBackground; } sal_Bool Window::IsControlBackground() const { return mpWindowImpl->mbControlBackground; } sal_Bool Window::IsInPaint() const { return mpWindowImpl->mbInPaint; } Window* Window::GetParent() const { return mpWindowImpl->mpRealParent; } sal_Bool Window::IsVisible() const { return mpWindowImpl->mbVisible; } sal_Bool Window::IsReallyVisible() const { return mpWindowImpl->mbReallyVisible; } sal_Bool Window::IsParentPathVisible() const { return mpWindowImpl->mbReallyVisible; } sal_Bool Window::IsReallyShown() const { return mpWindowImpl->mbReallyShown; } sal_Bool Window::IsInInitShow() const { return mpWindowImpl->mbInInitShow; } sal_Bool Window::IsEnabled() const { return !mpWindowImpl->mbDisabled; } sal_Bool Window::IsInputEnabled() const { return !mpWindowImpl->mbInputDisabled; } sal_Bool Window::IsAlwaysEnableInput() const { return mpWindowImpl->meAlwaysInputMode == AlwaysInputEnabled; } sal_Bool Window::IsAlwaysDisableInput() const { return mpWindowImpl->meAlwaysInputMode == AlwaysInputDisabled; } sal_uInt16 Window::GetActivateMode() const { return mpWindowImpl->mnActivateMode; } sal_Bool Window::IsAlwaysOnTopEnabled() const { return mpWindowImpl->mbAlwaysOnTop; } sal_Bool Window::IsDefaultPos() const { return mpWindowImpl->mbDefPos; } sal_Bool Window::IsDefaultSize() const { return mpWindowImpl->mbDefSize; } void Window::EnablePaint( sal_Bool bEnable ) { mpWindowImpl->mbPaintDisabled = !bEnable; } sal_Bool Window::IsPaintEnabled() const { return !mpWindowImpl->mbPaintDisabled; } sal_Bool Window::IsUpdateMode() const { return !mpWindowImpl->mbNoUpdate; } void Window::SetParentUpdateMode( sal_Bool bUpdate ) { mpWindowImpl->mbNoParentUpdate = !bUpdate; } sal_Bool Window::IsParentUpdateMode() const { return !mpWindowImpl->mbNoParentUpdate; } sal_Bool Window::IsActive() const { return mpWindowImpl->mbActive; } sal_uInt16 Window::GetGetFocusFlags() const { return mpWindowImpl->mnGetFocusFlags; } sal_Bool Window::IsCompoundControl() const { return mpWindowImpl->mbCompoundControl; } sal_Bool Window::HasCompoundControlFocus() const { return mpWindowImpl->mbCompoundControlHasFocus; } sal_Bool Window::IsChildPointerOverwrite() const { return mpWindowImpl->mbChildPtrOverwrite; } sal_Bool Window::IsPointerVisible() const { return !mpWindowImpl->mbNoPtrVisible; } sal_Bool Window::IsWait() const { return (mpWindowImpl->mnWaitCount != 0); } Cursor* Window::GetCursor() const { return mpWindowImpl->mpCursor; } const Fraction& Window::GetZoom() const { return mpWindowImpl->maZoom; } sal_Bool Window::IsZoom() const { return mpWindowImpl->maZoom.GetNumerator() != mpWindowImpl->maZoom.GetDenominator(); } void Window::SetHelpText( const XubString& rHelpText ) { mpWindowImpl->maHelpText = rHelpText; mpWindowImpl->mbHelpTextDynamic = sal_True; } void Window::SetQuickHelpText( const XubString& rHelpText ) { mpWindowImpl->maQuickHelpText = rHelpText; } const XubString& Window::GetQuickHelpText() const { return mpWindowImpl->maQuickHelpText; } void Window::SetData( void* pNewData ) { mpWindowImpl->mpUserData = pNewData; } void* Window::GetData() const { return mpWindowImpl->mpUserData; } sal_Bool Window::IsCreatedWithToolkit() const { return mpWindowImpl->mbCreatedWithToolkit; } void Window::SetCreatedWithToolkit( sal_Bool b ) { mpWindowImpl->mbCreatedWithToolkit = b; } const Pointer& Window::GetPointer() const { return mpWindowImpl->maPointer; } VCLXWindow* Window::GetWindowPeer() const { return mpWindowImpl->mpVCLXWindow; } void Window::SetPosPixel( const Point& rNewPos ) { SetPosSizePixel( rNewPos.X(), rNewPos.Y(), 0, 0, WINDOW_POSSIZE_POS ); } void Window::SetSizePixel( const Size& rNewSize ) { SetPosSizePixel( 0, 0, rNewSize.Width(), rNewSize.Height(), WINDOW_POSSIZE_SIZE ); } void Window::SetPosSizePixel( const Point& rNewPos, const Size& rNewSize ) { SetPosSizePixel( rNewPos.X(), rNewPos.Y(), rNewSize.Width(), rNewSize.Height(), WINDOW_POSSIZE_POSSIZE ); } void Window::SetOutputSizePixel( const Size& rNewSize ) { SetSizePixel( Size( rNewSize.Width()+mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder, rNewSize.Height()+mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder ) ); }