// 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:
//

#include <e32std.h>
#include "cliwin.h"
#include "server.h"
#include "windowelementset.h"
#include "regionextend.h"
#include <graphics/wsscene.h>
#include <graphics/wsgraphicdrawer.h>
#include "panics.h"
#include "wstop.h"

#include "EVENT.H"

#ifndef KCacheListGranularity
	enum	{KCacheListGranularity = 8};
#endif
#ifndef KCacheExtensionReserve
	enum	{KCacheExtensionReserve = 1};
#endif
	


/** Element to gc rotation function
*/
LOCAL_C inline CFbsBitGc::TGraphicsOrientation ElementToGcRotation(MWsElement::TElementRotation aElementRotation)
	{
	CFbsBitGc::TGraphicsOrientation gcRotation = CFbsBitGc::EGraphicsOrientationNormal;

	switch (aElementRotation)
		{
		case MWsElement::EElementAntiClockwise90:
			gcRotation = CFbsBitGc::EGraphicsOrientationRotated90;
			break;
		case MWsElement::EElementAntiClockwise180:
			gcRotation = CFbsBitGc::EGraphicsOrientationRotated180;
			break;
		case MWsElement::EElementAntiClockwise270:
			gcRotation = CFbsBitGc::EGraphicsOrientationRotated270;
			break;
		default:
			break;
		}
	return gcRotation;
	}

//
// CWindowElement
//

CWindowElement::CWindowElement(const CWsClientWindow& aWindow) :
	iWindow(aWindow), iCache(KCacheListGranularity), iHighestReusedIndex(-1)
	{}


/** Finds all elements within the window that overlap with the region and 
marks them as unassigned.
If any part of these unassigned elements are outside the region, they are also 
marked overlapping and locked config.

@param aRegion The region that is being redrawn.
@return KErrNone on success or KErrNoMemory if critical calculations could not be made.

@see CWindowElementSet::UnassignPlacedElements
**/
TInt CWindowElement::UnassignPlacedElements(const TRegion& aRegion,TInt aGcDrawingCount)
	{
	iFlags = 0;	//reset flags
	iStartGcDrawingCount = aGcDrawingCount;	//Detect any drawing between calls
	iBackgroundElement.SetDrawnOverLast(iBackgroundElement.DrawnOver());
	iNonRedrawVisibleRegion.Clear();
	iNonRedrawVisibleRegion.Copy(const_cast<CWsClientWindow&>(iWindow).VisibleRegion());
	iNonRedrawVisibleRegion.SubRegion(aRegion);
	if (iNonRedrawVisibleRegion.CheckError())
		{	//memory error. Still needs to cope if whole window is being redrawn
		iNonRedrawVisibleRegion.Clear();
		TInt fullWindowRedraw = TRegionExtend::Cast(aRegion).TestDifference(const_cast<CWsClientWindow&>(iWindow).VisibleRegion());
		if (fullWindowRedraw != 0)
			{	//not a full window redraw, return immediately
			return KErrNoMemory;
			}
		}	
	TInt placedElements = iPlacedElements.Count();
	TInt unassignedCount = 0;
	TInt ii;
	TBool cacheError = EFalse;

	STACK_REGION tempSurfaceBaseArea;
	if (iCache.Reserve(placedElements + KCacheExtensionReserve) < KErrNone)	//quite often there may need to be room for more
		{	//failed to reserve space
		cacheError = ETrue;
		}
	TRect tempExtent;
	TRect tempIntersect;
	
	for (ii=0; ii<placedElements; ii++)
		{
		if (!cacheError)
			{	//cache is ok up to this point but does not contain cache for this element yet
			RRegion newRegion;
			if (iCache.Append(newRegion) < KErrNone)
				{
				cacheError = ETrue;
				}
			newRegion.Close();
			}

		iPlacedElements[ii].iElement->GetDestinationRectangle(tempExtent);
		TInt regionReturn = TRegionExtend::Cast(aRegion).TestDifference(tempExtent);
		iPlacedElements[ii].SetDrawnOverLast(iPlacedElements[ii].DrawnOver());	//allows detection of change of state
		if (!(regionReturn&TRegionExtend::ENoIntersect))
			{	//redraw region intersects with element
			iPlacedElements[ii].SetUnassigned();
			iPlacedElements[ii].SetDrawnOver(EFalse);
			unassignedCount++;
			
			if (!(regionReturn&TRegionExtend::EAdd))
				{	//surface is entirely within the redraw region
				iPlacedElements[ii].SetOverlapping(EFalse);
				iPlacedElements[ii].SetLockedConfig(EFalse);
				if(!cacheError)
					{
					TRect destinationRect;
					tempSurfaceBaseArea.Clear();
                    iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);
					tempSurfaceBaseArea.AddRect(destinationRect);
					if (!tempSurfaceBaseArea.CheckError())
						{
						tempSurfaceBaseArea.Offset(tempExtent.iTl);	//cache needs to be in absolute coords
						iCache[ii].Copy(tempSurfaceBaseArea);
						}
					if (tempSurfaceBaseArea.CheckError() || iCache[ii].CheckError())
						{	//cache is no good from this point onwards
						iCache[ii].Close();
						iCache.Remove(ii);
						cacheError = ETrue;
						}
					}
				}
			else
				{
                TRect destinationRect;
                tempSurfaceBaseArea.Clear();
                iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);
                tempSurfaceBaseArea.AddRect(destinationRect);
				if (tempSurfaceBaseArea.CheckError())
					{	//critical failure, clear cache and return error
					for (ii=iCache.Count(); ii>0; ii--)
						{
						iCache[ii-1].Close();
						iCache.Remove(ii-1);
						}
					iCache.Reset();
					iNonRedrawVisibleRegion.Close();
					tempSurfaceBaseArea.Close();
					return KErrNoMemory;
					}
				else
					{
					tempSurfaceBaseArea.Offset(tempExtent.iTl);	//change to absolute coordinates
					regionReturn = TRegionExtend::Cast(iNonRedrawVisibleRegion ).TestDifference(tempSurfaceBaseArea);
					if (regionReturn&TRegionExtend::ENoIntersect)
						{	//element base area entirely inside redraw region
						iPlacedElements[ii].SetOverlapping(EFalse);
						iPlacedElements[ii].SetLockedConfig(EFalse);
						}
					else
						{	//element base area is at least partly within non redraw visible region
						iPlacedElements[ii].SetOverlapping(ETrue);
						iPlacedElements[ii].SetLockedConfig(ETrue);
						}
					if(!cacheError)
						{
						iCache[ii].Copy(tempSurfaceBaseArea);
						if (iCache[ii].CheckError())
							{	//cache is no good from this point onwards
							iCache[ii].Close();
							iCache.Remove(ii);
							cacheError = ETrue;
							}
						}
					}
				}
			}
		else
			{	//element does not intersect with redraw region
			iPlacedElements[ii].SetUnassigned(EFalse);
			}
		}
	tempSurfaceBaseArea.Close();
	
	if (iRemovedSurfaces.Reserve(unassignedCount) == KErrNone)
		{
		iRemovedSurfacesValid = ETrue;
		}
	else
		{
		iRemovedSurfacesValid = EFalse;
		}
	return KErrNone;
	}

/** Marks all elements that have been assigned since the unassign as drawn over.

@see CWindowElementSet::FlagAssignedElementsDrawnOver
**/
void CWindowElement::FlagAssignedElementsDrawnOver(TInt aGcDrawingCount)
	{
	iStartGcDrawingCount = aGcDrawingCount;
	if (iBackgroundElement.iElement)
		{
		iBackgroundElement.SetDrawnOver();
		}
	TInt placedElementCount = iPlacedElements.Count();
	for (TInt ii = 0; ii < placedElementCount; ii++)
		{
		if(!iPlacedElements[ii].Unassigned() && iPlacedElements[ii].LockedConfig())
			{
			iPlacedElements[ii].SetDrawnOver();
			}
		else if(iPlacedElements[ii].Unassigned() && iPlacedElements[ii].LockedConfig() &&
				!iPlacedElements[ii].ChangedClip() && iPlacedElements[ii].Overlapping())
			{
			iPlacedElements[ii].SetDrawnOver();
			}
		}
	}

