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