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