/** Checks whether a elements configuration is the same as that of the surface configuration, taking
into account the stateflags (TPlacedAttributes) passed in.
It must match surfaceId and extent.
If it is a locked config it will need to match viewport and orientation as well.

@param aElement Element to compare against.
@param aSurfaceConfiguration Configuration to compare.
@param aStateFlags The TPlacedAttributes flags for the element.
@return ETrue if a match, otherwise EFalse.
*/
TBool CWindowElement::IsElementAMatch(MWsElement& aElement, const TSurfaceConfiguration& aSurfaceConfiguration,
		TInt aStateFlags)
	{
	TBool match = EFalse;
	
	TRect tempElementExtent;
	TRect tempCRPExtent;
	aElement.GetDestinationRectangle(tempElementExtent);
	aSurfaceConfiguration.GetExtent(tempCRPExtent);
	if (tempElementExtent == tempCRPExtent)
		{
		TSurfaceId tempElementSurfaceId;
		TSurfaceId tempCRPSurfaceId;
		aSurfaceConfiguration.GetSurfaceId(tempElementSurfaceId);
		tempCRPSurfaceId = aElement.ConnectedSurface();
		if (tempElementSurfaceId == tempCRPSurfaceId)
			{
			match = ETrue;
			if (aStateFlags&TPlacedAttributes::ELockedConfig)
				{
				match = EFalse;
				TBool orientationOK = EFalse;
				TRect tempCRPViewport;
				aSurfaceConfiguration.GetViewport(tempCRPViewport);
				//if explicit viewport flagged
				TRect tempElementViewport;
				aElement.GetSourceRectangle(tempElementViewport);
				if (tempElementViewport == tempCRPViewport)
					{
					CFbsBitGc::TGraphicsOrientation tempElementOrientation;
					MWsElement::TElementRotation tempCRPRotation;
					CFbsBitGc::TGraphicsOrientation tempCRPOrientation;
					tempElementOrientation = aSurfaceConfiguration.Orientation();
					tempCRPRotation = aElement.SourceRotation();
					tempCRPOrientation = ElementToGcRotation(tempCRPRotation);	//convert to common type
					if (tempElementOrientation == tempCRPOrientation)
						{
						orientationOK = ETrue;
						}
					}
				if(orientationOK)
				    {
				    TBool tempElementFlip = aSurfaceConfiguration.Flip();
				    TBool tempCRPFlip = aElement.SourceFlipping();
				    if(tempElementFlip == tempCRPFlip)
				        {
				        match = ETrue;
				        }
				    }
				}
			}
		}
	return match;
	}

/** Sets the surfaceconfiguration to the element.

@param aElement The element to set.
@param aSurfaceConfiguration The configuration to set to the element.
@param aLimitedSet Set all values if EFalse, otherwise only set viewport and orientation.
@return KErrNone on success, error from compositor if it could not set the surface id.
*/
TInt CWindowElement::SetElement(MWsElement& aElement, const TSurfaceConfiguration& aSurfaceConfiguration, TBool aLimitedSet)
	{	//aLimitedSet - EFalse = set all . ETrue = set viewport and orientation only
	if (!aLimitedSet)
		{
		//set surface id
		TSurfaceId newSurfaceId;
		aSurfaceConfiguration.GetSurfaceId(newSurfaceId);
		TInt error = aElement.ConnectSurface(newSurfaceId);
		if (error != KErrNone)
			{
			return error;
			}
		
		//set extent
		TRect newExtent;
		aSurfaceConfiguration.GetExtent(newExtent);
		aElement.SetDestinationRectangle(newExtent);
		}
	
	//set viewport
	TRect newViewport;
	aSurfaceConfiguration.GetViewport(newViewport);
	if (newViewport.iTl.iX < 0 || newViewport.iTl.iY < 0)
		{
		return KErrArgument;
		}
	
	if (!newViewport.IsEmpty())
		{	//need to check if viewport is valid size
		TInt error = aElement.SetSourceRectangle(newViewport);
        if (error != KErrNone)
            {
            return error;
            }
		}

	//set orientation
	//Note for compatibility with Oghma:
	//This method does not properly error check or return KErrArgument,
	//as that would propagate a client panic in SetBackgroundSurface which did not previously occur.
	aElement.SetSourceRotation(GcToElementRotation(aSurfaceConfiguration.Orientation()));
	// Set or clear flip if the element flags are changing
	if ( (!aSurfaceConfiguration.Flip()) != (!aElement.SourceFlipping()) ) 
	    {
        aElement.SetSourceFlipping(!aElement.SourceFlipping());
	    }
	return KErrNone;
	}

/** Attempts to insert a region cache in to the the windows iCache.
If it fails, it will remove all cache beyond its index as it is now out of step.

@param aIndexToInsert The index of where to insert the cache.
@return ETrue on success, else EFalse.
*/

TBool CWindowElement::InsertCache(TInt aIndexToInsert)
	{
	RRegion newRegion;
	TInt cacheInsertError = iCache.Insert(newRegion, aIndexToInsert);
	if (cacheInsertError == KErrNone)
		{
		newRegion.Close(); 
		return ETrue;	//inserted cache
		}
	if (iCache.Count() > aIndexToInsert)
		{	//if insert failed and there is more cache above where its trying to insert
		iCache.Remove(iCache.Count()-1);
		cacheInsertError = iCache.Insert(newRegion, aIndexToInsert);
		
		if (cacheInsertError == KErrNone)
			{
			newRegion.Close();
			return ETrue;	//inserted cache
			}
		}
	
	//cant insert this cache, there may be invalid cache to destroy
	TInt count = iCache.Count();
	while(count > aIndexToInsert)
		{	//if there is cache where we wished to insert, it and everything above is now invalid
		iCache[count-1].Close();
		iCache.Remove(count-1);
		count--;
		};
	newRegion.Close();
	return EFalse;	//failed to insert
	}

/** Will send a notification that a surface being unreferenced if it is not
found in any WindowElementSet

@pre Make sure the element being removed has already had its surfaceid set to NULL.
@param aSurfaceId The surface being removed
*/
void CWindowElement::NotifyReleasingSurface(TSurfaceId aSurfaceId)
	{
	if (CWsTop::SearchDuplicateSurfaceId(aSurfaceId) == EFalse)
		{	//NOT found other instance of surface id, send notification now
		TWservCrEvent crEvent(TWservCrEvent::ESurfaceUnreferenced, sizeof(aSurfaceId), &aSurfaceId);
		TWindowServerEvent::NotifyDrawer(crEvent);
		}
	}

/** Called to place a element within the window.
It will either create a new element, recycle a element, or extend a element .

@pre UnassignPlacedElements has already been called.
@param aPlacedAttributes Returns the attributes of the surface placed.
@param aSurfaceConfiguration The surface configuration for the surface to place.
@param aUserDefinedRegion The user defined clipping of the window.
@param aScene Access to the scene.
@return Serious error, otherwise flags to describe what extra work needs doing.

@see CWindowElementSet::AssignPlacedElement
*/
TInt CWindowElement::AssignPlacedElement(
		TPlacedAttributes*& aPlacedAttributes,
		const TSurfaceConfiguration& aSurfaceConfiguration,
		const TRegion& aUserDefinedRegion,
		MWsScene& aScene,
		TInt	aGcDrawingCount
		)
	{	
	if (iStartGcDrawingCount!=aGcDrawingCount)
		{
		FlagAssignedElementsDrawnOver(aGcDrawingCount);
		}

	if (iNonRedrawVisibleRegion.CheckError())
		{
		//CANNOT DO ANYTHING, LEAVE
		return KErrNotReady;	//error
		}

	TRect surfaceExtent;
	aSurfaceConfiguration.GetExtent(surfaceExtent);
	if (!aUserDefinedRegion.Intersects(surfaceExtent))
		{
		//clippedRegion.Close();
		return KErrCancel;	//no intersection, so nothing to do
		}

	TInt matchFound = -1;
	
	//check 'current' (last placed element) to see if it is a match
	if (iHighestReusedIndex != -1)
		{
		if (IsElementAMatch(*(iPlacedElements[iHighestReusedIndex].iElement),aSurfaceConfiguration,iPlacedElements[iHighestReusedIndex].Flags()) )
			{
			matchFound = iHighestReusedIndex;
			}
		}

	if (matchFound == -1)
		{
		//check current unassigned elements to see if there is a match
		for (TInt ii = (iHighestReusedIndex == -1)?0:iHighestReusedIndex+1; ii < iPlacedElements.Count(); ii++)
			{
			if (IsElementAMatch(*(iPlacedElements[ii].iElement),aSurfaceConfiguration,iPlacedElements[ii].Flags()))
				{
				matchFound = ii;
				break;
				}
			}
		}
	TInt returnValue = 0;
	if (matchFound == -1)
		{	//not found a element to extend
		//iResort = ETrue;
		matchFound = 0;
		while(1)
			{
			if (iPlacedElements.Count() == 0 || iHighestReusedIndex == -1 || matchFound == iHighestReusedIndex)	//reached last re assigned element, so cannot reuse one
				{
				matchFound = -1;
				break;
				}
			if (iPlacedElements[matchFound].Unassigned() && !iPlacedElements[matchFound].LockedConfig())	//found a element to reuse
				{
				break;
				}
			matchFound++;
			};

		if (matchFound != -1)
			{	//found a element to recycle
			returnValue = AssignRecycleElement(matchFound,aSurfaceConfiguration,aUserDefinedRegion,aScene);
			}
		else
			{	//need to create a new element
			returnValue = AssignCreateElement(aSurfaceConfiguration,aUserDefinedRegion,aScene);
			}
		}
	else
		{	//found a candidate to extend
		returnValue = AssignExtendElement(matchFound,aSurfaceConfiguration,aUserDefinedRegion,aScene);
		}
	if (returnValue < KErrNone)
		{	//failed with error
			return returnValue;
		}
	aPlacedAttributes = &iPlacedElements[iHighestReusedIndex];
	iFlags|=returnValue;	//update window wide flags
	return returnValue;
	}

