diff -r 000000000000 -r bde4ae8d615e os/graphics/windowing/windowserver/nga/SERVER/openwfc/windowelementset.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/windowelementset.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,250 @@ +// Copyright (c) 2006-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: +// + +#if !defined(__WINDOWELEMENTSET_H__) +#define __WINDOWELEMENTSET_H__ + +/** +@file +@internalComponent +*/ + +#include + +class CBase; +class CWsClientWindow; +class TSurfaceConfiguration; +class MWsScene; + +class TAttributes +{ +public: + TAttributes(){iFlags = 0;} + enum + { + EConcealed = 0x00000001, + EDrawnOver = 0x00000002, + EDrawnOverLast = 0x01000000, + }; + //flag accessors + inline TBool Concealed() const {return iFlags&EConcealed;} + inline void SetConcealed(TBool aSetting = ETrue) {aSetting?iFlags|=EConcealed:iFlags&=~EConcealed;} + inline TBool DrawnOver() const {return iFlags&EDrawnOver;} + inline void SetDrawnOver(TBool aSetting = ETrue) {aSetting?iFlags|=EDrawnOver:iFlags&=~EDrawnOver;} + inline TBool DrawnOverLast() const {return iFlags&EDrawnOverLast;} + inline void SetDrawnOverLast(TBool aSetting = ETrue) + { iFlags= aSetting? iFlags|EDrawnOverLast:iFlags&~EDrawnOverLast; } + inline TInt Flags()const + { return iFlags; } + TBool Destroy(MWsScene& aScene, TBool aUnregister); +public: + TInt DebugFlags()const { return iFlags; } +protected: + TUint iFlags; +public: + MWsElement* iElement; +}; + +class TBackgroundAttributes : public TAttributes +{ +public: + enum + { + EExplicitExtent = 0x00010000, + //EAbsoluteExtent = 0x00020000, //This would be used to represent wallpaper or DSA per window + EExplicitViewPort = 0x00040000, + }; + //flag accessors + inline TBool ExplicitExtent() const {return iFlags&EExplicitExtent;} + inline void SetExplicitExtent(TBool aSetting = ETrue) + { iFlags= aSetting? iFlags|EExplicitExtent:iFlags&~EExplicitExtent;} +//Absolute extent functionality is currently not required or used +// inline TBool AbsoluteExtent() const {return iFlags&EAbsoluteExtent;} +// inline void SetAbsoluteExtent(TBool aSetting = ETrue) +// { iFlags= aSetting? iFlags|EAbsoluteExtent:iFlags&~EAbsoluteExtent;} + inline TBool ExplicitViewPort() const {return iFlags&EExplicitViewPort;} + inline void SetExplicitViewPort(TBool aSetting = ETrue) + { iFlags = aSetting ? iFlags|EExplicitViewPort : iFlags&~EExplicitExtent;} +}; + +class TPlacedAttributes : public TAttributes +{ +public: + enum + { + EUnassigned = 0x00010000, + ELockedConfig = 0x00020000, + EChangedClip = 0x00040000, + EOverlapping = 0x00080000, + }; + //flag accessors + inline TBool Unassigned() const {return iFlags&EUnassigned ;} + inline void SetUnassigned(TBool aSetting = ETrue) + { iFlags= aSetting? iFlags|EUnassigned :iFlags&~EUnassigned; } + inline TBool LockedConfig() const {return iFlags&ELockedConfig ;} + inline void SetLockedConfig(TBool aSetting = ETrue) + {aSetting?iFlags|=ELockedConfig:iFlags&=~ELockedConfig;} + inline TBool ChangedClip() const {return iFlags&EChangedClip;} + inline void SetChangedClip(TBool aSetting = ETrue) + {aSetting?iFlags|=EChangedClip:iFlags&=~EChangedClip;} + inline TBool Overlapping() const {return iFlags&EOverlapping;} + inline void SetOverlapping(TBool aSetting = ETrue) + { iFlags= aSetting? iFlags|EOverlapping:iFlags&~EOverlapping; } + inline void ClearRedrawFlags() + { iFlags &= (~(EUnassigned|ELockedConfig|EChangedClip|EOverlapping)); } +}; + +class CWindowElement : public CBase +{ +friend class CWindowElementSet; +public: + enum + { + EFastPath = 0x00000001, + EPauseComposition = 0x00000002, //assign flags this if pause is needed immediately + EResort = 0x00000004, + EFailed = 0x00010000, //cleanup failure needs to be reported separately + }; + + CWindowElement(const CWsClientWindow& aWindow); + + TInt UnassignPlacedElements(const TRegion& aRegion,TInt aGcDrawingCount); + void FlagAssignedElementsDrawnOver(TInt aGcDrawingCount); + static TBool IsElementAMatch(MWsElement&,const TSurfaceConfiguration&,TInt); + static TInt SetElement(MWsElement&,const TSurfaceConfiguration&,TBool); + TBool InsertCache(TInt aIndexToInsert); + static void NotifyReleasingSurface(TSurfaceId aSurfaceId); + TInt AssignPlacedElement(TPlacedAttributes*& aPlacedAttributes, + const TSurfaceConfiguration& aSurfaceConfiguration, + const TRegion& aUserDefinedRegion, MWsScene& aScene,TInt aGcDrawingCount); + + TInt CleanUpPlacedElements(MWsScene& aScene,TInt aGcDrawingCount); + void MoveToAboveGivenElement(MWsScene& aScene, MWsElement* aAboveElement); + void UpdateElementExtent(const TPoint* aOffset); + TBool SetVisibleRegion(const TRegion& aRegion, MWsScene& aScene); + TInt ReleaseAllElements(); + TBool SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId); + void SetElementOpacity(TInt aOpacity, MWsScene& aScene); + void ResubmitAllElementExtents(); + MWsElement* Element() const; + +protected: + TInt AssignRecycleElement(const TInt aIndex, + const TSurfaceConfiguration& aSurfaceConfiguration, + const TRegion& aUserDefinedRegion, + MWsScene& aScene); + TInt AssignCreateElement(const TSurfaceConfiguration& aSurfaceConfiguration, + const TRegion& aUserDefinedRegion, + MWsScene& aScene); + TInt AssignExtendElement(const TInt aIndex, + const TSurfaceConfiguration& aSurfaceConfiguration, + const TRegion& aUserDefinedRegion, + MWsScene& aScene); + +public: + const CWsClientWindow& iWindow; +private: + TBackgroundAttributes iBackgroundElement; + RArray iPlacedElements; +private: //The following are all exclusively used during window rendering + RArray iCache; + //memory of surfaces that need to be removed + RArray iRemovedSurfaces; + TBool iRemovedSurfacesValid; + + RRegion iNonRedrawVisibleRegion; + TInt iHighestReusedIndex; + TInt iStartGcDrawingCount; + TUint iFlags; +}; + +/** +Owns the set of elements and their associated identification information. Only +references are provided for clients. +*/ +class CWindowElementSet : public CBase +{ +public: + static CWindowElementSet* NewL(MWsScene& aScene); + ~CWindowElementSet(); + TBackgroundAttributes& AcquireBackgroundElementL(CWsClientWindow& aWindow); + TInt ReleaseBackgroundElement(const CWsClientWindow&, TBool aWindowClosing = EFalse); + TInt ReleaseAllElements(const CWsClientWindow&, TBool aWindowClosing = EFalse); + TInt UnassignPlacedElements(const TRegion& aRedrawRegion, const CWsClientWindow& aWindow,TInt aGcDrawingCount); + TInt AssignPlacedElement(TPlacedAttributes*&, const TSurfaceConfiguration&, const TRegion& aUserDefinedRegion, + const CWsClientWindow&,TInt aGcDrawingCount); + TInt CleanUpPlacedElements(const CWsClientWindow& aWindow,TInt aGcDrawingCount); + TInt Count() const; + TBackgroundAttributes* FindBackgroundElement(const CWsClientWindow&); + TBool FindElements(const CWsClientWindow&,const TBackgroundAttributes*&,const RArray*&); + TInt RegisterSurface(const TSurfaceId& aSurface); + void UnregisterSurface(const TSurfaceId& aSurface); + TBool SortByZOrder(); + TInt SetVisibleRegion(CWsClientWindow& aWindow); //cant be a const win as VisibleRegion() isnt const?? + void UpdateElementExtent(const CWsClientWindow&, const TPoint* aOffset); + static TInt GetConfiguration(TSurfaceConfiguration&,MWsElement&); + TBool SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId); + void SetElementOpacity(CWsClientWindow& aWindow, TInt aOpacity); + void ResubmitAllElementExtents(); + MWsElement* GetElementFromWindow(const CWsClientWindow& aWindow) const; + +public: + const CWsClientWindow* DebugWindowAt(TUint aWin)const; + const TBackgroundAttributes* DebugBackgroundAt(TUint aWin)const; + const TPlacedAttributes* DebugPlacedAt(TUint aWin,TUint aPlace)const; +//Note: The following methods are currently unused +// const TPlacedAttributes* DebugPlacedAt(const CWsClientWindow& aWindow,TInt aPlace)const; +// const RRegion* DebugCacheAt(TInt aWin,TInt aPlace)const; + TInt DebugPlacedCountAt(TUint aWin)const; + +protected: + CWindowElement* FindElement(const CWsClientWindow& aWindow) const; + +private: + CWindowElementSet(MWsScene& aScene); + TInt FindEntry(const CWsClientWindow& aWindow, TInt& aIndex, TBool aLinearSearch = EFalse) const; + static TBool WindowMatch(const CWindowElement& aFirst, const CWindowElement& aSecond); + static TInt WindowOrder(const CWindowElement& aFirst, const CWindowElement& aSecond); + void DestroyWindowElementEntry(const TInt aWinElementIndex); + +private: + RPointerArray iElements; + MWsScene& iScene; +}; + +/** Gc to element rotation function +*/ +inline MWsElement::TElementRotation GcToElementRotation(CFbsBitGc::TGraphicsOrientation aGcRotation) + { + MWsElement::TElementRotation elementRotation = MWsElement::EElementAntiClockwise0; + + switch (aGcRotation) + { + case CFbsBitGc::EGraphicsOrientationRotated90: + elementRotation = MWsElement::EElementAntiClockwise90; + break; + case CFbsBitGc::EGraphicsOrientationRotated180: + elementRotation = MWsElement::EElementAntiClockwise180; + break; + case CFbsBitGc::EGraphicsOrientationRotated270: + elementRotation = MWsElement::EElementAntiClockwise270; + break; + default: + break; + } + return elementRotation; + } + +#endif // !defined(__WINDOWELEMENTSET_H__)