diff -r 000000000000 -r bde4ae8d615e os/graphics/windowing/windowserver/nonnga/SERVER/screen.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/windowing/windowserver/nonnga/SERVER/screen.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,377 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Defines the screen class (was in scrdev.h) +// +// + +#ifndef __SCREEN_H__ +#define __SCREEN_H__ + +#include +#include +#include +#include "w32cmd.h" +#include "wstypes.h" + +#include + +class CWsDirectScreenAccess; + +class CWsOffScreenBitmap; +class CWsWindowGroup; +class CWsWindow; +class CWsRootWindow; +class CWsClientWindow; +class CDebugBar; +class CScreenRedraw; +class CWsSpriteManager; + +class CScreen : public CBase, public MWsScreen, public MWsScreenConfig, public MWsFrontBuffer + { + enum {EDefaultShadowX=2}; + enum {EDefaultShadowY=2}; +public: + enum {EGetScanLineBufLen=0x100}; // Buffer of for returning result of GetScanLine + enum {EMaxNumModes=EColorLast-2}; // Number of available devices in the GDI enum TDisplayMode + enum TDisplayScreen + { + EBlankScreenOnRotation = 0x1, + EAutoClear = 0x2, + EBltOffScreenBitmap = 0x04, // Refrain from clearing window to default background color + }; + /** + The fallback map is an array of 32 bit integers sufficiently large to store a single bit for any + possible orientation and size of the screen, with the pixel rows padded to the end of the int. + Andy - This is only used by the screen redraw, so it should be in the screen redraw, not the screen. + Also, it doesnt need its own region, since the root window has the correct region already. + */ + class CFallbackMap : public CBase + { + public: + static CFallbackMap * NewL(CScreen* aScreen); + ~CFallbackMap(); + + void Prepare(); + TBool FillRegion(const TRegion& aRegion); + TBool FillRect(const TRect& aRect); + TInt Count() const; + const TRect * Rect() const; + const RRegion * Region() const; + + private: + CFallbackMap(CScreen* aScreen); + void ConstructL(); + + public: + CScreen* iScreen; + RRegionBuf<1> iRegion; + TInt iCount; + TInt iMapSize; // size in padded TInts + TInt * iMap; + }; +public: + CScreen(); + ~CScreen(); + void ConstructL( const TRect& aDigitiserArea, TInt aScreenNumber ); + void AbortAllDirectDrawing(RDirectScreenAccess::TTerminationReasons aReason); + void AddDirect(CWsDirectScreenAccess& aDirect); + void RemoveDirect(CWsDirectScreenAccess& aDirect); + void AbortDSAs(RDirectScreenAccess::TTerminationReasons aReason,TSglQue& aDirects); +#if defined(_DEBUG) + TBool IsDirectOnQueue(const CWsDirectScreenAccess* aDirect); +#if defined(__WINS__) + void UpdateOffScreenBitmap(); +#endif +#endif + + inline CWsWindowGroup* FocusWindowGroup(); + void KillForegroundSession(); + void ResetFocus(CWsWindowGroup *aClosingWindow); + void SetShadowVector(const TPoint &aShadowShift); + inline TPoint ShadowVector(); + inline TBool BlankScreenOnRotation(); + inline TBool AutoClear(); + void RemoveFromDefaultOwningList(CWsWindowGroup *aDestroyedGroup); + void SetDefaultOwningWindow(CWsWindowGroup *aGroup); + inline CWsWindowGroup *DefaultOwningWindowGroup(); + + void CheckDisplayMode(TBool aUpdateNow); + CFbsScreenDevice *ScreenDevice(); + inline CWsRootWindow* RootWindow() const; + inline TInt ScreenNumber() const; + void Update(); + void Update(const TRegion &aRegion); + inline TDisplayMode CurrentDisplayMode(); + inline TDisplayMode DefaultDisplayMode(); + inline TDisplayMode DefaultDisplayMode(const TInt aMode) const; + TDisplayMode FirstDefaultDisplayMode() const; + // + inline CFbsBitGc *ScreenGdi(); + void MaxNumColors(TInt& aColors,TInt& aGrays); + TInt ColorModesFlag(); + inline void GetFadingParams(TUint8& aBlackMap,TUint8& aWhiteMap) const; + inline void SetFadingParams(TUint8 aBlackMap,TUint8 aWhiteMap); + void GetScanLine(const TWsSdCmdGetScanLine *aGetScanLine); + + TBool SetScreenModeEnforcement(TInt aMode); + inline TInt ScreenSizeMode() const; + void SetPointerCursorArea(TInt aMode,const TRect& aRect); + inline TRect GetPointerCursorArea(TInt aMode) const; + CFbsBitGc::TGraphicsOrientation Orientation(); + void CycleDisplaySize(); + void UpdateOrientation(); + void doSetScreenMode(TInt aMode); + inline TSize CurrentScreenSize() const; + TRect DrawableArea() const; + void CycleOrientation(); + TClientPanic SetModeRotation(TInt aMode,CFbsBitGc::TGraphicsOrientation aRotation); + void LoadScreenSizesL(TSize aScreenSize); + void LoadScreenSizeProperties(); + void LoadScreenScale(); + void SetDigitiserAreas(const TSize& aScreenSize,const TRect& aDigitiserArea); + inline TInt NumScreenSizeModes() const; + inline const TSizeMode& ScreenSizeModeData() const; + inline const TSizeMode& ScreenSizeModeData(TInt aMode) const; + inline TPoint ScreenModeOrigin(TInt aMode); + inline TPoint CurrentScreenModeOrigin(); + inline TSize CurrentScreenModeScale(); + inline TPoint CurrentScreenModeScaledOrigin(); + inline TPoint ScreenModeScaledOrigin(TInt aMode); + inline TScreenModeEnforcement SizeEnforcementMode() const; + void GetScreenSizeAndRotation(TPixelsTwipsAndRotation &aSar, TInt aScreenMode); + void GetScreenSizeAndRotation(TPixelsAndRotation &aSar, TInt aScreenMode); + inline TSize GetScreenScale(TInt aMode) const; + inline void SetCurrentScreenModeAttributes(const TSizeMode &aModeData); + inline TSize GetPhysicalScreenSize(); + inline void SetPhysicalScreenSize(); + inline TBool ShouldSwapWidthAndHeightOffScBitmap(TInt aOldRotation); + inline TInt Modes(); + CFbsDevice * DrawDevice(); + CWsOffScreenBitmap* OffScreenBitmap(); + void FreeOffScreenBitmap(); + void UpdateGcs(); + inline void SetScalingFactor(); + void UpdateOffScreenBitmapGc(const TBool aSwapWidthAndHeight); + TPoint PhysicalToLogical(TPoint aPhysicalPt); + void IncContrast(); + void DecContrast(); + void IncBrightness(); + void DecBrightness(); + inline TBool IsValidScreenSizeMode(TInt aMode); + TInt GetScreenSizeModeListL(); + void SetDisplayModeFromName(const TDesC& aModeName, TDisplayMode& aMode); + CFbsDevice* GetFbsDevice(); + // called by CWsGc when it is implementing MWsGc + const TTime& Now() const; + void ScheduleAnimation(const TRect& aRect,const TTimeIntervalMicroSeconds& aFromNow,const TTimeIntervalMicroSeconds& aFreq,const TTimeIntervalMicroSeconds& aStop); + // redraw scheduling code + void AddRedrawRegion(const TRegion& aRegion, TBool aSchedule = ETrue, TRedrawDepth aDepth = ERedrawAll); + void DoRedrawNow(); + void ScheduleRegionUpdate(const TRegion* aDefinitelyDirty); + void EndClientBuffer(); + // implementing MWsScreen + void OnAnimation(); + void Redraw(); + TBool RedrawInvalid(const TArray& aInvalid); + inline TBool BackLightFlag(); + // implementing interface extension + TAny* ResolveObjectInterface(TUint aTypeId); + // implementing MWsScreenConfig interface + TDisplayMode DisplayMode() const; + TSize SizeInPixels() const; + TSize ScreenModeSizeInPixels() const; + TInt Stride() const; + CFbsBitGc::TGraphicsOrientation Orientation() const; + TInt SizeMode() const; + TSize ScalingFactor() const; + TPoint Origin() const; + TPoint ScaledOrigin() const; + // implementing MWsFrontBuffer + const TAny* GetBits(); + CFbsBitGc* GetBitGc(); + CFbsBitGc* GetBitGcCurrent(); + TInt SetBitGc(CFbsBitGc* aBitGc); + TInt SetBitGc(CFbsBitGc* aBitGc, TBool aInvalidateScreen); + inline TBool IsOffScreenBitmap(); + inline TBool MaskingEnabled(); + inline TBool BltOffScreen(); + void RecalcHeights(); + void DiscardAllSchedules(); + inline CDebugBar * DebugBar(); + inline CFallbackMap * FallbackMap(); + inline CWsSpriteManager* SpriteManager(); + inline MWsFader* Fader(); + TBool IsUpdatePending(); + void DSARegionSyncStart( CWsDirectScreenAccess& aDSA ); + void DSARegionSyncOver( CWsDirectScreenAccess& aDSA ); + TBool HasVisibleDirectOnQueue(); + TBool IsDSAClientWindow( const CWsClientWindow* aWin ) const; + void AcceptFadeRequest( CWsWindow* aWin, TBool aIsFaded, TBool aIsBehind, TBool aIncludeChildren = EFalse ); + +private: + enum TSyncConsts + { + KDSAAbortingImmediateRespAwaitFrameMicrosec = 80000 // 0.08 sec + }; +private: + void ChangeDisplayModeForAllOffScreenBitmap(TBool aSwapWidthAndHeight=EFalse); + void SetInitialScreenSizeMode(); + CWsWindowGroup* FindNewFocus(CWsRootWindow* aRootWindow); + void CreateFallbackMapL(); + void CreateScreenDeviceL(); + TBool DoCreateScreenDevice(TDisplayMode aScreenMode); +private: + enum + { + eTimerCreated=0x1, + }; + enum TDsaDrawState + { + EDsaDrawStateIdle, + EDsaDrawStateDrawing + }; +private: + TSglQue iDirects; + RTimer iTimer; + TRequestStatus iTimerStatus; + TUint iFlags; + + CScreenRedraw* iRedraw; + + CWsRootWindow* iRootWindow; + CWsWindowGroup *iCurrentFocus; + CWsWindowGroup *iDefaultOwningWindow; + CWsOffScreenBitmap* iOffScreenBitmap; + TPoint iShadowShift; + + CFbsScreenDevice *iScreenDevice; + CFbsBitGc *iScreenGdi; + +// Size and roation members + RPointerArray *iModes; + TInt iScreenSizeMode; + TScreenModeEnforcement iSizeEnforcementMode; + TSize iPhysicalScreenSize; + TInt iScreenNumber; + TInt iMaxContrast; + TInt iMaxBrightness; + TInt iNumScreenSizeModes; + TInt iNumSupportedScreenSizeModes; + TBool iBackLightFlag; + + // used by MWsFrontBuffer to redirect screen output + CFbsBitGc* iRedirectGc; + + TDsaDrawState iDsaDrawState; + CDebugBar* iDebugBar; + CFallbackMap* iFallbackMap; + TUint8 iBlackMap; + TUint8 iWhiteMap; + CWsSpriteManager* iSpriteManager; + MWsFader* iFader; + }; + + + +// +// inlines // +// + +// +// CScreen +// +inline void CScreen::Update(const TRegion &aRegion) + {iScreenDevice->Update(aRegion);} +inline TPoint CScreen::ShadowVector() + {return(iShadowShift);} +inline CWsWindowGroup* CScreen::FocusWindowGroup() + {return(iCurrentFocus);} +inline TBool CScreen::BlankScreenOnRotation() + {return(iFlags&EBlankScreenOnRotation);} +inline TBool CScreen::AutoClear() + {return(iFlags&EAutoClear);} +inline CWsWindowGroup* CScreen::DefaultOwningWindowGroup() + {return(iDefaultOwningWindow);} + +inline CWsRootWindow* CScreen::RootWindow() const + {return iRootWindow;} +inline TInt CScreen::ScreenNumber() const + {return iScreenNumber;} + +inline CFbsBitGc *CScreen::ScreenGdi() + {return(iScreenGdi);} +inline TDisplayMode CScreen::CurrentDisplayMode() + {return iScreenDevice->DisplayMode();} +inline TDisplayMode CScreen::DefaultDisplayMode() + {return iScreenDevice->DisplayMode();} +// +inline TInt CScreen::ScreenSizeMode() const + {return(iScreenSizeMode);} +inline TRect CScreen::GetPointerCursorArea(TInt aMode) const + {return (*iModes)[aMode]->iPointerCursorArea;} +inline TSize CScreen::CurrentScreenSize() const + {return (*iModes)[iScreenSizeMode]->iScreenSize;} +inline TInt CScreen::NumScreenSizeModes() const + {return iNumScreenSizeModes;} +inline const TSizeMode& CScreen::ScreenSizeModeData() const + {return *(*iModes)[iScreenSizeMode];} +inline const TSizeMode& CScreen::ScreenSizeModeData(TInt aMode) const + {return *(*iModes)[aMode];} +inline TPoint CScreen::ScreenModeOrigin(TInt aMode) + {return (*iModes)[aMode]->iOrigin;} +inline TPoint CScreen::CurrentScreenModeOrigin() + {return (*iModes)[iScreenSizeMode]->iOrigin;} +inline TSize CScreen::CurrentScreenModeScale() + {return (*iModes)[iScreenSizeMode]->iScreenScale;} +inline TPoint CScreen::CurrentScreenModeScaledOrigin() + {return (*iModes)[iScreenSizeMode]->ScaledOrigin();} +inline TPoint CScreen::ScreenModeScaledOrigin(TInt aMode) + {return (*iModes)[aMode]->ScaledOrigin();} +inline TSize CScreen::GetScreenScale(TInt aMode) const + {return (*iModes)[aMode]->iScreenScale;} +inline TDisplayMode CScreen::DefaultDisplayMode(const TInt aMode) const + {return (*iModes)[aMode]->iDefaultDisplayMode;} +inline TSize CScreen::GetPhysicalScreenSize() + {return iPhysicalScreenSize;} +inline void CScreen::SetScalingFactor() + {iScreenDevice->SetScalingFactor((*iModes)[iScreenSizeMode]->iOrigin,(*iModes)[iScreenSizeMode]->iScreenScale.iWidth,(*iModes)[iScreenSizeMode]->iScreenScale.iHeight,1,1);} +inline void CScreen::SetCurrentScreenModeAttributes(const TSizeMode &aModeData) + {*(*iModes)[iScreenSizeMode]=aModeData;} +inline void CScreen::SetPhysicalScreenSize() + {TInt temp=iPhysicalScreenSize.iWidth;iPhysicalScreenSize.iWidth=iPhysicalScreenSize.iHeight;iPhysicalScreenSize.iHeight=temp;} +inline TScreenModeEnforcement CScreen::SizeEnforcementMode() const + {return iSizeEnforcementMode;} +inline TBool CScreen::IsValidScreenSizeMode(TInt aMode) + {return (aMode>=0 && aModeCount() && (*iModes)[aMode]!=NULL);} +inline TBool CScreen::BackLightFlag() + {return iBackLightFlag;} +inline TBool CScreen::IsOffScreenBitmap() + {return iOffScreenBitmap!=NULL;} + +inline CDebugBar * CScreen::DebugBar() + {return iDebugBar;} +inline CScreen::CFallbackMap * CScreen::FallbackMap() + {return iFallbackMap;} + +inline void CScreen::GetFadingParams(TUint8& aBlackMap,TUint8& aWhiteMap) const + {aBlackMap=iBlackMap;aWhiteMap=iWhiteMap;} +inline void CScreen::SetFadingParams(TUint8 aBlackMap,TUint8 aWhiteMap) + {iBlackMap=aBlackMap;iWhiteMap=aWhiteMap;} +inline CWsSpriteManager* CScreen::SpriteManager() + {return iSpriteManager;} +inline MWsFader* CScreen::Fader() + {return iFader;} +inline TBool CScreen::BltOffScreen() + {return iFlags&EBltOffScreenBitmap;} +#endif