/** Recycle a element assigned to the window.

@param aIndex The index of the placed element to recycle.
@param aSurfaceConfiguration The surface configuration for the surface to place.
@param aUserDefinedRegion The user defined clipping of the window.
@param aScene Access to the scene.
@return Serious error, otherwise flags to describe what extra work needs doing.

@see CWindowElement::AssignPlacedElement
*/
TInt CWindowElement::AssignRecycleElement(const TInt aIndex, const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& aScene)
	{
	TInt returnValue = 0;
	TInt error = KErrNone;
	STACK_REGION clippedRegion;
	TRect surfaceExtent;
	aSurfaceConfiguration.GetExtent(surfaceExtent);
	clippedRegion.AddRect(surfaceExtent);
	clippedRegion.Intersect(aUserDefinedRegion);
	if (clippedRegion.CheckError())
		{	//failed crucial calculation, leave while nothing has been changed!
		clippedRegion.Close();
		return KErrNoMemory;
		}
	WS_ASSERT_DEBUG(!clippedRegion.IsEmpty(),EWsPanicRegion);
	if (clippedRegion.IsEmpty())
		{
		return KErrArgument;
		}
	
	//keep note of surface being removed
	TSurfaceId oldSurfaceId = iPlacedElements[aIndex].iElement->ConnectedSurface();
	
	//set element with new attributes
	error = SetElement(*(iPlacedElements[aIndex].iElement),aSurfaceConfiguration,EFalse);
	
	if (error < KErrNone)
		{	//must be a bad surface id or bad viewport, leave while nothing has been changed!
		clippedRegion.Close();
		return error;
		}
	
	returnValue|=EFastPath;
	returnValue|=EPauseComposition;
	//element has been altered, must make sure old surface unreferenced notify will be called
	if (!iRemovedSurfacesValid)
		{	//didnt reserve space for surface ids, do search immediately
		NotifyReleasingSurface(oldSurfaceId);
		}
	else
		{	//keep memory of surface id - search will be done during cleanup. Space already been reserved
		iRemovedSurfaces.Append(oldSurfaceId);
		}

	//order placed element correctly in iPlacedElements
	TPlacedAttributes tempAttributes = iPlacedElements[aIndex];
	iPlacedElements.Remove(aIndex);
	//keep cache up to date
	if (iCache.Count() > aIndex)
		{
		iCache[aIndex].Close();
		iCache.Remove(aIndex);
		}

	WS_ASSERT_DEBUG(iHighestReusedIndex != -1,EWsPanicRecycleElement);
	if (iHighestReusedIndex == -1)
		{
		return KErrArgument;
		}
	
	error = iPlacedElements.Insert(tempAttributes, iHighestReusedIndex);
	if (error < KErrNone)
		{	//must destroy the element and leave.  Old elements surface unregistration already dealt with
		aScene.DestroySceneElement(tempAttributes.iElement);
		clippedRegion.Close();
		return KErrNoMemory;
		}
	returnValue|=EResort;	//element has been moved, will need a resort
	//set placed element attributes
	iPlacedElements[iHighestReusedIndex].SetUnassigned(EFalse);
	iPlacedElements[iHighestReusedIndex].SetLockedConfig(ETrue);
	iPlacedElements[iHighestReusedIndex].SetChangedClip(ETrue);
	
	TRect tempViewport;
	aSurfaceConfiguration.GetViewport(tempViewport);

	TBool cacheSaved = EFalse;
	if (iCache.Count() >= iHighestReusedIndex)
		{	//need to update cache with visible region of element
		TBool insertSuccess = InsertCache(iHighestReusedIndex);
		if (insertSuccess != EFalse)
			{
			iCache[iHighestReusedIndex].Copy(clippedRegion);
			if (!iCache[iHighestReusedIndex].CheckError())
				{
				cacheSaved = ETrue;
				}
			}
		}
	if (cacheSaved == EFalse)
		{	//need to set clipping to element immediately
		TInt count = iCache.Count();
		while(count > iHighestReusedIndex)
			{	//if there is cache where we wished to insert, it and everything above is now invalid
			iCache[count-1].Close();
			iCache.Remove(count-1);
			count--;
			};
		}
	clippedRegion.Close();
	return returnValue;
	}

/** Create a new element for the placed surface.

@param aSurfaceConfiguration The surface configuration for the surface to place.
@param aUserDefinedRegion The user defined clipping of the window.
@param aScene Access to the scene.
@return Serious error, otherwise flags to describe what extra work needs doing.

@see CWindowElement::AssignPlacedElement
*/
TInt CWindowElement::AssignCreateElement(const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& aScene)
	{
	TInt returnValue = 0;
	TInt error = KErrNone;
	STACK_REGION clippedRegion;
	TRect surfaceExtent;
	aSurfaceConfiguration.GetExtent(surfaceExtent);
	//calculate region
	clippedRegion.AddRect(surfaceExtent);
	clippedRegion.Intersect(aUserDefinedRegion);
	if (clippedRegion.CheckError())
		{	//failed, return KErrNoMemory
		clippedRegion.Close();
		return KErrNoMemory;
		}
	
	TPlacedAttributes newElement;
	if (iHighestReusedIndex == -1)
		{
		error = iPlacedElements.Insert(newElement,0);
		}
	else
		{	//insert above current highest reused element
		error = iPlacedElements.Insert(newElement,iHighestReusedIndex+1);
		}
	if (error >= KErrNone)
		{
		iHighestReusedIndex++;
		}
	else
		{
		//FAILED! LEAVE FUNCTION. nothing has been changed
		clippedRegion.Close();
		return KErrNoMemory;
		}

	//create new element with new configuration
	MWsElement* element = NULL;
	TRAP(error,element = aScene.CreateSceneElementL());
	if (error != KErrNone)
		{
		//FAILED! LEAVE FUNCTION. nothing has been changed
		clippedRegion.Close();
		return error;
		}

	element->SetGlobalAlpha( 0xFF );

	iPlacedElements[iHighestReusedIndex].iElement = element;
	error = SetElement(*element,aSurfaceConfiguration,EFalse);
	if (error < KErrNone)
		{
		//must be a bad surface id or viewport. Leave now.
		aScene.DestroySceneElement(element);
		clippedRegion.Close();
		iPlacedElements.Remove(iHighestReusedIndex);
		iHighestReusedIndex--;
		return error;
		}
	
	//Now certain that these must be flagged
	returnValue|=EFastPath;
	returnValue|=EPauseComposition;
	returnValue|=EResort;

	//set placed element attributes
	iPlacedElements[iHighestReusedIndex].SetUnassigned(EFalse);
	iPlacedElements[iHighestReusedIndex].SetChangedClip(ETrue);
	iPlacedElements[iHighestReusedIndex].SetLockedConfig(ETrue);
	
	TRect tempViewport;
	aSurfaceConfiguration.GetViewport(tempViewport);

	TBool cacheSaved = EFalse;
	if (iCache.Count() >= iHighestReusedIndex)
		{	//should try to add new elements region to cache
		TBool insertSuccess = InsertCache(iHighestReusedIndex);
		if (insertSuccess != EFalse)
			{
			iCache[iHighestReusedIndex].Copy(clippedRegion);
			if (!iCache[iHighestReusedIndex].CheckError())
				{
				cacheSaved = ETrue;
				}
			}
		}
	if (cacheSaved == EFalse)
		{	//need to clear cache from this point onward, and set clipping to element immediately
		TInt count = iCache.Count();
		while(count > iHighestReusedIndex)
			{	//if there is cache where we wished to insert, it and everything above is now invalid
			iCache[count-1].Close();
			iCache.Remove(count-1);
			count--;
			};
		}
	//add the new element to the scene
    error = aScene.InsertSceneElement(element, NULL);    //place at the back. will get ordered correctly later
	WS_ASSERT_DEBUG(error == KErrNone,EWsPanicSceneErrorIgnored);
	clippedRegion.Close();
	return returnValue;
	}

