| /************************************************************** |
| * |
| * 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 <limits.h> |
| |
| #include <tools/debug.hxx> |
| #include <tools/poly.hxx> |
| |
| #include <vcl/bitmap.hxx> |
| #include <vcl/event.hxx> |
| #include <vcl/timer.hxx> |
| #include <vcl/metric.hxx> |
| #include <vcl/virdev.hxx> |
| #include <vcl/window.hxx> |
| #include <vcl/scrbar.hxx> |
| #include <vcl/dockwin.hxx> |
| |
| #include <window.h> |
| #include <outfont.hxx> |
| #include <outdev.h> |
| #include <svdata.hxx> |
| #include <impbmp.hxx> |
| #include <salbmp.hxx> |
| #include <salgdi.hxx> |
| #include <salframe.hxx> |
| #include <scrwnd.hxx> |
| |
| |
| // ======================================================================= |
| |
| 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<ImplDockFloatWin*>(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 *>& 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 ) ); |
| } |
| |
