// 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 <graphics/wselement.h>

 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<TPlacedAttributes> iPlacedElements;

 private:	//The following are all exclusively used during window rendering

 	RArray<RRegion> iCache;

 	//memory of surfaces that need to be removed

 	RArray<TSurfaceId> 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<TPlacedAttributes>*&);	

 	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<CWindowElement> 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__)