/** Extend an existing placed surface element.

@param The index of the element to extend.
@param aSurfaceConfiguration The surface configuration for the surface to place.
@param aUserDefinedRegion The user defined clipping of the window.
@param aScene Access to the scene.
@return Serious error, otherwise flags to describe what extra work needs doing.

@see CWindowElement::AssignPlacedElement
*/
TInt CWindowElement::AssignExtendElement(const TInt aIndex, const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& /*aScene*/)
	{
	TInt returnValue = 0;
	TInt error = KErrNone;
	STACK_REGION backupRegionAgainstFail;
	STACK_REGION clippedRegion;
	TRect surfaceExtent;
	aSurfaceConfiguration.GetExtent(surfaceExtent);
	TRect surfaceViewport;
	aSurfaceConfiguration.GetViewport(surfaceViewport);
	
	if (!iPlacedElements[aIndex].LockedConfig())
		{	//set element now. If viewport is invalid its ok to fail now
		error = SetElement(*iPlacedElements[aIndex].iElement,aSurfaceConfiguration,ETrue);
		if (error < KErrNone)
			{
			backupRegionAgainstFail.Close();
			clippedRegion.Close();
			return error;
			}
		}

	if(iPlacedElements[aIndex].Unassigned() && !iPlacedElements[aIndex].Overlapping())
		{
		//backup stays clear
		clippedRegion.Copy(aUserDefinedRegion);
		}
	else
		{
		clippedRegion.Copy(iNonRedrawVisibleRegion);
		if (iCache.Count() > aIndex)	//if cache is ok
			{
			clippedRegion.Intersect(iCache[aIndex]);
			clippedRegion.Union(iCache[aIndex]);	//previously added regions should be kept
			}
		else
			{
			STACK_REGION tempSurfaceBaseArea;
            TRect destinationRect;
            iPlacedElements[aIndex].iElement->GetDestinationRectangle(destinationRect);
            tempSurfaceBaseArea.AddRect(destinationRect);
			tempSurfaceBaseArea.Offset(surfaceExtent.iTl);
			clippedRegion.Intersect(tempSurfaceBaseArea);
			clippedRegion.Union(tempSurfaceBaseArea);
			tempSurfaceBaseArea.Close();
			}
		backupRegionAgainstFail.Copy(clippedRegion);
		//clipped region should contain something
		clippedRegion.Union(aUserDefinedRegion);
		}
	clippedRegion.ClipRect(surfaceExtent);
	
	if (backupRegionAgainstFail.CheckError() || clippedRegion.CheckError())
		{	//failed critical calculations, leave now before anything has been changed
		clippedRegion.Close();
		backupRegionAgainstFail.Close();
		return KErrNoMemory;
		}

	TBool setCache = EFalse;
	if (iCache.Count() > aIndex)	//if Cache is ok
		{
		//compare
		TInt compareReturn;
		compareReturn = TRegionExtend::Cast(iCache[aIndex]).TestDifference(clippedRegion);

		if (compareReturn&TRegionExtend::EDiffers)	//element has changed
			{
			iPlacedElements[aIndex].SetChangedClip(ETrue);
			if (compareReturn&TRegionExtend::EAdd)	//element has become revealed on the screen
				{
				returnValue|=EPauseComposition;	//need to pause before the end of assign placed element
				}
			else
				{
				returnValue|=EFastPath;	//fastpath and pause will be called during cleanup
				}
			}
		
		//copy clipped region to cache
		iCache[aIndex].Copy(clippedRegion);	//can fail
		setCache = ETrue;
		if (iCache[aIndex].CheckError())
			{	//copy failed, remove cache from this element onwards
			TInt count = iCache.Count();
			while(count > aIndex)
				{	//if there is cache where we wished to insert, it and everything above is now invalid
				iCache[count-1].Close();
				iCache.Remove(count-1);
				count--;
				};
			setCache = EFalse;
			}
		}
	if (setCache == EFalse)
		{	//need to pause composition and update element immediately
		returnValue|=EPauseComposition;
		}
	iPlacedElements[aIndex].SetUnassigned(EFalse);
	iPlacedElements[aIndex].SetLockedConfig(ETrue);
	iHighestReusedIndex = aIndex;
	backupRegionAgainstFail.Close();
	clippedRegion.Close();
	return returnValue;
	}

/** Called at the end of a redraw to set cached changed to elements, and
removed elements that are still unassigned.

@param aScene Access to the scene.
@return Flags to describe what extra work needs doing.
@see CWindowElementSet::CleanUpPlacedElements
*/
TInt CWindowElement::CleanUpPlacedElements(MWsScene& aScene, TInt aGcDrawingCount)
	{
	if (iStartGcDrawingCount!=aGcDrawingCount)
		{
		FlagAssignedElementsDrawnOver(aGcDrawingCount);
		}
	TInt returnFlags = iFlags;
	if (iFlags > 0)
		{	//copy flags to return, and ensure pause is flagged
		returnFlags|=EPauseComposition;
		}
	TInt ii;
	TBool removeElements = EFalse;
	//destroy placed element reference
	for (ii=0; ii<iPlacedElements.Count(); ii++)
		{
		if (iPlacedElements[ii].Unassigned() && !iPlacedElements[ii].Overlapping())
			{
			returnFlags|=EFastPath;	//need to invoke 1108
			if (iRemovedSurfacesValid)
				{
				iRemovedSurfaces.Append(iPlacedElements[ii].iElement->ConnectedSurface());
				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
				}
			else
				{
				TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();
				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
				NotifyReleasingSurface(tempId);
				}
			removeElements = ETrue;
			}
		}

	if (removeElements)
		{	//there will be elements to remove
		for (ii=0; ii<iPlacedElements.Count(); ii++)
			{
			if (iPlacedElements[ii].iElement->ConnectedSurface().IsNull())
				{
				aScene.DestroySceneElement(iPlacedElements[ii].iElement);
				iPlacedElements.Remove(ii);
				if (iCache.Count() > ii)
					{	//there is cache for this element, remove it
					iCache[ii].Close();
					iCache.Remove(ii);
					}
				ii--;
				}
			}
		}

	if (iRemovedSurfaces.Count() > 1)
		{	//remove duplicates of surface id from removal list
		for (ii = 0; ii < iRemovedSurfaces.Count() - 1; ii++)
			{
			for (TInt jj = ii+1; jj < iRemovedSurfaces.Count(); jj++)
				{
				if (iRemovedSurfaces[ii] == iRemovedSurfaces[jj])
					{
					iRemovedSurfaces.Remove(jj);
					jj--;
					}
				}
			}
		}
	
	//do global search for surface ids
	while (iRemovedSurfaces.Count()>0)
		{
		TInt tempRemoval = iRemovedSurfaces.Count() - 1;
		NotifyReleasingSurface(iRemovedSurfaces[tempRemoval]);
		iRemovedSurfaces.Remove(tempRemoval);
		};

	iRemovedSurfaces.Reset();

	//clip unassigned overlapping entries, mark as changedclip if region changed
	for (ii=0; ii<iPlacedElements.Count(); ii++)
		{
		if (iPlacedElements[ii].Unassigned())	//non overlapping unassigned have already been destroyed
			{	//these must overlap
			TBool failureOccured = EFalse;
			if (iCache.Count() > ii)
				{
				//if cache region is entirely inside non redraw vis region, nothing to update!
				TInt changed = 
						TRegionExtend::Cast(iCache[ii]).TestDifference(iNonRedrawVisibleRegion);
				if (changed&TRegionExtend::ESub)
					{	//the clipping will change
					iCache[ii].Intersect(iNonRedrawVisibleRegion);
					if (iCache[ii].CheckError())
						{
						failureOccured = ETrue;
						iCache[ii].Close();
						iCache.Remove(ii);
						}
					else
						{
						iPlacedElements[ii].SetChangedClip(ETrue);	//changed clipping
						}
					}
				}
			else
				{	//attempt getting element region to perform calculation and update element directly
				STACK_REGION elementRegion;
	            TRect destinationRect;
	            iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);
	            elementRegion.AddRect(destinationRect);
				if (elementRegion.CheckError())
					{
					failureOccured = ETrue;
					}
				else
					{
					TRect elementExtent;
					iPlacedElements[ii].iElement->GetDestinationRectangle(elementExtent);
					elementRegion.Offset(elementExtent.iTl);	//get element region into absolute coordinates
					TInt changed =
						TRegionExtend::Cast(elementRegion).TestDifference(iNonRedrawVisibleRegion);
					if (changed&TRegionExtend::ESub)
						{	//need to clip element back
						elementRegion.Intersect(iNonRedrawVisibleRegion);
						if (!elementRegion.CheckError())
							{
							elementRegion.Offset(-elementExtent.iTl);	//put element region back into relative coords
							returnFlags|=EFastPath;
							}
						else
							{
							failureOccured = ETrue;
							}
						}
					}
				elementRegion.Close();
				}
			if (failureOccured)
				{	//need to release element
				TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();
				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
				NotifyReleasingSurface(tempId);
				aScene.DestroySceneElement(iPlacedElements[ii].iElement);
				returnFlags|=EFailed;
				iPlacedElements.Remove(ii);	//remove placed element entry, cache is already removed
				ii--;
				}
			}
		}

	//update any elements marked as changedclip , clear all cache, clear flags
	for (ii=0; ii<iPlacedElements.Count(); ii++)
		{
		if (iPlacedElements[ii].ChangedClip())
			{
			returnFlags|=EFastPath;	//need to invoke 1108
			}
		else
			if (	!(returnFlags&EFastPath)
				&&	iPlacedElements[ii].LockedConfig() && !iPlacedElements[ii].Unassigned()
				&&	iPlacedElements[ii].DrawnOver()!=iPlacedElements[ii].DrawnOverLast()	)
						{
						returnFlags|=EFastPath;
						}
		iPlacedElements[ii].ClearRedrawFlags();
		if (iCache.Count() > ii)
			{
			iCache[ii].Clear();
			}
		}
	iCache.Reset();
	iNonRedrawVisibleRegion.Clear();
	iHighestReusedIndex = -1;
	return returnFlags;
	}

/** Move all elements in this windowelement to above the supplied element in the scene

@param aScene Access to the scene.
@param aElement The element to set all this windows elements above.
*/

void CWindowElement::MoveToAboveGivenElement(MWsScene& aScene, MWsElement* aElement)
	{
	MWsElement* newAboveElement = iBackgroundElement.iElement;
	MWsElement* previousAboveElement = aElement;
	if (newAboveElement)
		{
		aScene.InsertSceneElement(newAboveElement, previousAboveElement);	//background element is put on first
		previousAboveElement = newAboveElement;		
		}
	TInt placedElements = iPlacedElements.Count();
	if (placedElements != 0)
		{
		for (TInt ii = 0; ii < placedElements; ii++)
			{
			newAboveElement = iPlacedElements[ii].iElement;
			aScene.InsertSceneElement(newAboveElement, previousAboveElement);	//place element above previous above element
			previousAboveElement = newAboveElement;	
			}
		}
	}

/** Updates the elements extent, whether from a window movement or a change in window size

@param aOffset The movement of the window.  If NULL then the window has changed size.
@see CWindowElementSet::UpdateElementExtent
*/
void CWindowElement::UpdateElementExtent(const TPoint* aOffset)
	{
	if (aOffset)	//window moved
		{
		TRect tempExtent;
		MWsElement* element = iBackgroundElement.iElement;
		TBool complete = EFalse;
		TInt placedElementDone = -1;
		while (!complete)
			{
			if (!element && placedElementDone < iPlacedElements.Count()-1)
				{
				placedElementDone++;
				element = iPlacedElements[placedElementDone].iElement;
				}
			if (!element)
				{
				complete = ETrue;
				}
			else
				{
				tempExtent = const_cast<CWsClientWindow&>(iWindow).GetOriginalDestElementRect();
				tempExtent.Move(*aOffset);
				element->SetDestinationRectangle(tempExtent);
				const_cast<CWsClientWindow&>(iWindow).SetOriginalDestElementRect(tempExtent);
				}
			element = NULL;
			}
		}
	else			//window changed size
		{
		if (!iBackgroundElement.ExplicitExtent() && iBackgroundElement.iElement)
			{
			iBackgroundElement.iElement->SetDestinationRectangle(iWindow.FullRect());
			const_cast<CWsClientWindow&>(iWindow).SetOriginalDestElementRect(iWindow.FullRect());
			}
		}
	}

/** Checks the windows placed elements when the windows visibility is changed.
If the placed elements are no longer visible, they are removed.

@param aRegion The new visible region of the window.
@param aScene Access to the scene.
@return ETrue if any elements have been removed, otherwise EFalse.
@see CWindowElementSet::SetVisibleRegion
*/
TBool CWindowElement::SetVisibleRegion(const TRegion& aRegion, MWsScene& aScene)
	{
	TBool retcode=EFalse;
	if (iPlacedElements.Count() == 0)
		{
		return EFalse;	//there is noting to do
		}
	
	STACK_REGION tempRegion;
	for (TInt ii = 0; ii < iPlacedElements.Count(); ii++)
		{
		TRect tempExtent;
        tempRegion.Clear();
        iPlacedElements[ii].iElement->GetDestinationRectangle(tempExtent);
        tempRegion.AddRect(tempExtent);
		if (tempRegion.CheckError())	//if there was error getting region
			{
			tempRegion.Clear();
			tempRegion.AddRect(tempExtent);
			}
		else
			{	//offset basearea of element
			tempRegion.Offset(tempExtent.iTl);
			}
		TInt regionReturn = TRegionExtend::Cast(aRegion).TestDifference(tempRegion);
		if (regionReturn&TRegionExtend::ENoIntersect)
			{	//placed surface needs to be removed
			TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();
			iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
			NotifyReleasingSurface(tempId);
			aScene.DestroySceneElement(iPlacedElements[ii].iElement);
			retcode = ETrue;	//a element has been removed
			iPlacedElements.Remove(ii);
			if (iCache.Count() > ii)
				{	//keep cache up to date
				iCache[ii].Close();
				iCache.Remove(ii);
				}
			ii--;
			}
		}
	tempRegion.Close();
	return retcode;
	}

/** Checks if any of the windows element ids match the one in question.

@param aSurfaceId The surface id to match against.
@return ETrue if a match is found, otherwise EFalse.

@see CWindowElementSet::SearchDuplicateSurfaceId
*/
TBool CWindowElement::SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId)
	{
	if (iBackgroundElement.iElement)
		{
		if (iBackgroundElement.iElement->ConnectedSurface() == aSurfaceId)
			{
			return ETrue;
			}
		}
	if (iPlacedElements.Count() > 0)
		{
		for (TInt ii = 0; ii < iPlacedElements.Count(); ii++)
			{
			if (iPlacedElements[ii].iElement)	//if removed without reserved space for ids, could be a null element
				{
				if (iPlacedElements[ii].iElement->ConnectedSurface() == aSurfaceId)
					{
					return ETrue;
					}
				}
			}
		}
	return EFalse;
	}

/** Sets the opacity for the background surface and if setting to 0 removes placed surfaces.

@param aOpacity The opacity to set.
@param aScene Access to the scene.
@see CWindowElementSet::SetElementOpacity
*/
void CWindowElement::SetElementOpacity(TInt aOpacity, MWsScene& aScene)
	{
	if (iBackgroundElement.iElement)
		{
	    TUint32 flags = 0;
	    iBackgroundElement.iElement->GetTargetRendererFlags(flags);
	    flags |= MWsElement::EElementTransparencyGlobalAlpha;
		iBackgroundElement.iElement->SetTargetRendererFlags(MWsElement::EElementTransparencyGlobalAlpha);
		iBackgroundElement.iElement->SetGlobalAlpha(aOpacity);
		iBackgroundElement.SetConcealed(aOpacity==0);
		}
	if (aOpacity == 0)
		{
		while (iPlacedElements.Count() > 0)
			{	//remove any placed elements
			TInt placedElement = iPlacedElements.Count()-1;
			TSurfaceId tempId = iPlacedElements[placedElement].iElement->ConnectedSurface();
			iPlacedElements[placedElement].iElement->ConnectSurface(TSurfaceId::CreateNullId());
			NotifyReleasingSurface(tempId);
			aScene.DestroySceneElement(iPlacedElements[placedElement].iElement);
			iPlacedElements.Remove(placedElement);
			};
		}
	}

MWsElement* CWindowElement::Element() const
    {
    return iBackgroundElement.iElement;
    }

//
// CWindowElementSet
//

/** Destroys the set of window-element pairs.
*/
CWindowElementSet::~CWindowElementSet()
	{
	ASSERT(iElements.Count() == 0);
	iElements.Close();
	}

/** Basic NewL constructor
@param aScene To allow access to the scene.
@param aComposer To allow access to the composer.
*/
CWindowElementSet* CWindowElementSet::NewL(MWsScene& aScene)
	{
	CWindowElementSet* wls = new (ELeave) CWindowElementSet(aScene);
	return wls;
	}

/** Sets a new background surface on the window supplied.
Will remove any previous background surface.

@param aWindow The window to place a background surface on.
@return A reference to the new background surface attributes.
*/
TBackgroundAttributes& CWindowElementSet::AcquireBackgroundElementL(CWsClientWindow& aWindow)
	{
	// Find the matching element.
	TInt index;
	TInt result = FindEntry(aWindow, index);
	MWsElement* element;

	// If a background element is already associated with the window, then unregister
	// the surface. Create and add a new element to scene.
	// This will ensure that the element has default values.
	if (result != KErrNotFound && iElements[index]->iBackgroundElement.iElement)
	    {
	    element = iElements[index]->iBackgroundElement.iElement;
		TSurfaceId surface = element->ConnectedSurface();
		element->ConnectSurface(TSurfaceId::CreateNullId());
		UnregisterSurface(surface);
		iScene.DestroySceneElement(element);
	    }
	if (index < 0)
		{
		index = 0;
		}

	// Allocate a new element and add it to the set and the scene
	element = iScene.CreateSceneElementL();
	
	TInt returnCode;
	if (result == KErrNotFound)
		{
		CWindowElement* winelement = new CWindowElement(aWindow);
		if (!winelement)
			{
			iScene.DestroySceneElement(element);
			User::Leave(KErrNoMemory);
			}
		returnCode = iElements.Insert(winelement, index);
		if(returnCode != KErrNone)
		    {
		    delete winelement;
		    iScene.DestroySceneElement(element);
		    User::Leave(returnCode);
		    }
		}

	// Use the element below the insertion point to decide where the element
	// goes in the scene
	returnCode = KErrNone;
	if (index == 0)
		{
		returnCode = iScene.InsertSceneElement(element, NULL);
		}
	else
		{
		//Find highest element in window below
		MWsElement* below;
		TInt placedCount = iElements[index-1]->iPlacedElements.Count();
		if (placedCount > 0)
			{
			below = iElements[index-1]->iPlacedElements[placedCount-1].iElement;
			}
		else
			{	//below = above = background surface
			below = iElements[index-1]->iBackgroundElement.iElement;
			}
		returnCode = iScene.InsertSceneElement(element, below);
		}
	
	__ASSERT_DEBUG(returnCode == KErrNone, Panic(EWsPanicSceneErrorIgnored));

	iElements[index]->iBackgroundElement.iElement = element;
	return iElements[index]->iBackgroundElement;
	}

/** Removes the background element of the specified window.

@param aWindow The window to remove the background element from.
@param aWindowClosing ETrue if aWindow is in between closing state.
@return KErrNone on success or a system-wide error code.
*/
TInt CWindowElementSet::ReleaseBackgroundElement(const CWsClientWindow& aWindow, TBool aWindowClosing /*= EFalse*/)
	{
	TInt index;

	TInt err = FindEntry(aWindow, index, aWindowClosing);
	__ASSERT_DEBUG(err != KErrNotFound, Panic(EWsPanicNoWindowElement));

	if (err==KErrNone)
		{
		CWindowElement* winElement=iElements[index];
		if (winElement->iPlacedElements.Count() == 0)
			{	//destroy the window entry
			DestroyWindowElementEntry(index);
			}
		else
			{	// just destroy the background
			if (winElement->iBackgroundElement.iElement)
				{
				winElement->iBackgroundElement.Destroy(iScene, ETrue);
				}
			}
		}
	return err;
	}

/** Destroys the element associated with this set of attributes

@param aScene To allow access to the scene.
@param aUnregister Whether to call unregister on the surface id.
@return ETrue if a element existed to be destroyed, otherwise EFalse.
*/
TBool TAttributes::Destroy(MWsScene& aScene, TBool aUnregister)
	{
	MWsElement* element = iElement;
	if (element)
		{
		TSurfaceId surface = element->ConnectedSurface();
		element->ConnectSurface(TSurfaceId::CreateNullId());
        if (aUnregister)
            {
            aScene.UnregisterSurface(surface);
            }
		aScene.DestroySceneElement(element);
		iElement = NULL;
		}
	return element!=NULL;
	}

/** Destroys all elements associated with the window and removes the window from the element set

@param aWinElementIndex The index of the window in the element set
*/
void CWindowElementSet::DestroyWindowElementEntry(const TInt aWinElementIndex)
	{
	CWindowElement* winElement=iElements[aWinElementIndex];
	const CWsClientWindow& window = winElement->iWindow;
	winElement->iBackgroundElement.Destroy(iScene, ETrue);
	for (TInt placedIndex=0,maxindex=winElement->iPlacedElements.Count();placedIndex<maxindex;placedIndex++)
		{
		winElement->iPlacedElements[placedIndex].Destroy(iScene, EFalse);
		}
	winElement->iPlacedElements.Close();
	delete winElement;
	iElements.Remove(aWinElementIndex);
	window.Redraw()->SetHasElement(EFalse);
	window.Screen()->ElementRemoved();
	}

/** Removes all elements in the associated window.

@param aWindow The window to remove the elements for.
@param aWindowClosing ETrue if aWindow is in between closing state.
@return KErrNone on success, KErrNotFound if there was no windowelement entry.
*/
TInt CWindowElementSet::ReleaseAllElements(const CWsClientWindow& aWindow, TBool aWindowClosing /*= EFalse*/)
	{
	TInt index;

	TInt err = FindEntry(aWindow, index, aWindowClosing);
	__ASSERT_DEBUG(err != KErrNotFound, Panic(EWsPanicNoWindowElement));
	if (err==KErrNone)
		{
		DestroyWindowElementEntry(index);
		}
	return err;
	}

/** For every window element, checks if any of the windows element ids match the one in question.

@param aSurfaceId The surface id to match against.
@return ETrue if a match is found, otherwise EFalse.

@see CWindowElement::SearchDuplicateSurfaceId
*/
TBool CWindowElementSet::SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId)
	{
	TInt windowElements = iElements.Count();
	for (TInt ii = 0; ii < windowElements; ii++)
		{
		if (iElements[ii]->SearchDuplicateSurfaceId(aSurfaceId))
			{
			return ETrue;
			}
		}
	return EFalse;
	}

/** For a window, sets the opacity for the background surface and if setting to 
0 removes placed surfaces.

@param aWindow The window to perform the function on.
@param aOpacity The opacity to set.
@see CWindowElement::SetElementOpacity
*/
void CWindowElementSet::SetElementOpacity(CWsClientWindow& aWindow, TInt aOpacity)
	{
	WS_ASSERT_DEBUG(aOpacity == 0 || aOpacity == 255,EWsPanicUnexpectedOpacity);
	return FindElement(aWindow)->SetElementOpacity(aOpacity, iScene);
	}

/** Finds all elements within the window that overlap with the region and 
marks them as unassigned.
If any part of these unassigned elements are outside the region, they are also 
marked overlapping and locked config.

@param aRedrawRegion The region in which elements will be unassigned
@param aWindow The window to perform the function on.
@return KErrNone on success or KErrNoMemory if critical calculations could not be made.
@see CWindowElement::UnassignPlacedElements
*/
TInt CWindowElementSet::UnassignPlacedElements(const TRegion& aRedrawRegion, const CWsClientWindow& aWindow, TInt aGcDrawingCount)
	{
	return FindElement(aWindow)->UnassignPlacedElements(aRedrawRegion, aGcDrawingCount);
	}

/** Called to place a element within the window.
It will either create a new element, recycle a element, or extend a element .

@param aPlacedAttributes Returns the attributes of the surface placed.
@param aSurfaceConfiguration The surface configuration for the surface to place.
@param aUserDefinedRegion The user defined clipping of the window.
@param aWindow The window to perform the function on.
@return KErrNone on success or a system-wide error code.
@see CWindowElement::AssignPlacedElement
*/
TInt CWindowElementSet::AssignPlacedElement(
		TPlacedAttributes*& aPlacedAttributes,
		const TSurfaceConfiguration& aSurfaceConfiguration,
		const TRegion& aUserDefinedRegion,
		const CWsClientWindow& aWindow,
		TInt aGcDrawingCount	)
	{
	TInt index;
	TInt error = KErrNone;
	TInt result = FindEntry(aWindow, index);
	TBool insertedElement = EFalse;
	if (result == KErrNotFound)
		{
		CWindowElement* winelement = new CWindowElement(aWindow);
		if (!winelement)
			{
			return KErrNoMemory;		//memory error
			}
		error = iElements.Insert(winelement, index);
		if (error == KErrNone)
			{
			insertedElement = ETrue;
			aWindow.Redraw()->SetHasElement(ETrue);
			STACK_REGION windowRegion = aWindow.Abs();
			if (!windowRegion.CheckError())
				{
				error = iElements[index]->UnassignPlacedElements(windowRegion, aGcDrawingCount);
				}
			else
				{
				error = KErrNoMemory;
				}
			windowRegion.Close();
			}
		else
			{
			delete winelement;
			}
		}
	if (error == KErrNone)
		{
		
		TInt assignReturn = iElements[index]->AssignPlacedElement(aPlacedAttributes, aSurfaceConfiguration,
				aUserDefinedRegion, iScene, aGcDrawingCount);
		error = assignReturn;	//return assign flags
		}
	if (error < KErrNone && insertedElement)
		{	//remove this element that has just been created
		aWindow.Redraw()->SetHasElement(EFalse);
		iElements.Remove(index);
		}
	return error;
	}

/** Marks all elements that have been assigned since the unassign as drawn over.

@param aWindow The window to perform the function on.
@see CWindowElement::FlagAssignedElementsDrawnOver
**/
//void CWindowElementSet::FlagAssignedElementsDrawnOver(const CWsClientWindow& aWindow)
//	{
//	FindElement(aWindow)->FlagAssignedElementsDrawnOver();
//	}

/** Called at the end of a redraw to set cached changed to elements, and
removed elements that are still unassigned.

@param aWindow The window to perform the function on.
@return Flags to describe what extra work needed doing.
@see CWindowElement::CleanUpPlacedElements
*/
TInt CWindowElementSet::CleanUpPlacedElements(const CWsClientWindow& aWindow, TInt aGcDrawingCount)
	{
	TInt index;
	TInt error = FindEntry(aWindow,index);
	if (error < 0)
		{
		WS_ASSERT_DEBUG(0,EWsPanicNoWindowElement);
		return error;
		}
	TInt returnFlags = iElements[index]->CleanUpPlacedElements(iScene, aGcDrawingCount);

	if (!iElements[index]->iBackgroundElement.iElement && iElements[index]->iPlacedElements.Count() == 0)
		{	//remove window entry
		DestroyWindowElementEntry(index);
		}
	else
		{
		if (returnFlags&CWindowElement::EResort)
			{	//need to sort elements
			//find front most visible element in window behind, invoke sort by z order
			if (index == 0)
				{	//this element is backmost window
				iElements[index]->MoveToAboveGivenElement(iScene,NULL);
				}
			else
				{	//place infront of highest element behind
				if (iElements[index-1]->iPlacedElements.Count() == 0)
					{	//top element of element behind must be the background element
					iElements[index]->MoveToAboveGivenElement(iScene,iElements[index-1]->iBackgroundElement.iElement);				
					}
				else
					{	//top element of element behind must be highest placed element
					TInt placedCount = iElements[index-1]->iPlacedElements.Count();
					iElements[index]->MoveToAboveGivenElement(iScene,iElements[index-1]->iPlacedElements[placedCount-1].iElement);
					}
				}
			}
		}
	if (returnFlags&CWindowElement::EFailed)
		{	//visible elements may have been deleted, error to suggest a full window redraw
		return KErrGeneral;
		}
	return returnFlags;
	}

/** Counts how many elements there are in the set.

@return The number of elements in the set.
*/
TInt CWindowElementSet::Count() const
	{
	return iElements.Count();
	}

/** Returns the background attributes for the specified window

@param aWindow The window to perform the function on.
@return The background surface attributes.  If the window has no elementset entry, returns NULL.
*/
TBackgroundAttributes* CWindowElementSet::FindBackgroundElement(const CWsClientWindow& aWindow)
	{
	TInt index;
	TInt err = FindEntry(aWindow, index);

	if (err != KErrNotFound)
		{
		return &(iElements[index]->iBackgroundElement);
		}
	return NULL;
	}

/**	Returns the contents of the element data associated with the input window.
If this method is successful, then neither pointer will be NULL.

@return standard symbian error code.
@param	aWindow	window to find
@param	aBackAttr	backgroud surface attributes associated with the window
@param	aPlacedAttr	array of placed surface attributes associated with the window.
*/
TInt CWindowElementSet::FindElements(	CWsClientWindow const &aWindow, 
									TBackgroundAttributes const * & aBackAttr, 
									RArray<class TPlacedAttributes> const * &	aPlacedAttr	)
	{
	TInt index;

	TInt err = FindEntry(aWindow, index);
//	__ASSERT_DEBUG(err != KErrNotFound, Panic(EWsPanicNoWindowElement));

//	return *iElements[index].iElement;
	if (err >= KErrNone)
		{
		aBackAttr=&iElements[index]->iBackgroundElement;
		aPlacedAttr=&iElements[index]->iPlacedElements;
		}
	else
		{
		aBackAttr=NULL;
		aPlacedAttr=NULL;
		}
	return err;
	
	}

/** Registers the surface with the compositor.
@param aSurface The surface id to register.
@return  KErrNone if successful, KErrNoMemory if registration fails due to low
memory, KErrNotSupported if the surface is not compatible with
this compositor or KErrBadHandle if the given surface ID does not
represent a valid surface. KErrArgument is returned if the
surface does not have both dimensions less than 32 767 pixels.
*/
TInt CWindowElementSet::RegisterSurface(const TSurfaceId& aSurface)
    {
    
    return iScene.RegisterSurface(aSurface);
    }

/** Unregisters the surface with the compositor.

@param aSurface The surface id to register.
@return  KErrNone if successful. KErrInUse if the surface is
used by a layer or layers. KErrBadHandle if the surface
is not currently registered. KErrArgument if
the surface ID is a NULL ID.
*/

void CWindowElementSet::UnregisterSurface(const TSurfaceId& aSurface)
    {
    
    TInt returnCode = iScene.UnregisterSurface(aSurface);
    __ASSERT_DEBUG((returnCode==KErrNone || returnCode==KErrInUse || returnCode==KErrBadHandle), Panic(EWsPanicSceneErrorIgnored));
    }

/** Sorts the array elements into the same order as the windows are in the
hierarchy. Use after window hierarchy has been modified, to update the scene
order to match.
@return EFalse if element order unchanged, ETrue if order may have changed.
*/
TBool CWindowElementSet::SortByZOrder()
	{
	if (iElements.Count() < 2)
		{
		// Early out for the very common cases where there are zero or one
		// elements, which cannot therefore be out of order.
		return EFalse;
		}

	// The approach being used is to first just sort the array, then update the 
	// scene order afterwards. This is simple to code and since there are not
	// expected to be many elements, it should be perfectly good enough.

	TLinearOrder<CWindowElement> order(WindowOrder);
	iElements.Sort(order);

	TBool orderChanged = EFalse;
	MWsElement* below;
	TInt elementCount = iElements.Count();
	for (TInt index = 0; index < elementCount; index++)
		{
		if (index == 0)
			{
			below = NULL;
			}
		else
			{
			//Find highest element in window below
			TInt placedCount = iElements[index-1]->iPlacedElements.Count();
			if (placedCount > 0)
				{
				below = iElements[index-1]->iPlacedElements[placedCount-1].iElement;
				}
			else
				{	//below = above = background surface
				below = iElements[index-1]->iBackgroundElement.iElement;
				}
			}
		//Find lowest element in above window element
		MWsElement* above;
		if (iElements[index]->iBackgroundElement.iElement != NULL)
			{	//use background element
			above = iElements[index]->iBackgroundElement.iElement;	//background element will be bottom
			}
		else	//use bottom element of placed surfaces
			{
			//above = iElements[index]->iPlacedElements[iElements[index]->iPlacedElements.Count()-1].iElement;	//first or last placed element is bottom?
			above = iElements[index]->iPlacedElements[0].iElement;
			}
		if (above->ElementBelow() != below)
			{
			//CALL below window element function to move all elements above 'below'
			iElements[index]->MoveToAboveGivenElement(iScene, below);
	        orderChanged = ETrue;
			}
		}
	return orderChanged;
	}

/** Processes the specified windows placed elements, for when windows visibility is changed.
If the placed elements are no longer visible, they are removed.

@param aWindow The window to call the function on.
@return Positive if any elements have been removed, zero if not, or errorcode. 
@see CWindowElement::SetVisibleRegion
*/
TInt CWindowElementSet::SetVisibleRegion(CWsClientWindow& aWindow)
	{
	TInt index;
	TInt find = FindEntry(aWindow,index);
	WS_ASSERT_DEBUG(find>=KErrNone,EWsPanicNoWindowElement);
	TBool ret = iElements[index]->SetVisibleRegion(aWindow.VisibleRegion(), iScene);

	if (!iElements[index]->iBackgroundElement.iElement && iElements[index]->iPlacedElements.Count() == 0)
		{
		DestroyWindowElementEntry(index);
		}
	return ret;
	}

/** Updates the specified windows elements extent, either from a window movement or a change in window size

@param aWindow The window to call the function on.
@param aOffset The movement of the window.  If NULL then the window has changed size.
@see CWindowElement::UpdateElementExtent
*/
void CWindowElementSet::UpdateElementExtent(const CWsClientWindow& aWindow, const TPoint* aOffset)
	{
	FindElement(aWindow)->UpdateElementExtent(aOffset);
	}

/** Method to fill in a TSurfaceConfiguration from a scene element.

@param aConfiguration Surface configuration to fill in.
@param aElement Element to get information from.
@return Once multiple versions of TSurfaceConfiguration are available, KErrNotSupported if configuration supplied is too small.
*/
TInt CWindowElementSet::GetConfiguration(TSurfaceConfiguration& aConfiguration,MWsElement& aElement)
	{
	TSurfaceId tempSurfaceId = aElement.ConnectedSurface();
	aConfiguration.SetSurfaceId(tempSurfaceId);
	
	//Convert and copy orientation
	aConfiguration.SetOrientation(ElementToGcRotation(aElement.SourceRotation()));
	
	//Convert and copy flip
	TBool flip = aElement.SourceFlipping();
	aConfiguration.SetFlip(flip);

	//Convert and copy viewport
	TRect tempViewport;
	aElement.GetSourceRectangle(tempViewport);
	aConfiguration.SetViewport(tempViewport);
	TRect tempExtent;
	aElement.GetDestinationRectangle(tempExtent);
	aConfiguration.SetExtent(tempExtent);
	return KErrNone;	//Could fail if there are multiple versions of TSurfaceConfiguration
	}

/** Returns the window element entry for the specified window.

@param aWindow The window to call the function on.
*/
CWindowElement* CWindowElementSet::FindElement(const CWsClientWindow& aWindow) const
	{
	TInt index;
	TInt error = FindEntry(aWindow,index);
	if (error == KErrNone)
		return iElements[index];
	WS_ASSERT_DEBUG(EFalse,EWsPanicNoWindowElement);
	return NULL;
	}

/** Creates a set of window-element pairs for this scene.

@param aScene To allow access to the scene.
@param aComposer To allow access to the composer.
*/
CWindowElementSet::CWindowElementSet(MWsScene& aScene) :
	iScene(aScene)
	{}

/** Searches for the entry in iElements with the given window

@param aWindow The window to find the entry of / where it should be inserted.
@param aIndex aIndex is set to entry found or the insertion point, respectively.
@param aLinearSearch ETrue if a linear search of the window element set is required.
@return KErrNone if found or KErrNotFound.
*/
TInt CWindowElementSet::FindEntry(const CWsClientWindow& aWindow, TInt& aIndex, TBool aLinearSearch /*= EFalse*/) const
	{
	CWindowElement winelement(aWindow);
	
	// The array order makes use of the parent pointer, which gets reset during
	// window shutdown, so if it is clear fall back to a linear search.
	if (!aWindow.BaseParent() || aLinearSearch)
		{
		TIdentityRelation<CWindowElement> match(WindowMatch);
		
		aIndex = iElements.Find(&winelement, match);
		return (aIndex == KErrNotFound) ? KErrNotFound : KErrNone;
		}
	else
		{
		TLinearOrder<CWindowElement> order(WindowOrder);
		return iElements.FindInOrder(&winelement, aIndex, order);
		}
	}

/** Used to find an entry in the set when order cannot be used. 

@param aFirst First windowelement to compare.
@param aSecond Second windowelement to compare.
@return ETrue if the entries are the same, and EFalse if they are not.
*/
TBool CWindowElementSet::WindowMatch(const CWindowElement& aFirst, const CWindowElement& aSecond)
	{
	return (&aFirst.iWindow == &aSecond.iWindow);
	}


/** Used to determine the order of entries in the set.

@param aFirst First windowelement to compare.
@param aSecond Second windowelement to compare.
@return zero if the entries are the same, a negative value if 
aFirst is behind aSecond or a positive value if aFirst is in front of aSecond.
*/
TInt CWindowElementSet::WindowOrder(const CWindowElement& aFirst, const CWindowElement& aSecond)
	{
	TInt result = 0;

	if (&aFirst.iWindow != &aSecond.iWindow)
		{
		result = aFirst.iWindow.IsInfrontOf(&aSecond.iWindow) ? 1 : -1;
		}

	return result;
	}


/**	Re-sends the extents for all the elements (in this window) to the scene  	
 * 	This allows the renderstage to re-scale those element extents
 * 
 * 
 **/
void CWindowElement::ResubmitAllElementExtents()
	{
	if (MWsElement* element=iBackgroundElement.iElement)
		{
		TRect extent(TRect::EUninitialized);
		element->GetDestinationRectangle(extent);
		element->SetDestinationRectangle(extent);
		}
	TInt elementCount = iPlacedElements.Count();
	for (TInt index = 0; index < elementCount; index++)
		{
		if (MWsElement* element=iPlacedElements[index].iElement)
			{
			TRect extent(TRect::EUninitialized);
			element->GetDestinationRectangle(extent);
			element->SetDestinationRectangle(extent);
			}
		}
	}

/**	Re-sends the extents for all the elements (in all the windows) to the scene  	
 * 	This allows the renderstage to re-scale those element extents
 * 
 * 
 **/
void CWindowElementSet::ResubmitAllElementExtents()
	{
	TInt elementCount = iElements.Count();
	for (TInt index = 0; index < elementCount; index++)
		{
		iElements[index]->ResubmitAllElementExtents();
		}
	}

//
// Debug functions
//

/** Returns background attributes for the specified window index.
For use with debug client interface.

@param aWin Window index to get the surface attributes from.
@return Background attributes for the specified window.  NULL if the window index is invalid.
*/
const TBackgroundAttributes* CWindowElementSet::DebugBackgroundAt(TUint aWin)const
	{
	if (aWin>=Count())
		return NULL;
	return &iElements[aWin]->iBackgroundElement;
	}

/** Returns the client window for the specified window index.
For use with debug client interface.

@param aWin Window index to get the client window from.
@return Client window for the specified window.  NULL if the window index is invalid.
*/
const CWsClientWindow* CWindowElementSet::DebugWindowAt(TUint aWin)const
	{
	if (aWin>=Count())
		return NULL;
	return &iElements[aWin]->iWindow;
	}

/** Returns how many placed surfaces are on the specified window
For use with debug client interface.

@param aWin Window index to get the client window from.
@return Amount of placed surfaces for the specified window index
*/
TInt CWindowElementSet::DebugPlacedCountAt(TUint aWin)const
	{
	if (aWin>=Count())
		return -1;
	return iElements[aWin]->iPlacedElements.Count();
	}

/** Returns the placed attributes for the specified placed surface index in the
specified window index.
For use with debug client interface.

@param aWin Window index to get the client window from.
@param aPlace Placed surface index to get the placed surface attributes
@return Placed surface attributes.  NULL if either index was invalid.
*/
const TPlacedAttributes* CWindowElementSet::DebugPlacedAt(TUint aWin,TUint aPlace)const
	{
	if (aWin>=Count())
		return NULL;
	if (aPlace>=iElements[aWin]->iPlacedElements.Count())
		return NULL;
	return &iElements[aWin]->iPlacedElements[aPlace];
	}

MWsElement* CWindowElementSet::GetElementFromWindow(const CWsClientWindow& aWindow) const
    {
    CWindowElement* windowElement = FindElement(aWindow);
    if (windowElement)
        return windowElement->Element();
    else 
        return NULL; 
    }