sl@0: // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32std.h>
sl@0: #include "cliwin.h"
sl@0: #include "server.h"
sl@0: #include "windowelementset.h"
sl@0: #include "regionextend.h"
sl@0: #include <graphics/wsscene.h>
sl@0: #include <graphics/wsgraphicdrawer.h>
sl@0: #include "panics.h"
sl@0: #include "wstop.h"
sl@0: 
sl@0: #include "EVENT.H"
sl@0: 
sl@0: #ifndef KCacheListGranularity
sl@0: 	enum	{KCacheListGranularity = 8};
sl@0: #endif
sl@0: #ifndef KCacheExtensionReserve
sl@0: 	enum	{KCacheExtensionReserve = 1};
sl@0: #endif
sl@0: 	
sl@0: 
sl@0: 
sl@0: /** Element to gc rotation function
sl@0: */
sl@0: LOCAL_C inline CFbsBitGc::TGraphicsOrientation ElementToGcRotation(MWsElement::TElementRotation aElementRotation)
sl@0: 	{
sl@0: 	CFbsBitGc::TGraphicsOrientation gcRotation = CFbsBitGc::EGraphicsOrientationNormal;
sl@0: 
sl@0: 	switch (aElementRotation)
sl@0: 		{
sl@0: 		case MWsElement::EElementAntiClockwise90:
sl@0: 			gcRotation = CFbsBitGc::EGraphicsOrientationRotated90;
sl@0: 			break;
sl@0: 		case MWsElement::EElementAntiClockwise180:
sl@0: 			gcRotation = CFbsBitGc::EGraphicsOrientationRotated180;
sl@0: 			break;
sl@0: 		case MWsElement::EElementAntiClockwise270:
sl@0: 			gcRotation = CFbsBitGc::EGraphicsOrientationRotated270;
sl@0: 			break;
sl@0: 		default:
sl@0: 			break;
sl@0: 		}
sl@0: 	return gcRotation;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // CWindowElement
sl@0: //
sl@0: 
sl@0: CWindowElement::CWindowElement(const CWsClientWindow& aWindow) :
sl@0: 	iWindow(aWindow), iCache(KCacheListGranularity), iHighestReusedIndex(-1)
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: /** Finds all elements within the window that overlap with the region and 
sl@0: marks them as unassigned.
sl@0: If any part of these unassigned elements are outside the region, they are also 
sl@0: marked overlapping and locked config.
sl@0: 
sl@0: @param aRegion The region that is being redrawn.
sl@0: @return KErrNone on success or KErrNoMemory if critical calculations could not be made.
sl@0: 
sl@0: @see CWindowElementSet::UnassignPlacedElements
sl@0: **/
sl@0: TInt CWindowElement::UnassignPlacedElements(const TRegion& aRegion,TInt aGcDrawingCount)
sl@0: 	{
sl@0: 	iFlags = 0;	//reset flags
sl@0: 	iStartGcDrawingCount = aGcDrawingCount;	//Detect any drawing between calls
sl@0: 	iBackgroundElement.SetDrawnOverLast(iBackgroundElement.DrawnOver());
sl@0: 	iNonRedrawVisibleRegion.Clear();
sl@0: 	iNonRedrawVisibleRegion.Copy(const_cast<CWsClientWindow&>(iWindow).VisibleRegion());
sl@0: 	iNonRedrawVisibleRegion.SubRegion(aRegion);
sl@0: 	if (iNonRedrawVisibleRegion.CheckError())
sl@0: 		{	//memory error. Still needs to cope if whole window is being redrawn
sl@0: 		iNonRedrawVisibleRegion.Clear();
sl@0: 		TInt fullWindowRedraw = TRegionExtend::Cast(aRegion).TestDifference(const_cast<CWsClientWindow&>(iWindow).VisibleRegion());
sl@0: 		if (fullWindowRedraw != 0)
sl@0: 			{	//not a full window redraw, return immediately
sl@0: 			return KErrNoMemory;
sl@0: 			}
sl@0: 		}	
sl@0: 	TInt placedElements = iPlacedElements.Count();
sl@0: 	TInt unassignedCount = 0;
sl@0: 	TInt ii;
sl@0: 	TBool cacheError = EFalse;
sl@0: 
sl@0: 	STACK_REGION tempSurfaceBaseArea;
sl@0: 	if (iCache.Reserve(placedElements + KCacheExtensionReserve) < KErrNone)	//quite often there may need to be room for more
sl@0: 		{	//failed to reserve space
sl@0: 		cacheError = ETrue;
sl@0: 		}
sl@0: 	TRect tempExtent;
sl@0: 	TRect tempIntersect;
sl@0: 	
sl@0: 	for (ii=0; ii<placedElements; ii++)
sl@0: 		{
sl@0: 		if (!cacheError)
sl@0: 			{	//cache is ok up to this point but does not contain cache for this element yet
sl@0: 			RRegion newRegion;
sl@0: 			if (iCache.Append(newRegion) < KErrNone)
sl@0: 				{
sl@0: 				cacheError = ETrue;
sl@0: 				}
sl@0: 			newRegion.Close();
sl@0: 			}
sl@0: 
sl@0: 		iPlacedElements[ii].iElement->GetDestinationRectangle(tempExtent);
sl@0: 		TInt regionReturn = TRegionExtend::Cast(aRegion).TestDifference(tempExtent);
sl@0: 		iPlacedElements[ii].SetDrawnOverLast(iPlacedElements[ii].DrawnOver());	//allows detection of change of state
sl@0: 		if (!(regionReturn&TRegionExtend::ENoIntersect))
sl@0: 			{	//redraw region intersects with element
sl@0: 			iPlacedElements[ii].SetUnassigned();
sl@0: 			iPlacedElements[ii].SetDrawnOver(EFalse);
sl@0: 			unassignedCount++;
sl@0: 			
sl@0: 			if (!(regionReturn&TRegionExtend::EAdd))
sl@0: 				{	//surface is entirely within the redraw region
sl@0: 				iPlacedElements[ii].SetOverlapping(EFalse);
sl@0: 				iPlacedElements[ii].SetLockedConfig(EFalse);
sl@0: 				if(!cacheError)
sl@0: 					{
sl@0: 					TRect destinationRect;
sl@0: 					tempSurfaceBaseArea.Clear();
sl@0:                     iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);
sl@0: 					tempSurfaceBaseArea.AddRect(destinationRect);
sl@0: 					if (!tempSurfaceBaseArea.CheckError())
sl@0: 						{
sl@0: 						tempSurfaceBaseArea.Offset(tempExtent.iTl);	//cache needs to be in absolute coords
sl@0: 						iCache[ii].Copy(tempSurfaceBaseArea);
sl@0: 						}
sl@0: 					if (tempSurfaceBaseArea.CheckError() || iCache[ii].CheckError())
sl@0: 						{	//cache is no good from this point onwards
sl@0: 						iCache[ii].Close();
sl@0: 						iCache.Remove(ii);
sl@0: 						cacheError = ETrue;
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0:                 TRect destinationRect;
sl@0:                 tempSurfaceBaseArea.Clear();
sl@0:                 iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);
sl@0:                 tempSurfaceBaseArea.AddRect(destinationRect);
sl@0: 				if (tempSurfaceBaseArea.CheckError())
sl@0: 					{	//critical failure, clear cache and return error
sl@0: 					for (ii=iCache.Count(); ii>0; ii--)
sl@0: 						{
sl@0: 						iCache[ii-1].Close();
sl@0: 						iCache.Remove(ii-1);
sl@0: 						}
sl@0: 					iCache.Reset();
sl@0: 					iNonRedrawVisibleRegion.Close();
sl@0: 					tempSurfaceBaseArea.Close();
sl@0: 					return KErrNoMemory;
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					tempSurfaceBaseArea.Offset(tempExtent.iTl);	//change to absolute coordinates
sl@0: 					regionReturn = TRegionExtend::Cast(iNonRedrawVisibleRegion ).TestDifference(tempSurfaceBaseArea);
sl@0: 					if (regionReturn&TRegionExtend::ENoIntersect)
sl@0: 						{	//element base area entirely inside redraw region
sl@0: 						iPlacedElements[ii].SetOverlapping(EFalse);
sl@0: 						iPlacedElements[ii].SetLockedConfig(EFalse);
sl@0: 						}
sl@0: 					else
sl@0: 						{	//element base area is at least partly within non redraw visible region
sl@0: 						iPlacedElements[ii].SetOverlapping(ETrue);
sl@0: 						iPlacedElements[ii].SetLockedConfig(ETrue);
sl@0: 						}
sl@0: 					if(!cacheError)
sl@0: 						{
sl@0: 						iCache[ii].Copy(tempSurfaceBaseArea);
sl@0: 						if (iCache[ii].CheckError())
sl@0: 							{	//cache is no good from this point onwards
sl@0: 							iCache[ii].Close();
sl@0: 							iCache.Remove(ii);
sl@0: 							cacheError = ETrue;
sl@0: 							}
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{	//element does not intersect with redraw region
sl@0: 			iPlacedElements[ii].SetUnassigned(EFalse);
sl@0: 			}
sl@0: 		}
sl@0: 	tempSurfaceBaseArea.Close();
sl@0: 	
sl@0: 	if (iRemovedSurfaces.Reserve(unassignedCount) == KErrNone)
sl@0: 		{
sl@0: 		iRemovedSurfacesValid = ETrue;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iRemovedSurfacesValid = EFalse;
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /** Marks all elements that have been assigned since the unassign as drawn over.
sl@0: 
sl@0: @see CWindowElementSet::FlagAssignedElementsDrawnOver
sl@0: **/
sl@0: void CWindowElement::FlagAssignedElementsDrawnOver(TInt aGcDrawingCount)
sl@0: 	{
sl@0: 	iStartGcDrawingCount = aGcDrawingCount;
sl@0: 	if (iBackgroundElement.iElement)
sl@0: 		{
sl@0: 		iBackgroundElement.SetDrawnOver();
sl@0: 		}
sl@0: 	TInt placedElementCount = iPlacedElements.Count();
sl@0: 	for (TInt ii = 0; ii < placedElementCount; ii++)
sl@0: 		{
sl@0: 		if(!iPlacedElements[ii].Unassigned() && iPlacedElements[ii].LockedConfig())
sl@0: 			{
sl@0: 			iPlacedElements[ii].SetDrawnOver();
sl@0: 			}
sl@0: 		else if(iPlacedElements[ii].Unassigned() && iPlacedElements[ii].LockedConfig() &&
sl@0: 				!iPlacedElements[ii].ChangedClip() && iPlacedElements[ii].Overlapping())
sl@0: 			{
sl@0: 			iPlacedElements[ii].SetDrawnOver();
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** Checks whether a elements configuration is the same as that of the surface configuration, taking
sl@0: into account the stateflags (TPlacedAttributes) passed in.
sl@0: It must match surfaceId and extent.
sl@0: If it is a locked config it will need to match viewport and orientation as well.
sl@0: 
sl@0: @param aElement Element to compare against.
sl@0: @param aSurfaceConfiguration Configuration to compare.
sl@0: @param aStateFlags The TPlacedAttributes flags for the element.
sl@0: @return ETrue if a match, otherwise EFalse.
sl@0: */
sl@0: TBool CWindowElement::IsElementAMatch(MWsElement& aElement, const TSurfaceConfiguration& aSurfaceConfiguration,
sl@0: 		TInt aStateFlags)
sl@0: 	{
sl@0: 	TBool match = EFalse;
sl@0: 	
sl@0: 	TRect tempElementExtent;
sl@0: 	TRect tempCRPExtent;
sl@0: 	aElement.GetDestinationRectangle(tempElementExtent);
sl@0: 	aSurfaceConfiguration.GetExtent(tempCRPExtent);
sl@0: 	if (tempElementExtent == tempCRPExtent)
sl@0: 		{
sl@0: 		TSurfaceId tempElementSurfaceId;
sl@0: 		TSurfaceId tempCRPSurfaceId;
sl@0: 		aSurfaceConfiguration.GetSurfaceId(tempElementSurfaceId);
sl@0: 		tempCRPSurfaceId = aElement.ConnectedSurface();
sl@0: 		if (tempElementSurfaceId == tempCRPSurfaceId)
sl@0: 			{
sl@0: 			match = ETrue;
sl@0: 			if (aStateFlags&TPlacedAttributes::ELockedConfig)
sl@0: 				{
sl@0: 				match = EFalse;
sl@0: 				TBool orientationOK = EFalse;
sl@0: 				TRect tempCRPViewport;
sl@0: 				aSurfaceConfiguration.GetViewport(tempCRPViewport);
sl@0: 				//if explicit viewport flagged
sl@0: 				TRect tempElementViewport;
sl@0: 				aElement.GetSourceRectangle(tempElementViewport);
sl@0: 				if (tempElementViewport == tempCRPViewport)
sl@0: 					{
sl@0: 					CFbsBitGc::TGraphicsOrientation tempElementOrientation;
sl@0: 					MWsElement::TElementRotation tempCRPRotation;
sl@0: 					CFbsBitGc::TGraphicsOrientation tempCRPOrientation;
sl@0: 					tempElementOrientation = aSurfaceConfiguration.Orientation();
sl@0: 					tempCRPRotation = aElement.SourceRotation();
sl@0: 					tempCRPOrientation = ElementToGcRotation(tempCRPRotation);	//convert to common type
sl@0: 					if (tempElementOrientation == tempCRPOrientation)
sl@0: 						{
sl@0: 						orientationOK = ETrue;
sl@0: 						}
sl@0: 					}
sl@0: 				if(orientationOK)
sl@0: 				    {
sl@0: 				    TBool tempElementFlip = aSurfaceConfiguration.Flip();
sl@0: 				    TBool tempCRPFlip = aElement.SourceFlipping();
sl@0: 				    if(tempElementFlip == tempCRPFlip)
sl@0: 				        {
sl@0: 				        match = ETrue;
sl@0: 				        }
sl@0: 				    }
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return match;
sl@0: 	}
sl@0: 
sl@0: /** Sets the surfaceconfiguration to the element.
sl@0: 
sl@0: @param aElement The element to set.
sl@0: @param aSurfaceConfiguration The configuration to set to the element.
sl@0: @param aLimitedSet Set all values if EFalse, otherwise only set viewport and orientation.
sl@0: @return KErrNone on success, error from compositor if it could not set the surface id.
sl@0: */
sl@0: TInt CWindowElement::SetElement(MWsElement& aElement, const TSurfaceConfiguration& aSurfaceConfiguration, TBool aLimitedSet)
sl@0: 	{	//aLimitedSet - EFalse = set all . ETrue = set viewport and orientation only
sl@0: 	if (!aLimitedSet)
sl@0: 		{
sl@0: 		//set surface id
sl@0: 		TSurfaceId newSurfaceId;
sl@0: 		aSurfaceConfiguration.GetSurfaceId(newSurfaceId);
sl@0: 		TInt error = aElement.ConnectSurface(newSurfaceId);
sl@0: 		if (error != KErrNone)
sl@0: 			{
sl@0: 			return error;
sl@0: 			}
sl@0: 		
sl@0: 		//set extent
sl@0: 		TRect newExtent;
sl@0: 		aSurfaceConfiguration.GetExtent(newExtent);
sl@0: 		aElement.SetDestinationRectangle(newExtent);
sl@0: 		}
sl@0: 	
sl@0: 	//set viewport
sl@0: 	TRect newViewport;
sl@0: 	aSurfaceConfiguration.GetViewport(newViewport);
sl@0: 	if (newViewport.iTl.iX < 0 || newViewport.iTl.iY < 0)
sl@0: 		{
sl@0: 		return KErrArgument;
sl@0: 		}
sl@0: 	
sl@0: 	if (!newViewport.IsEmpty())
sl@0: 		{	//need to check if viewport is valid size
sl@0: 		TInt error = aElement.SetSourceRectangle(newViewport);
sl@0:         if (error != KErrNone)
sl@0:             {
sl@0:             return error;
sl@0:             }
sl@0: 		}
sl@0: 
sl@0: 	//set orientation
sl@0: 	//Note for compatibility with Oghma:
sl@0: 	//This method does not properly error check or return KErrArgument,
sl@0: 	//as that would propagate a client panic in SetBackgroundSurface which did not previously occur.
sl@0: 	aElement.SetSourceRotation(GcToElementRotation(aSurfaceConfiguration.Orientation()));
sl@0: 	// Set or clear flip if the element flags are changing
sl@0: 	if ( (!aSurfaceConfiguration.Flip()) != (!aElement.SourceFlipping()) ) 
sl@0: 	    {
sl@0:         aElement.SetSourceFlipping(!aElement.SourceFlipping());
sl@0: 	    }
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /** Attempts to insert a region cache in to the the windows iCache.
sl@0: If it fails, it will remove all cache beyond its index as it is now out of step.
sl@0: 
sl@0: @param aIndexToInsert The index of where to insert the cache.
sl@0: @return ETrue on success, else EFalse.
sl@0: */
sl@0: 
sl@0: TBool CWindowElement::InsertCache(TInt aIndexToInsert)
sl@0: 	{
sl@0: 	RRegion newRegion;
sl@0: 	TInt cacheInsertError = iCache.Insert(newRegion, aIndexToInsert);
sl@0: 	if (cacheInsertError == KErrNone)
sl@0: 		{
sl@0: 		newRegion.Close(); 
sl@0: 		return ETrue;	//inserted cache
sl@0: 		}
sl@0: 	if (iCache.Count() > aIndexToInsert)
sl@0: 		{	//if insert failed and there is more cache above where its trying to insert
sl@0: 		iCache.Remove(iCache.Count()-1);
sl@0: 		cacheInsertError = iCache.Insert(newRegion, aIndexToInsert);
sl@0: 		
sl@0: 		if (cacheInsertError == KErrNone)
sl@0: 			{
sl@0: 			newRegion.Close();
sl@0: 			return ETrue;	//inserted cache
sl@0: 			}
sl@0: 		}
sl@0: 	
sl@0: 	//cant insert this cache, there may be invalid cache to destroy
sl@0: 	TInt count = iCache.Count();
sl@0: 	while(count > aIndexToInsert)
sl@0: 		{	//if there is cache where we wished to insert, it and everything above is now invalid
sl@0: 		iCache[count-1].Close();
sl@0: 		iCache.Remove(count-1);
sl@0: 		count--;
sl@0: 		};
sl@0: 	newRegion.Close();
sl@0: 	return EFalse;	//failed to insert
sl@0: 	}
sl@0: 
sl@0: /** Will send a notification that a surface being unreferenced if it is not
sl@0: found in any WindowElementSet
sl@0: 
sl@0: @pre Make sure the element being removed has already had its surfaceid set to NULL.
sl@0: @param aSurfaceId The surface being removed
sl@0: */
sl@0: void CWindowElement::NotifyReleasingSurface(TSurfaceId aSurfaceId)
sl@0: 	{
sl@0: 	if (CWsTop::SearchDuplicateSurfaceId(aSurfaceId) == EFalse)
sl@0: 		{	//NOT found other instance of surface id, send notification now
sl@0: 		TWservCrEvent crEvent(TWservCrEvent::ESurfaceUnreferenced, sizeof(aSurfaceId), &aSurfaceId);
sl@0: 		TWindowServerEvent::NotifyDrawer(crEvent);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** Called to place a element within the window.
sl@0: It will either create a new element, recycle a element, or extend a element .
sl@0: 
sl@0: @pre UnassignPlacedElements has already been called.
sl@0: @param aPlacedAttributes Returns the attributes of the surface placed.
sl@0: @param aSurfaceConfiguration The surface configuration for the surface to place.
sl@0: @param aUserDefinedRegion The user defined clipping of the window.
sl@0: @param aScene Access to the scene.
sl@0: @return Serious error, otherwise flags to describe what extra work needs doing.
sl@0: 
sl@0: @see CWindowElementSet::AssignPlacedElement
sl@0: */
sl@0: TInt CWindowElement::AssignPlacedElement(
sl@0: 		TPlacedAttributes*& aPlacedAttributes,
sl@0: 		const TSurfaceConfiguration& aSurfaceConfiguration,
sl@0: 		const TRegion& aUserDefinedRegion,
sl@0: 		MWsScene& aScene,
sl@0: 		TInt	aGcDrawingCount
sl@0: 		)
sl@0: 	{	
sl@0: 	if (iStartGcDrawingCount!=aGcDrawingCount)
sl@0: 		{
sl@0: 		FlagAssignedElementsDrawnOver(aGcDrawingCount);
sl@0: 		}
sl@0: 
sl@0: 	if (iNonRedrawVisibleRegion.CheckError())
sl@0: 		{
sl@0: 		//CANNOT DO ANYTHING, LEAVE
sl@0: 		return KErrNotReady;	//error
sl@0: 		}
sl@0: 
sl@0: 	TRect surfaceExtent;
sl@0: 	aSurfaceConfiguration.GetExtent(surfaceExtent);
sl@0: 	if (!aUserDefinedRegion.Intersects(surfaceExtent))
sl@0: 		{
sl@0: 		//clippedRegion.Close();
sl@0: 		return KErrCancel;	//no intersection, so nothing to do
sl@0: 		}
sl@0: 
sl@0: 	TInt matchFound = -1;
sl@0: 	
sl@0: 	//check 'current' (last placed element) to see if it is a match
sl@0: 	if (iHighestReusedIndex != -1)
sl@0: 		{
sl@0: 		if (IsElementAMatch(*(iPlacedElements[iHighestReusedIndex].iElement),aSurfaceConfiguration,iPlacedElements[iHighestReusedIndex].Flags()) )
sl@0: 			{
sl@0: 			matchFound = iHighestReusedIndex;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if (matchFound == -1)
sl@0: 		{
sl@0: 		//check current unassigned elements to see if there is a match
sl@0: 		for (TInt ii = (iHighestReusedIndex == -1)?0:iHighestReusedIndex+1; ii < iPlacedElements.Count(); ii++)
sl@0: 			{
sl@0: 			if (IsElementAMatch(*(iPlacedElements[ii].iElement),aSurfaceConfiguration,iPlacedElements[ii].Flags()))
sl@0: 				{
sl@0: 				matchFound = ii;
sl@0: 				break;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	TInt returnValue = 0;
sl@0: 	if (matchFound == -1)
sl@0: 		{	//not found a element to extend
sl@0: 		//iResort = ETrue;
sl@0: 		matchFound = 0;
sl@0: 		while(1)
sl@0: 			{
sl@0: 			if (iPlacedElements.Count() == 0 || iHighestReusedIndex == -1 || matchFound == iHighestReusedIndex)	//reached last re assigned element, so cannot reuse one
sl@0: 				{
sl@0: 				matchFound = -1;
sl@0: 				break;
sl@0: 				}
sl@0: 			if (iPlacedElements[matchFound].Unassigned() && !iPlacedElements[matchFound].LockedConfig())	//found a element to reuse
sl@0: 				{
sl@0: 				break;
sl@0: 				}
sl@0: 			matchFound++;
sl@0: 			};
sl@0: 
sl@0: 		if (matchFound != -1)
sl@0: 			{	//found a element to recycle
sl@0: 			returnValue = AssignRecycleElement(matchFound,aSurfaceConfiguration,aUserDefinedRegion,aScene);
sl@0: 			}
sl@0: 		else
sl@0: 			{	//need to create a new element
sl@0: 			returnValue = AssignCreateElement(aSurfaceConfiguration,aUserDefinedRegion,aScene);
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{	//found a candidate to extend
sl@0: 		returnValue = AssignExtendElement(matchFound,aSurfaceConfiguration,aUserDefinedRegion,aScene);
sl@0: 		}
sl@0: 	if (returnValue < KErrNone)
sl@0: 		{	//failed with error
sl@0: 			return returnValue;
sl@0: 		}
sl@0: 	aPlacedAttributes = &iPlacedElements[iHighestReusedIndex];
sl@0: 	iFlags|=returnValue;	//update window wide flags
sl@0: 	return returnValue;
sl@0: 	}
sl@0: 
sl@0: /** Recycle a element assigned to the window.
sl@0: 
sl@0: @param aIndex The index of the placed element to recycle.
sl@0: @param aSurfaceConfiguration The surface configuration for the surface to place.
sl@0: @param aUserDefinedRegion The user defined clipping of the window.
sl@0: @param aScene Access to the scene.
sl@0: @return Serious error, otherwise flags to describe what extra work needs doing.
sl@0: 
sl@0: @see CWindowElement::AssignPlacedElement
sl@0: */
sl@0: TInt CWindowElement::AssignRecycleElement(const TInt aIndex, const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& aScene)
sl@0: 	{
sl@0: 	TInt returnValue = 0;
sl@0: 	TInt error = KErrNone;
sl@0: 	STACK_REGION clippedRegion;
sl@0: 	TRect surfaceExtent;
sl@0: 	aSurfaceConfiguration.GetExtent(surfaceExtent);
sl@0: 	clippedRegion.AddRect(surfaceExtent);
sl@0: 	clippedRegion.Intersect(aUserDefinedRegion);
sl@0: 	if (clippedRegion.CheckError())
sl@0: 		{	//failed crucial calculation, leave while nothing has been changed!
sl@0: 		clippedRegion.Close();
sl@0: 		return KErrNoMemory;
sl@0: 		}
sl@0: 	WS_ASSERT_DEBUG(!clippedRegion.IsEmpty(),EWsPanicRegion);
sl@0: 	if (clippedRegion.IsEmpty())
sl@0: 		{
sl@0: 		return KErrArgument;
sl@0: 		}
sl@0: 	
sl@0: 	//keep note of surface being removed
sl@0: 	TSurfaceId oldSurfaceId = iPlacedElements[aIndex].iElement->ConnectedSurface();
sl@0: 	
sl@0: 	//set element with new attributes
sl@0: 	error = SetElement(*(iPlacedElements[aIndex].iElement),aSurfaceConfiguration,EFalse);
sl@0: 	
sl@0: 	if (error < KErrNone)
sl@0: 		{	//must be a bad surface id or bad viewport, leave while nothing has been changed!
sl@0: 		clippedRegion.Close();
sl@0: 		return error;
sl@0: 		}
sl@0: 	
sl@0: 	returnValue|=EFastPath;
sl@0: 	returnValue|=EPauseComposition;
sl@0: 	//element has been altered, must make sure old surface unreferenced notify will be called
sl@0: 	if (!iRemovedSurfacesValid)
sl@0: 		{	//didnt reserve space for surface ids, do search immediately
sl@0: 		NotifyReleasingSurface(oldSurfaceId);
sl@0: 		}
sl@0: 	else
sl@0: 		{	//keep memory of surface id - search will be done during cleanup. Space already been reserved
sl@0: 		iRemovedSurfaces.Append(oldSurfaceId);
sl@0: 		}
sl@0: 
sl@0: 	//order placed element correctly in iPlacedElements
sl@0: 	TPlacedAttributes tempAttributes = iPlacedElements[aIndex];
sl@0: 	iPlacedElements.Remove(aIndex);
sl@0: 	//keep cache up to date
sl@0: 	if (iCache.Count() > aIndex)
sl@0: 		{
sl@0: 		iCache[aIndex].Close();
sl@0: 		iCache.Remove(aIndex);
sl@0: 		}
sl@0: 
sl@0: 	WS_ASSERT_DEBUG(iHighestReusedIndex != -1,EWsPanicRecycleElement);
sl@0: 	if (iHighestReusedIndex == -1)
sl@0: 		{
sl@0: 		return KErrArgument;
sl@0: 		}
sl@0: 	
sl@0: 	error = iPlacedElements.Insert(tempAttributes, iHighestReusedIndex);
sl@0: 	if (error < KErrNone)
sl@0: 		{	//must destroy the element and leave.  Old elements surface unregistration already dealt with
sl@0: 		aScene.DestroySceneElement(tempAttributes.iElement);
sl@0: 		clippedRegion.Close();
sl@0: 		return KErrNoMemory;
sl@0: 		}
sl@0: 	returnValue|=EResort;	//element has been moved, will need a resort
sl@0: 	//set placed element attributes
sl@0: 	iPlacedElements[iHighestReusedIndex].SetUnassigned(EFalse);
sl@0: 	iPlacedElements[iHighestReusedIndex].SetLockedConfig(ETrue);
sl@0: 	iPlacedElements[iHighestReusedIndex].SetChangedClip(ETrue);
sl@0: 	
sl@0: 	TRect tempViewport;
sl@0: 	aSurfaceConfiguration.GetViewport(tempViewport);
sl@0: 
sl@0: 	TBool cacheSaved = EFalse;
sl@0: 	if (iCache.Count() >= iHighestReusedIndex)
sl@0: 		{	//need to update cache with visible region of element
sl@0: 		TBool insertSuccess = InsertCache(iHighestReusedIndex);
sl@0: 		if (insertSuccess != EFalse)
sl@0: 			{
sl@0: 			iCache[iHighestReusedIndex].Copy(clippedRegion);
sl@0: 			if (!iCache[iHighestReusedIndex].CheckError())
sl@0: 				{
sl@0: 				cacheSaved = ETrue;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if (cacheSaved == EFalse)
sl@0: 		{	//need to set clipping to element immediately
sl@0: 		TInt count = iCache.Count();
sl@0: 		while(count > iHighestReusedIndex)
sl@0: 			{	//if there is cache where we wished to insert, it and everything above is now invalid
sl@0: 			iCache[count-1].Close();
sl@0: 			iCache.Remove(count-1);
sl@0: 			count--;
sl@0: 			};
sl@0: 		}
sl@0: 	clippedRegion.Close();
sl@0: 	return returnValue;
sl@0: 	}
sl@0: 
sl@0: /** Create a new element for the placed surface.
sl@0: 
sl@0: @param aSurfaceConfiguration The surface configuration for the surface to place.
sl@0: @param aUserDefinedRegion The user defined clipping of the window.
sl@0: @param aScene Access to the scene.
sl@0: @return Serious error, otherwise flags to describe what extra work needs doing.
sl@0: 
sl@0: @see CWindowElement::AssignPlacedElement
sl@0: */
sl@0: TInt CWindowElement::AssignCreateElement(const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& aScene)
sl@0: 	{
sl@0: 	TInt returnValue = 0;
sl@0: 	TInt error = KErrNone;
sl@0: 	STACK_REGION clippedRegion;
sl@0: 	TRect surfaceExtent;
sl@0: 	aSurfaceConfiguration.GetExtent(surfaceExtent);
sl@0: 	//calculate region
sl@0: 	clippedRegion.AddRect(surfaceExtent);
sl@0: 	clippedRegion.Intersect(aUserDefinedRegion);
sl@0: 	if (clippedRegion.CheckError())
sl@0: 		{	//failed, return KErrNoMemory
sl@0: 		clippedRegion.Close();
sl@0: 		return KErrNoMemory;
sl@0: 		}
sl@0: 	
sl@0: 	TPlacedAttributes newElement;
sl@0: 	if (iHighestReusedIndex == -1)
sl@0: 		{
sl@0: 		error = iPlacedElements.Insert(newElement,0);
sl@0: 		}
sl@0: 	else
sl@0: 		{	//insert above current highest reused element
sl@0: 		error = iPlacedElements.Insert(newElement,iHighestReusedIndex+1);
sl@0: 		}
sl@0: 	if (error >= KErrNone)
sl@0: 		{
sl@0: 		iHighestReusedIndex++;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		//FAILED! LEAVE FUNCTION. nothing has been changed
sl@0: 		clippedRegion.Close();
sl@0: 		return KErrNoMemory;
sl@0: 		}
sl@0: 
sl@0: 	//create new element with new configuration
sl@0: 	MWsElement* element = NULL;
sl@0: 	TRAP(error,element = aScene.CreateSceneElementL());
sl@0: 	if (error != KErrNone)
sl@0: 		{
sl@0: 		//FAILED! LEAVE FUNCTION. nothing has been changed
sl@0: 		clippedRegion.Close();
sl@0: 		return error;
sl@0: 		}
sl@0: 
sl@0: 	element->SetGlobalAlpha( 0xFF );
sl@0: 
sl@0: 	iPlacedElements[iHighestReusedIndex].iElement = element;
sl@0: 	error = SetElement(*element,aSurfaceConfiguration,EFalse);
sl@0: 	if (error < KErrNone)
sl@0: 		{
sl@0: 		//must be a bad surface id or viewport. Leave now.
sl@0: 		aScene.DestroySceneElement(element);
sl@0: 		clippedRegion.Close();
sl@0: 		iPlacedElements.Remove(iHighestReusedIndex);
sl@0: 		iHighestReusedIndex--;
sl@0: 		return error;
sl@0: 		}
sl@0: 	
sl@0: 	//Now certain that these must be flagged
sl@0: 	returnValue|=EFastPath;
sl@0: 	returnValue|=EPauseComposition;
sl@0: 	returnValue|=EResort;
sl@0: 
sl@0: 	//set placed element attributes
sl@0: 	iPlacedElements[iHighestReusedIndex].SetUnassigned(EFalse);
sl@0: 	iPlacedElements[iHighestReusedIndex].SetChangedClip(ETrue);
sl@0: 	iPlacedElements[iHighestReusedIndex].SetLockedConfig(ETrue);
sl@0: 	
sl@0: 	TRect tempViewport;
sl@0: 	aSurfaceConfiguration.GetViewport(tempViewport);
sl@0: 
sl@0: 	TBool cacheSaved = EFalse;
sl@0: 	if (iCache.Count() >= iHighestReusedIndex)
sl@0: 		{	//should try to add new elements region to cache
sl@0: 		TBool insertSuccess = InsertCache(iHighestReusedIndex);
sl@0: 		if (insertSuccess != EFalse)
sl@0: 			{
sl@0: 			iCache[iHighestReusedIndex].Copy(clippedRegion);
sl@0: 			if (!iCache[iHighestReusedIndex].CheckError())
sl@0: 				{
sl@0: 				cacheSaved = ETrue;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if (cacheSaved == EFalse)
sl@0: 		{	//need to clear cache from this point onward, and set clipping to element immediately
sl@0: 		TInt count = iCache.Count();
sl@0: 		while(count > iHighestReusedIndex)
sl@0: 			{	//if there is cache where we wished to insert, it and everything above is now invalid
sl@0: 			iCache[count-1].Close();
sl@0: 			iCache.Remove(count-1);
sl@0: 			count--;
sl@0: 			};
sl@0: 		}
sl@0: 	//add the new element to the scene
sl@0:     error = aScene.InsertSceneElement(element, NULL);    //place at the back. will get ordered correctly later
sl@0: 	WS_ASSERT_DEBUG(error == KErrNone,EWsPanicSceneErrorIgnored);
sl@0: 	clippedRegion.Close();
sl@0: 	return returnValue;
sl@0: 	}
sl@0: 
sl@0: /** Extend an existing placed surface element.
sl@0: 
sl@0: @param The index of the element to extend.
sl@0: @param aSurfaceConfiguration The surface configuration for the surface to place.
sl@0: @param aUserDefinedRegion The user defined clipping of the window.
sl@0: @param aScene Access to the scene.
sl@0: @return Serious error, otherwise flags to describe what extra work needs doing.
sl@0: 
sl@0: @see CWindowElement::AssignPlacedElement
sl@0: */
sl@0: TInt CWindowElement::AssignExtendElement(const TInt aIndex, const TSurfaceConfiguration& aSurfaceConfiguration, const TRegion& aUserDefinedRegion, MWsScene& /*aScene*/)
sl@0: 	{
sl@0: 	TInt returnValue = 0;
sl@0: 	TInt error = KErrNone;
sl@0: 	STACK_REGION backupRegionAgainstFail;
sl@0: 	STACK_REGION clippedRegion;
sl@0: 	TRect surfaceExtent;
sl@0: 	aSurfaceConfiguration.GetExtent(surfaceExtent);
sl@0: 	TRect surfaceViewport;
sl@0: 	aSurfaceConfiguration.GetViewport(surfaceViewport);
sl@0: 	
sl@0: 	if (!iPlacedElements[aIndex].LockedConfig())
sl@0: 		{	//set element now. If viewport is invalid its ok to fail now
sl@0: 		error = SetElement(*iPlacedElements[aIndex].iElement,aSurfaceConfiguration,ETrue);
sl@0: 		if (error < KErrNone)
sl@0: 			{
sl@0: 			backupRegionAgainstFail.Close();
sl@0: 			clippedRegion.Close();
sl@0: 			return error;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if(iPlacedElements[aIndex].Unassigned() && !iPlacedElements[aIndex].Overlapping())
sl@0: 		{
sl@0: 		//backup stays clear
sl@0: 		clippedRegion.Copy(aUserDefinedRegion);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		clippedRegion.Copy(iNonRedrawVisibleRegion);
sl@0: 		if (iCache.Count() > aIndex)	//if cache is ok
sl@0: 			{
sl@0: 			clippedRegion.Intersect(iCache[aIndex]);
sl@0: 			clippedRegion.Union(iCache[aIndex]);	//previously added regions should be kept
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			STACK_REGION tempSurfaceBaseArea;
sl@0:             TRect destinationRect;
sl@0:             iPlacedElements[aIndex].iElement->GetDestinationRectangle(destinationRect);
sl@0:             tempSurfaceBaseArea.AddRect(destinationRect);
sl@0: 			tempSurfaceBaseArea.Offset(surfaceExtent.iTl);
sl@0: 			clippedRegion.Intersect(tempSurfaceBaseArea);
sl@0: 			clippedRegion.Union(tempSurfaceBaseArea);
sl@0: 			tempSurfaceBaseArea.Close();
sl@0: 			}
sl@0: 		backupRegionAgainstFail.Copy(clippedRegion);
sl@0: 		//clipped region should contain something
sl@0: 		clippedRegion.Union(aUserDefinedRegion);
sl@0: 		}
sl@0: 	clippedRegion.ClipRect(surfaceExtent);
sl@0: 	
sl@0: 	if (backupRegionAgainstFail.CheckError() || clippedRegion.CheckError())
sl@0: 		{	//failed critical calculations, leave now before anything has been changed
sl@0: 		clippedRegion.Close();
sl@0: 		backupRegionAgainstFail.Close();
sl@0: 		return KErrNoMemory;
sl@0: 		}
sl@0: 
sl@0: 	TBool setCache = EFalse;
sl@0: 	if (iCache.Count() > aIndex)	//if Cache is ok
sl@0: 		{
sl@0: 		//compare
sl@0: 		TInt compareReturn;
sl@0: 		compareReturn = TRegionExtend::Cast(iCache[aIndex]).TestDifference(clippedRegion);
sl@0: 
sl@0: 		if (compareReturn&TRegionExtend::EDiffers)	//element has changed
sl@0: 			{
sl@0: 			iPlacedElements[aIndex].SetChangedClip(ETrue);
sl@0: 			if (compareReturn&TRegionExtend::EAdd)	//element has become revealed on the screen
sl@0: 				{
sl@0: 				returnValue|=EPauseComposition;	//need to pause before the end of assign placed element
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				returnValue|=EFastPath;	//fastpath and pause will be called during cleanup
sl@0: 				}
sl@0: 			}
sl@0: 		
sl@0: 		//copy clipped region to cache
sl@0: 		iCache[aIndex].Copy(clippedRegion);	//can fail
sl@0: 		setCache = ETrue;
sl@0: 		if (iCache[aIndex].CheckError())
sl@0: 			{	//copy failed, remove cache from this element onwards
sl@0: 			TInt count = iCache.Count();
sl@0: 			while(count > aIndex)
sl@0: 				{	//if there is cache where we wished to insert, it and everything above is now invalid
sl@0: 				iCache[count-1].Close();
sl@0: 				iCache.Remove(count-1);
sl@0: 				count--;
sl@0: 				};
sl@0: 			setCache = EFalse;
sl@0: 			}
sl@0: 		}
sl@0: 	if (setCache == EFalse)
sl@0: 		{	//need to pause composition and update element immediately
sl@0: 		returnValue|=EPauseComposition;
sl@0: 		}
sl@0: 	iPlacedElements[aIndex].SetUnassigned(EFalse);
sl@0: 	iPlacedElements[aIndex].SetLockedConfig(ETrue);
sl@0: 	iHighestReusedIndex = aIndex;
sl@0: 	backupRegionAgainstFail.Close();
sl@0: 	clippedRegion.Close();
sl@0: 	return returnValue;
sl@0: 	}
sl@0: 
sl@0: /** Called at the end of a redraw to set cached changed to elements, and
sl@0: removed elements that are still unassigned.
sl@0: 
sl@0: @param aScene Access to the scene.
sl@0: @return Flags to describe what extra work needs doing.
sl@0: @see CWindowElementSet::CleanUpPlacedElements
sl@0: */
sl@0: TInt CWindowElement::CleanUpPlacedElements(MWsScene& aScene, TInt aGcDrawingCount)
sl@0: 	{
sl@0: 	if (iStartGcDrawingCount!=aGcDrawingCount)
sl@0: 		{
sl@0: 		FlagAssignedElementsDrawnOver(aGcDrawingCount);
sl@0: 		}
sl@0: 	TInt returnFlags = iFlags;
sl@0: 	if (iFlags > 0)
sl@0: 		{	//copy flags to return, and ensure pause is flagged
sl@0: 		returnFlags|=EPauseComposition;
sl@0: 		}
sl@0: 	TInt ii;
sl@0: 	TBool removeElements = EFalse;
sl@0: 	//destroy placed element reference
sl@0: 	for (ii=0; ii<iPlacedElements.Count(); ii++)
sl@0: 		{
sl@0: 		if (iPlacedElements[ii].Unassigned() && !iPlacedElements[ii].Overlapping())
sl@0: 			{
sl@0: 			returnFlags|=EFastPath;	//need to invoke 1108
sl@0: 			if (iRemovedSurfacesValid)
sl@0: 				{
sl@0: 				iRemovedSurfaces.Append(iPlacedElements[ii].iElement->ConnectedSurface());
sl@0: 				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();
sl@0: 				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
sl@0: 				NotifyReleasingSurface(tempId);
sl@0: 				}
sl@0: 			removeElements = ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if (removeElements)
sl@0: 		{	//there will be elements to remove
sl@0: 		for (ii=0; ii<iPlacedElements.Count(); ii++)
sl@0: 			{
sl@0: 			if (iPlacedElements[ii].iElement->ConnectedSurface().IsNull())
sl@0: 				{
sl@0: 				aScene.DestroySceneElement(iPlacedElements[ii].iElement);
sl@0: 				iPlacedElements.Remove(ii);
sl@0: 				if (iCache.Count() > ii)
sl@0: 					{	//there is cache for this element, remove it
sl@0: 					iCache[ii].Close();
sl@0: 					iCache.Remove(ii);
sl@0: 					}
sl@0: 				ii--;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if (iRemovedSurfaces.Count() > 1)
sl@0: 		{	//remove duplicates of surface id from removal list
sl@0: 		for (ii = 0; ii < iRemovedSurfaces.Count() - 1; ii++)
sl@0: 			{
sl@0: 			for (TInt jj = ii+1; jj < iRemovedSurfaces.Count(); jj++)
sl@0: 				{
sl@0: 				if (iRemovedSurfaces[ii] == iRemovedSurfaces[jj])
sl@0: 					{
sl@0: 					iRemovedSurfaces.Remove(jj);
sl@0: 					jj--;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	
sl@0: 	//do global search for surface ids
sl@0: 	while (iRemovedSurfaces.Count()>0)
sl@0: 		{
sl@0: 		TInt tempRemoval = iRemovedSurfaces.Count() - 1;
sl@0: 		NotifyReleasingSurface(iRemovedSurfaces[tempRemoval]);
sl@0: 		iRemovedSurfaces.Remove(tempRemoval);
sl@0: 		};
sl@0: 
sl@0: 	iRemovedSurfaces.Reset();
sl@0: 
sl@0: 	//clip unassigned overlapping entries, mark as changedclip if region changed
sl@0: 	for (ii=0; ii<iPlacedElements.Count(); ii++)
sl@0: 		{
sl@0: 		if (iPlacedElements[ii].Unassigned())	//non overlapping unassigned have already been destroyed
sl@0: 			{	//these must overlap
sl@0: 			TBool failureOccured = EFalse;
sl@0: 			if (iCache.Count() > ii)
sl@0: 				{
sl@0: 				//if cache region is entirely inside non redraw vis region, nothing to update!
sl@0: 				TInt changed = 
sl@0: 						TRegionExtend::Cast(iCache[ii]).TestDifference(iNonRedrawVisibleRegion);
sl@0: 				if (changed&TRegionExtend::ESub)
sl@0: 					{	//the clipping will change
sl@0: 					iCache[ii].Intersect(iNonRedrawVisibleRegion);
sl@0: 					if (iCache[ii].CheckError())
sl@0: 						{
sl@0: 						failureOccured = ETrue;
sl@0: 						iCache[ii].Close();
sl@0: 						iCache.Remove(ii);
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: 						iPlacedElements[ii].SetChangedClip(ETrue);	//changed clipping
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{	//attempt getting element region to perform calculation and update element directly
sl@0: 				STACK_REGION elementRegion;
sl@0: 	            TRect destinationRect;
sl@0: 	            iPlacedElements[ii].iElement->GetDestinationRectangle(destinationRect);
sl@0: 	            elementRegion.AddRect(destinationRect);
sl@0: 				if (elementRegion.CheckError())
sl@0: 					{
sl@0: 					failureOccured = ETrue;
sl@0: 					}
sl@0: 				else
sl@0: 					{
sl@0: 					TRect elementExtent;
sl@0: 					iPlacedElements[ii].iElement->GetDestinationRectangle(elementExtent);
sl@0: 					elementRegion.Offset(elementExtent.iTl);	//get element region into absolute coordinates
sl@0: 					TInt changed =
sl@0: 						TRegionExtend::Cast(elementRegion).TestDifference(iNonRedrawVisibleRegion);
sl@0: 					if (changed&TRegionExtend::ESub)
sl@0: 						{	//need to clip element back
sl@0: 						elementRegion.Intersect(iNonRedrawVisibleRegion);
sl@0: 						if (!elementRegion.CheckError())
sl@0: 							{
sl@0: 							elementRegion.Offset(-elementExtent.iTl);	//put element region back into relative coords
sl@0: 							returnFlags|=EFastPath;
sl@0: 							}
sl@0: 						else
sl@0: 							{
sl@0: 							failureOccured = ETrue;
sl@0: 							}
sl@0: 						}
sl@0: 					}
sl@0: 				elementRegion.Close();
sl@0: 				}
sl@0: 			if (failureOccured)
sl@0: 				{	//need to release element
sl@0: 				TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();
sl@0: 				iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
sl@0: 				NotifyReleasingSurface(tempId);
sl@0: 				aScene.DestroySceneElement(iPlacedElements[ii].iElement);
sl@0: 				returnFlags|=EFailed;
sl@0: 				iPlacedElements.Remove(ii);	//remove placed element entry, cache is already removed
sl@0: 				ii--;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	//update any elements marked as changedclip , clear all cache, clear flags
sl@0: 	for (ii=0; ii<iPlacedElements.Count(); ii++)
sl@0: 		{
sl@0: 		if (iPlacedElements[ii].ChangedClip())
sl@0: 			{
sl@0: 			returnFlags|=EFastPath;	//need to invoke 1108
sl@0: 			}
sl@0: 		else
sl@0: 			if (	!(returnFlags&EFastPath)
sl@0: 				&&	iPlacedElements[ii].LockedConfig() && !iPlacedElements[ii].Unassigned()
sl@0: 				&&	iPlacedElements[ii].DrawnOver()!=iPlacedElements[ii].DrawnOverLast()	)
sl@0: 						{
sl@0: 						returnFlags|=EFastPath;
sl@0: 						}
sl@0: 		iPlacedElements[ii].ClearRedrawFlags();
sl@0: 		if (iCache.Count() > ii)
sl@0: 			{
sl@0: 			iCache[ii].Clear();
sl@0: 			}
sl@0: 		}
sl@0: 	iCache.Reset();
sl@0: 	iNonRedrawVisibleRegion.Clear();
sl@0: 	iHighestReusedIndex = -1;
sl@0: 	return returnFlags;
sl@0: 	}
sl@0: 
sl@0: /** Move all elements in this windowelement to above the supplied element in the scene
sl@0: 
sl@0: @param aScene Access to the scene.
sl@0: @param aElement The element to set all this windows elements above.
sl@0: */
sl@0: 
sl@0: void CWindowElement::MoveToAboveGivenElement(MWsScene& aScene, MWsElement* aElement)
sl@0: 	{
sl@0: 	MWsElement* newAboveElement = iBackgroundElement.iElement;
sl@0: 	MWsElement* previousAboveElement = aElement;
sl@0: 	if (newAboveElement)
sl@0: 		{
sl@0: 		aScene.InsertSceneElement(newAboveElement, previousAboveElement);	//background element is put on first
sl@0: 		previousAboveElement = newAboveElement;		
sl@0: 		}
sl@0: 	TInt placedElements = iPlacedElements.Count();
sl@0: 	if (placedElements != 0)
sl@0: 		{
sl@0: 		for (TInt ii = 0; ii < placedElements; ii++)
sl@0: 			{
sl@0: 			newAboveElement = iPlacedElements[ii].iElement;
sl@0: 			aScene.InsertSceneElement(newAboveElement, previousAboveElement);	//place element above previous above element
sl@0: 			previousAboveElement = newAboveElement;	
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** Updates the elements extent, whether from a window movement or a change in window size
sl@0: 
sl@0: @param aOffset The movement of the window.  If NULL then the window has changed size.
sl@0: @see CWindowElementSet::UpdateElementExtent
sl@0: */
sl@0: void CWindowElement::UpdateElementExtent(const TPoint* aOffset)
sl@0: 	{
sl@0: 	if (aOffset)	//window moved
sl@0: 		{
sl@0: 		TRect tempExtent;
sl@0: 		MWsElement* element = iBackgroundElement.iElement;
sl@0: 		TBool complete = EFalse;
sl@0: 		TInt placedElementDone = -1;
sl@0: 		while (!complete)
sl@0: 			{
sl@0: 			if (!element && placedElementDone < iPlacedElements.Count()-1)
sl@0: 				{
sl@0: 				placedElementDone++;
sl@0: 				element = iPlacedElements[placedElementDone].iElement;
sl@0: 				}
sl@0: 			if (!element)
sl@0: 				{
sl@0: 				complete = ETrue;
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				tempExtent = const_cast<CWsClientWindow&>(iWindow).GetOriginalDestElementRect();
sl@0: 				tempExtent.Move(*aOffset);
sl@0: 				element->SetDestinationRectangle(tempExtent);
sl@0: 				const_cast<CWsClientWindow&>(iWindow).SetOriginalDestElementRect(tempExtent);
sl@0: 				}
sl@0: 			element = NULL;
sl@0: 			}
sl@0: 		}
sl@0: 	else			//window changed size
sl@0: 		{
sl@0: 		if (!iBackgroundElement.ExplicitExtent() && iBackgroundElement.iElement)
sl@0: 			{
sl@0: 			iBackgroundElement.iElement->SetDestinationRectangle(iWindow.FullRect());
sl@0: 			const_cast<CWsClientWindow&>(iWindow).SetOriginalDestElementRect(iWindow.FullRect());
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** Checks the windows placed elements when the windows visibility is changed.
sl@0: If the placed elements are no longer visible, they are removed.
sl@0: 
sl@0: @param aRegion The new visible region of the window.
sl@0: @param aScene Access to the scene.
sl@0: @return ETrue if any elements have been removed, otherwise EFalse.
sl@0: @see CWindowElementSet::SetVisibleRegion
sl@0: */
sl@0: TBool CWindowElement::SetVisibleRegion(const TRegion& aRegion, MWsScene& aScene)
sl@0: 	{
sl@0: 	TBool retcode=EFalse;
sl@0: 	if (iPlacedElements.Count() == 0)
sl@0: 		{
sl@0: 		return EFalse;	//there is noting to do
sl@0: 		}
sl@0: 	
sl@0: 	STACK_REGION tempRegion;
sl@0: 	for (TInt ii = 0; ii < iPlacedElements.Count(); ii++)
sl@0: 		{
sl@0: 		TRect tempExtent;
sl@0:         tempRegion.Clear();
sl@0:         iPlacedElements[ii].iElement->GetDestinationRectangle(tempExtent);
sl@0:         tempRegion.AddRect(tempExtent);
sl@0: 		if (tempRegion.CheckError())	//if there was error getting region
sl@0: 			{
sl@0: 			tempRegion.Clear();
sl@0: 			tempRegion.AddRect(tempExtent);
sl@0: 			}
sl@0: 		else
sl@0: 			{	//offset basearea of element
sl@0: 			tempRegion.Offset(tempExtent.iTl);
sl@0: 			}
sl@0: 		TInt regionReturn = TRegionExtend::Cast(aRegion).TestDifference(tempRegion);
sl@0: 		if (regionReturn&TRegionExtend::ENoIntersect)
sl@0: 			{	//placed surface needs to be removed
sl@0: 			TSurfaceId tempId = iPlacedElements[ii].iElement->ConnectedSurface();
sl@0: 			iPlacedElements[ii].iElement->ConnectSurface(TSurfaceId::CreateNullId());
sl@0: 			NotifyReleasingSurface(tempId);
sl@0: 			aScene.DestroySceneElement(iPlacedElements[ii].iElement);
sl@0: 			retcode = ETrue;	//a element has been removed
sl@0: 			iPlacedElements.Remove(ii);
sl@0: 			if (iCache.Count() > ii)
sl@0: 				{	//keep cache up to date
sl@0: 				iCache[ii].Close();
sl@0: 				iCache.Remove(ii);
sl@0: 				}
sl@0: 			ii--;
sl@0: 			}
sl@0: 		}
sl@0: 	tempRegion.Close();
sl@0: 	return retcode;
sl@0: 	}
sl@0: 
sl@0: /** Checks if any of the windows element ids match the one in question.
sl@0: 
sl@0: @param aSurfaceId The surface id to match against.
sl@0: @return ETrue if a match is found, otherwise EFalse.
sl@0: 
sl@0: @see CWindowElementSet::SearchDuplicateSurfaceId
sl@0: */
sl@0: TBool CWindowElement::SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId)
sl@0: 	{
sl@0: 	if (iBackgroundElement.iElement)
sl@0: 		{
sl@0: 		if (iBackgroundElement.iElement->ConnectedSurface() == aSurfaceId)
sl@0: 			{
sl@0: 			return ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 	if (iPlacedElements.Count() > 0)
sl@0: 		{
sl@0: 		for (TInt ii = 0; ii < iPlacedElements.Count(); ii++)
sl@0: 			{
sl@0: 			if (iPlacedElements[ii].iElement)	//if removed without reserved space for ids, could be a null element
sl@0: 				{
sl@0: 				if (iPlacedElements[ii].iElement->ConnectedSurface() == aSurfaceId)
sl@0: 					{
sl@0: 					return ETrue;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: /** Sets the opacity for the background surface and if setting to 0 removes placed surfaces.
sl@0: 
sl@0: @param aOpacity The opacity to set.
sl@0: @param aScene Access to the scene.
sl@0: @see CWindowElementSet::SetElementOpacity
sl@0: */
sl@0: void CWindowElement::SetElementOpacity(TInt aOpacity, MWsScene& aScene)
sl@0: 	{
sl@0: 	if (iBackgroundElement.iElement)
sl@0: 		{
sl@0: 	    TUint32 flags = 0;
sl@0: 	    iBackgroundElement.iElement->GetTargetRendererFlags(flags);
sl@0: 	    flags |= MWsElement::EElementTransparencyGlobalAlpha;
sl@0: 		iBackgroundElement.iElement->SetTargetRendererFlags(MWsElement::EElementTransparencyGlobalAlpha);
sl@0: 		iBackgroundElement.iElement->SetGlobalAlpha(aOpacity);
sl@0: 		iBackgroundElement.SetConcealed(aOpacity==0);
sl@0: 		}
sl@0: 	if (aOpacity == 0)
sl@0: 		{
sl@0: 		while (iPlacedElements.Count() > 0)
sl@0: 			{	//remove any placed elements
sl@0: 			TInt placedElement = iPlacedElements.Count()-1;
sl@0: 			TSurfaceId tempId = iPlacedElements[placedElement].iElement->ConnectedSurface();
sl@0: 			iPlacedElements[placedElement].iElement->ConnectSurface(TSurfaceId::CreateNullId());
sl@0: 			NotifyReleasingSurface(tempId);
sl@0: 			aScene.DestroySceneElement(iPlacedElements[placedElement].iElement);
sl@0: 			iPlacedElements.Remove(placedElement);
sl@0: 			};
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: MWsElement* CWindowElement::Element() const
sl@0:     {
sl@0:     return iBackgroundElement.iElement;
sl@0:     }
sl@0: 
sl@0: //
sl@0: // CWindowElementSet
sl@0: //
sl@0: 
sl@0: /** Destroys the set of window-element pairs.
sl@0: */
sl@0: CWindowElementSet::~CWindowElementSet()
sl@0: 	{
sl@0: 	ASSERT(iElements.Count() == 0);
sl@0: 	iElements.Close();
sl@0: 	}
sl@0: 
sl@0: /** Basic NewL constructor
sl@0: @param aScene To allow access to the scene.
sl@0: @param aComposer To allow access to the composer.
sl@0: */
sl@0: CWindowElementSet* CWindowElementSet::NewL(MWsScene& aScene)
sl@0: 	{
sl@0: 	CWindowElementSet* wls = new (ELeave) CWindowElementSet(aScene);
sl@0: 	return wls;
sl@0: 	}
sl@0: 
sl@0: /** Sets a new background surface on the window supplied.
sl@0: Will remove any previous background surface.
sl@0: 
sl@0: @param aWindow The window to place a background surface on.
sl@0: @return A reference to the new background surface attributes.
sl@0: */
sl@0: TBackgroundAttributes& CWindowElementSet::AcquireBackgroundElementL(CWsClientWindow& aWindow)
sl@0: 	{
sl@0: 	// Find the matching element.
sl@0: 	TInt index;
sl@0: 	TInt result = FindEntry(aWindow, index);
sl@0: 	MWsElement* element;
sl@0: 
sl@0: 	// If a background element is already associated with the window, then unregister
sl@0: 	// the surface. Create and add a new element to scene.
sl@0: 	// This will ensure that the element has default values.
sl@0: 	if (result != KErrNotFound && iElements[index]->iBackgroundElement.iElement)
sl@0: 	    {
sl@0: 	    element = iElements[index]->iBackgroundElement.iElement;
sl@0: 		TSurfaceId surface = element->ConnectedSurface();
sl@0: 		element->ConnectSurface(TSurfaceId::CreateNullId());
sl@0: 		UnregisterSurface(surface);
sl@0: 		iScene.DestroySceneElement(element);
sl@0: 	    }
sl@0: 	if (index < 0)
sl@0: 		{
sl@0: 		index = 0;
sl@0: 		}
sl@0: 
sl@0: 	// Allocate a new element and add it to the set and the scene
sl@0: 	element = iScene.CreateSceneElementL();
sl@0: 	
sl@0: 	TInt returnCode;
sl@0: 	if (result == KErrNotFound)
sl@0: 		{
sl@0: 		CWindowElement* winelement = new CWindowElement(aWindow);
sl@0: 		if (!winelement)
sl@0: 			{
sl@0: 			iScene.DestroySceneElement(element);
sl@0: 			User::Leave(KErrNoMemory);
sl@0: 			}
sl@0: 		returnCode = iElements.Insert(winelement, index);
sl@0: 		if(returnCode != KErrNone)
sl@0: 		    {
sl@0: 		    delete winelement;
sl@0: 		    iScene.DestroySceneElement(element);
sl@0: 		    User::Leave(returnCode);
sl@0: 		    }
sl@0: 		}
sl@0: 
sl@0: 	// Use the element below the insertion point to decide where the element
sl@0: 	// goes in the scene
sl@0: 	returnCode = KErrNone;
sl@0: 	if (index == 0)
sl@0: 		{
sl@0: 		returnCode = iScene.InsertSceneElement(element, NULL);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		//Find highest element in window below
sl@0: 		MWsElement* below;
sl@0: 		TInt placedCount = iElements[index-1]->iPlacedElements.Count();
sl@0: 		if (placedCount > 0)
sl@0: 			{
sl@0: 			below = iElements[index-1]->iPlacedElements[placedCount-1].iElement;
sl@0: 			}
sl@0: 		else
sl@0: 			{	//below = above = background surface
sl@0: 			below = iElements[index-1]->iBackgroundElement.iElement;
sl@0: 			}
sl@0: 		returnCode = iScene.InsertSceneElement(element, below);
sl@0: 		}
sl@0: 	
sl@0: 	__ASSERT_DEBUG(returnCode == KErrNone, Panic(EWsPanicSceneErrorIgnored));
sl@0: 
sl@0: 	iElements[index]->iBackgroundElement.iElement = element;
sl@0: 	return iElements[index]->iBackgroundElement;
sl@0: 	}
sl@0: 
sl@0: /** Removes the background element of the specified window.
sl@0: 
sl@0: @param aWindow The window to remove the background element from.
sl@0: @param aWindowClosing ETrue if aWindow is in between closing state.
sl@0: @return KErrNone on success or a system-wide error code.
sl@0: */
sl@0: TInt CWindowElementSet::ReleaseBackgroundElement(const CWsClientWindow& aWindow, TBool aWindowClosing /*= EFalse*/)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 
sl@0: 	TInt err = FindEntry(aWindow, index, aWindowClosing);
sl@0: 	__ASSERT_DEBUG(err != KErrNotFound, Panic(EWsPanicNoWindowElement));
sl@0: 
sl@0: 	if (err==KErrNone)
sl@0: 		{
sl@0: 		CWindowElement* winElement=iElements[index];
sl@0: 		if (winElement->iPlacedElements.Count() == 0)
sl@0: 			{	//destroy the window entry
sl@0: 			DestroyWindowElementEntry(index);
sl@0: 			}
sl@0: 		else
sl@0: 			{	// just destroy the background
sl@0: 			if (winElement->iBackgroundElement.iElement)
sl@0: 				{
sl@0: 				winElement->iBackgroundElement.Destroy(iScene, ETrue);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /** Destroys the element associated with this set of attributes
sl@0: 
sl@0: @param aScene To allow access to the scene.
sl@0: @param aUnregister Whether to call unregister on the surface id.
sl@0: @return ETrue if a element existed to be destroyed, otherwise EFalse.
sl@0: */
sl@0: TBool TAttributes::Destroy(MWsScene& aScene, TBool aUnregister)
sl@0: 	{
sl@0: 	MWsElement* element = iElement;
sl@0: 	if (element)
sl@0: 		{
sl@0: 		TSurfaceId surface = element->ConnectedSurface();
sl@0: 		element->ConnectSurface(TSurfaceId::CreateNullId());
sl@0:         if (aUnregister)
sl@0:             {
sl@0:             aScene.UnregisterSurface(surface);
sl@0:             }
sl@0: 		aScene.DestroySceneElement(element);
sl@0: 		iElement = NULL;
sl@0: 		}
sl@0: 	return element!=NULL;
sl@0: 	}
sl@0: 
sl@0: /** Destroys all elements associated with the window and removes the window from the element set
sl@0: 
sl@0: @param aWinElementIndex The index of the window in the element set
sl@0: */
sl@0: void CWindowElementSet::DestroyWindowElementEntry(const TInt aWinElementIndex)
sl@0: 	{
sl@0: 	CWindowElement* winElement=iElements[aWinElementIndex];
sl@0: 	const CWsClientWindow& window = winElement->iWindow;
sl@0: 	winElement->iBackgroundElement.Destroy(iScene, ETrue);
sl@0: 	for (TInt placedIndex=0,maxindex=winElement->iPlacedElements.Count();placedIndex<maxindex;placedIndex++)
sl@0: 		{
sl@0: 		winElement->iPlacedElements[placedIndex].Destroy(iScene, EFalse);
sl@0: 		}
sl@0: 	winElement->iPlacedElements.Close();
sl@0: 	delete winElement;
sl@0: 	iElements.Remove(aWinElementIndex);
sl@0: 	window.Redraw()->SetHasElement(EFalse);
sl@0: 	window.Screen()->ElementRemoved();
sl@0: 	}
sl@0: 
sl@0: /** Removes all elements in the associated window.
sl@0: 
sl@0: @param aWindow The window to remove the elements for.
sl@0: @param aWindowClosing ETrue if aWindow is in between closing state.
sl@0: @return KErrNone on success, KErrNotFound if there was no windowelement entry.
sl@0: */
sl@0: TInt CWindowElementSet::ReleaseAllElements(const CWsClientWindow& aWindow, TBool aWindowClosing /*= EFalse*/)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 
sl@0: 	TInt err = FindEntry(aWindow, index, aWindowClosing);
sl@0: 	__ASSERT_DEBUG(err != KErrNotFound, Panic(EWsPanicNoWindowElement));
sl@0: 	if (err==KErrNone)
sl@0: 		{
sl@0: 		DestroyWindowElementEntry(index);
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /** For every window element, checks if any of the windows element ids match the one in question.
sl@0: 
sl@0: @param aSurfaceId The surface id to match against.
sl@0: @return ETrue if a match is found, otherwise EFalse.
sl@0: 
sl@0: @see CWindowElement::SearchDuplicateSurfaceId
sl@0: */
sl@0: TBool CWindowElementSet::SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId)
sl@0: 	{
sl@0: 	TInt windowElements = iElements.Count();
sl@0: 	for (TInt ii = 0; ii < windowElements; ii++)
sl@0: 		{
sl@0: 		if (iElements[ii]->SearchDuplicateSurfaceId(aSurfaceId))
sl@0: 			{
sl@0: 			return ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: /** For a window, sets the opacity for the background surface and if setting to 
sl@0: 0 removes placed surfaces.
sl@0: 
sl@0: @param aWindow The window to perform the function on.
sl@0: @param aOpacity The opacity to set.
sl@0: @see CWindowElement::SetElementOpacity
sl@0: */
sl@0: void CWindowElementSet::SetElementOpacity(CWsClientWindow& aWindow, TInt aOpacity)
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(aOpacity == 0 || aOpacity == 255,EWsPanicUnexpectedOpacity);
sl@0: 	return FindElement(aWindow)->SetElementOpacity(aOpacity, iScene);
sl@0: 	}
sl@0: 
sl@0: /** Finds all elements within the window that overlap with the region and 
sl@0: marks them as unassigned.
sl@0: If any part of these unassigned elements are outside the region, they are also 
sl@0: marked overlapping and locked config.
sl@0: 
sl@0: @param aRedrawRegion The region in which elements will be unassigned
sl@0: @param aWindow The window to perform the function on.
sl@0: @return KErrNone on success or KErrNoMemory if critical calculations could not be made.
sl@0: @see CWindowElement::UnassignPlacedElements
sl@0: */
sl@0: TInt CWindowElementSet::UnassignPlacedElements(const TRegion& aRedrawRegion, const CWsClientWindow& aWindow, TInt aGcDrawingCount)
sl@0: 	{
sl@0: 	return FindElement(aWindow)->UnassignPlacedElements(aRedrawRegion, aGcDrawingCount);
sl@0: 	}
sl@0: 
sl@0: /** Called to place a element within the window.
sl@0: It will either create a new element, recycle a element, or extend a element .
sl@0: 
sl@0: @param aPlacedAttributes Returns the attributes of the surface placed.
sl@0: @param aSurfaceConfiguration The surface configuration for the surface to place.
sl@0: @param aUserDefinedRegion The user defined clipping of the window.
sl@0: @param aWindow The window to perform the function on.
sl@0: @return KErrNone on success or a system-wide error code.
sl@0: @see CWindowElement::AssignPlacedElement
sl@0: */
sl@0: TInt CWindowElementSet::AssignPlacedElement(
sl@0: 		TPlacedAttributes*& aPlacedAttributes,
sl@0: 		const TSurfaceConfiguration& aSurfaceConfiguration,
sl@0: 		const TRegion& aUserDefinedRegion,
sl@0: 		const CWsClientWindow& aWindow,
sl@0: 		TInt aGcDrawingCount	)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 	TInt error = KErrNone;
sl@0: 	TInt result = FindEntry(aWindow, index);
sl@0: 	TBool insertedElement = EFalse;
sl@0: 	if (result == KErrNotFound)
sl@0: 		{
sl@0: 		CWindowElement* winelement = new CWindowElement(aWindow);
sl@0: 		if (!winelement)
sl@0: 			{
sl@0: 			return KErrNoMemory;		//memory error
sl@0: 			}
sl@0: 		error = iElements.Insert(winelement, index);
sl@0: 		if (error == KErrNone)
sl@0: 			{
sl@0: 			insertedElement = ETrue;
sl@0: 			aWindow.Redraw()->SetHasElement(ETrue);
sl@0: 			STACK_REGION windowRegion = aWindow.Abs();
sl@0: 			if (!windowRegion.CheckError())
sl@0: 				{
sl@0: 				error = iElements[index]->UnassignPlacedElements(windowRegion, aGcDrawingCount);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				error = KErrNoMemory;
sl@0: 				}
sl@0: 			windowRegion.Close();
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			delete winelement;
sl@0: 			}
sl@0: 		}
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		
sl@0: 		TInt assignReturn = iElements[index]->AssignPlacedElement(aPlacedAttributes, aSurfaceConfiguration,
sl@0: 				aUserDefinedRegion, iScene, aGcDrawingCount);
sl@0: 		error = assignReturn;	//return assign flags
sl@0: 		}
sl@0: 	if (error < KErrNone && insertedElement)
sl@0: 		{	//remove this element that has just been created
sl@0: 		aWindow.Redraw()->SetHasElement(EFalse);
sl@0: 		iElements.Remove(index);
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: /** Marks all elements that have been assigned since the unassign as drawn over.
sl@0: 
sl@0: @param aWindow The window to perform the function on.
sl@0: @see CWindowElement::FlagAssignedElementsDrawnOver
sl@0: **/
sl@0: //void CWindowElementSet::FlagAssignedElementsDrawnOver(const CWsClientWindow& aWindow)
sl@0: //	{
sl@0: //	FindElement(aWindow)->FlagAssignedElementsDrawnOver();
sl@0: //	}
sl@0: 
sl@0: /** Called at the end of a redraw to set cached changed to elements, and
sl@0: removed elements that are still unassigned.
sl@0: 
sl@0: @param aWindow The window to perform the function on.
sl@0: @return Flags to describe what extra work needed doing.
sl@0: @see CWindowElement::CleanUpPlacedElements
sl@0: */
sl@0: TInt CWindowElementSet::CleanUpPlacedElements(const CWsClientWindow& aWindow, TInt aGcDrawingCount)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 	TInt error = FindEntry(aWindow,index);
sl@0: 	if (error < 0)
sl@0: 		{
sl@0: 		WS_ASSERT_DEBUG(0,EWsPanicNoWindowElement);
sl@0: 		return error;
sl@0: 		}
sl@0: 	TInt returnFlags = iElements[index]->CleanUpPlacedElements(iScene, aGcDrawingCount);
sl@0: 
sl@0: 	if (!iElements[index]->iBackgroundElement.iElement && iElements[index]->iPlacedElements.Count() == 0)
sl@0: 		{	//remove window entry
sl@0: 		DestroyWindowElementEntry(index);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if (returnFlags&CWindowElement::EResort)
sl@0: 			{	//need to sort elements
sl@0: 			//find front most visible element in window behind, invoke sort by z order
sl@0: 			if (index == 0)
sl@0: 				{	//this element is backmost window
sl@0: 				iElements[index]->MoveToAboveGivenElement(iScene,NULL);
sl@0: 				}
sl@0: 			else
sl@0: 				{	//place infront of highest element behind
sl@0: 				if (iElements[index-1]->iPlacedElements.Count() == 0)
sl@0: 					{	//top element of element behind must be the background element
sl@0: 					iElements[index]->MoveToAboveGivenElement(iScene,iElements[index-1]->iBackgroundElement.iElement);				
sl@0: 					}
sl@0: 				else
sl@0: 					{	//top element of element behind must be highest placed element
sl@0: 					TInt placedCount = iElements[index-1]->iPlacedElements.Count();
sl@0: 					iElements[index]->MoveToAboveGivenElement(iScene,iElements[index-1]->iPlacedElements[placedCount-1].iElement);
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if (returnFlags&CWindowElement::EFailed)
sl@0: 		{	//visible elements may have been deleted, error to suggest a full window redraw
sl@0: 		return KErrGeneral;
sl@0: 		}
sl@0: 	return returnFlags;
sl@0: 	}
sl@0: 
sl@0: /** Counts how many elements there are in the set.
sl@0: 
sl@0: @return The number of elements in the set.
sl@0: */
sl@0: TInt CWindowElementSet::Count() const
sl@0: 	{
sl@0: 	return iElements.Count();
sl@0: 	}
sl@0: 
sl@0: /** Returns the background attributes for the specified window
sl@0: 
sl@0: @param aWindow The window to perform the function on.
sl@0: @return The background surface attributes.  If the window has no elementset entry, returns NULL.
sl@0: */
sl@0: TBackgroundAttributes* CWindowElementSet::FindBackgroundElement(const CWsClientWindow& aWindow)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 	TInt err = FindEntry(aWindow, index);
sl@0: 
sl@0: 	if (err != KErrNotFound)
sl@0: 		{
sl@0: 		return &(iElements[index]->iBackgroundElement);
sl@0: 		}
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: /**	Returns the contents of the element data associated with the input window.
sl@0: If this method is successful, then neither pointer will be NULL.
sl@0: 
sl@0: @return standard symbian error code.
sl@0: @param	aWindow	window to find
sl@0: @param	aBackAttr	backgroud surface attributes associated with the window
sl@0: @param	aPlacedAttr	array of placed surface attributes associated with the window.
sl@0: */
sl@0: TInt CWindowElementSet::FindElements(	CWsClientWindow const &aWindow, 
sl@0: 									TBackgroundAttributes const * & aBackAttr, 
sl@0: 									RArray<class TPlacedAttributes> const * &	aPlacedAttr	)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 
sl@0: 	TInt err = FindEntry(aWindow, index);
sl@0: //	__ASSERT_DEBUG(err != KErrNotFound, Panic(EWsPanicNoWindowElement));
sl@0: 
sl@0: //	return *iElements[index].iElement;
sl@0: 	if (err >= KErrNone)
sl@0: 		{
sl@0: 		aBackAttr=&iElements[index]->iBackgroundElement;
sl@0: 		aPlacedAttr=&iElements[index]->iPlacedElements;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		aBackAttr=NULL;
sl@0: 		aPlacedAttr=NULL;
sl@0: 		}
sl@0: 	return err;
sl@0: 	
sl@0: 	}
sl@0: 
sl@0: /** Registers the surface with the compositor.
sl@0: @param aSurface The surface id to register.
sl@0: @return  KErrNone if successful, KErrNoMemory if registration fails due to low
sl@0: memory, KErrNotSupported if the surface is not compatible with
sl@0: this compositor or KErrBadHandle if the given surface ID does not
sl@0: represent a valid surface. KErrArgument is returned if the
sl@0: surface does not have both dimensions less than 32 767 pixels.
sl@0: */
sl@0: TInt CWindowElementSet::RegisterSurface(const TSurfaceId& aSurface)
sl@0:     {
sl@0:     
sl@0:     return iScene.RegisterSurface(aSurface);
sl@0:     }
sl@0: 
sl@0: /** Unregisters the surface with the compositor.
sl@0: 
sl@0: @param aSurface The surface id to register.
sl@0: @return  KErrNone if successful. KErrInUse if the surface is
sl@0: used by a layer or layers. KErrBadHandle if the surface
sl@0: is not currently registered. KErrArgument if
sl@0: the surface ID is a NULL ID.
sl@0: */
sl@0: 
sl@0: void CWindowElementSet::UnregisterSurface(const TSurfaceId& aSurface)
sl@0:     {
sl@0:     
sl@0:     TInt returnCode = iScene.UnregisterSurface(aSurface);
sl@0:     __ASSERT_DEBUG((returnCode==KErrNone || returnCode==KErrInUse || returnCode==KErrBadHandle), Panic(EWsPanicSceneErrorIgnored));
sl@0:     }
sl@0: 
sl@0: /** Sorts the array elements into the same order as the windows are in the
sl@0: hierarchy. Use after window hierarchy has been modified, to update the scene
sl@0: order to match.
sl@0: @return EFalse if element order unchanged, ETrue if order may have changed.
sl@0: */
sl@0: TBool CWindowElementSet::SortByZOrder()
sl@0: 	{
sl@0: 	if (iElements.Count() < 2)
sl@0: 		{
sl@0: 		// Early out for the very common cases where there are zero or one
sl@0: 		// elements, which cannot therefore be out of order.
sl@0: 		return EFalse;
sl@0: 		}
sl@0: 
sl@0: 	// The approach being used is to first just sort the array, then update the 
sl@0: 	// scene order afterwards. This is simple to code and since there are not
sl@0: 	// expected to be many elements, it should be perfectly good enough.
sl@0: 
sl@0: 	TLinearOrder<CWindowElement> order(WindowOrder);
sl@0: 	iElements.Sort(order);
sl@0: 
sl@0: 	TBool orderChanged = EFalse;
sl@0: 	MWsElement* below;
sl@0: 	TInt elementCount = iElements.Count();
sl@0: 	for (TInt index = 0; index < elementCount; index++)
sl@0: 		{
sl@0: 		if (index == 0)
sl@0: 			{
sl@0: 			below = NULL;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			//Find highest element in window below
sl@0: 			TInt placedCount = iElements[index-1]->iPlacedElements.Count();
sl@0: 			if (placedCount > 0)
sl@0: 				{
sl@0: 				below = iElements[index-1]->iPlacedElements[placedCount-1].iElement;
sl@0: 				}
sl@0: 			else
sl@0: 				{	//below = above = background surface
sl@0: 				below = iElements[index-1]->iBackgroundElement.iElement;
sl@0: 				}
sl@0: 			}
sl@0: 		//Find lowest element in above window element
sl@0: 		MWsElement* above;
sl@0: 		if (iElements[index]->iBackgroundElement.iElement != NULL)
sl@0: 			{	//use background element
sl@0: 			above = iElements[index]->iBackgroundElement.iElement;	//background element will be bottom
sl@0: 			}
sl@0: 		else	//use bottom element of placed surfaces
sl@0: 			{
sl@0: 			//above = iElements[index]->iPlacedElements[iElements[index]->iPlacedElements.Count()-1].iElement;	//first or last placed element is bottom?
sl@0: 			above = iElements[index]->iPlacedElements[0].iElement;
sl@0: 			}
sl@0: 		if (above->ElementBelow() != below)
sl@0: 			{
sl@0: 			//CALL below window element function to move all elements above 'below'
sl@0: 			iElements[index]->MoveToAboveGivenElement(iScene, below);
sl@0: 	        orderChanged = ETrue;
sl@0: 			}
sl@0: 		}
sl@0: 	return orderChanged;
sl@0: 	}
sl@0: 
sl@0: /** Processes the specified windows placed elements, for when windows visibility is changed.
sl@0: If the placed elements are no longer visible, they are removed.
sl@0: 
sl@0: @param aWindow The window to call the function on.
sl@0: @return Positive if any elements have been removed, zero if not, or errorcode. 
sl@0: @see CWindowElement::SetVisibleRegion
sl@0: */
sl@0: TInt CWindowElementSet::SetVisibleRegion(CWsClientWindow& aWindow)
sl@0: 	{
sl@0: 	TInt index;
sl@0: 	TInt find = FindEntry(aWindow,index);
sl@0: 	WS_ASSERT_DEBUG(find>=KErrNone,EWsPanicNoWindowElement);
sl@0: 	TBool ret = iElements[index]->SetVisibleRegion(aWindow.VisibleRegion(), iScene);
sl@0: 
sl@0: 	if (!iElements[index]->iBackgroundElement.iElement && iElements[index]->iPlacedElements.Count() == 0)
sl@0: 		{
sl@0: 		DestroyWindowElementEntry(index);
sl@0: 		}
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: /** Updates the specified windows elements extent, either from a window movement or a change in window size
sl@0: 
sl@0: @param aWindow The window to call the function on.
sl@0: @param aOffset The movement of the window.  If NULL then the window has changed size.
sl@0: @see CWindowElement::UpdateElementExtent
sl@0: */
sl@0: void CWindowElementSet::UpdateElementExtent(const CWsClientWindow& aWindow, const TPoint* aOffset)
sl@0: 	{
sl@0: 	FindElement(aWindow)->UpdateElementExtent(aOffset);
sl@0: 	}
sl@0: 
sl@0: /** Method to fill in a TSurfaceConfiguration from a scene element.
sl@0: 
sl@0: @param aConfiguration Surface configuration to fill in.
sl@0: @param aElement Element to get information from.
sl@0: @return Once multiple versions of TSurfaceConfiguration are available, KErrNotSupported if configuration supplied is too small.
sl@0: */
sl@0: TInt CWindowElementSet::GetConfiguration(TSurfaceConfiguration& aConfiguration,MWsElement& aElement)
sl@0: 	{
sl@0: 	TSurfaceId tempSurfaceId = aElement.ConnectedSurface();
sl@0: 	aConfiguration.SetSurfaceId(tempSurfaceId);
sl@0: 	
sl@0: 	//Convert and copy orientation
sl@0: 	aConfiguration.SetOrientation(ElementToGcRotation(aElement.SourceRotation()));
sl@0: 	
sl@0: 	//Convert and copy flip
sl@0: 	TBool flip = aElement.SourceFlipping();
sl@0: 	aConfiguration.SetFlip(flip);
sl@0: 
sl@0: 	//Convert and copy viewport
sl@0: 	TRect tempViewport;
sl@0: 	aElement.GetSourceRectangle(tempViewport);
sl@0: 	aConfiguration.SetViewport(tempViewport);
sl@0: 	TRect tempExtent;
sl@0: 	aElement.GetDestinationRectangle(tempExtent);
sl@0: 	aConfiguration.SetExtent(tempExtent);
sl@0: 	return KErrNone;	//Could fail if there are multiple versions of TSurfaceConfiguration
sl@0: 	}
sl@0: 
sl@0: /** Returns the window element entry for the specified window.
sl@0: 
sl@0: @param aWindow The window to call the function on.
sl@0: */
sl@0: CWindowElement* CWindowElementSet::FindElement(const CWsClientWindow& aWindow) const
sl@0: 	{
sl@0: 	TInt index;
sl@0: 	TInt error = FindEntry(aWindow,index);
sl@0: 	if (error == KErrNone)
sl@0: 		return iElements[index];
sl@0: 	WS_ASSERT_DEBUG(EFalse,EWsPanicNoWindowElement);
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: /** Creates a set of window-element pairs for this scene.
sl@0: 
sl@0: @param aScene To allow access to the scene.
sl@0: @param aComposer To allow access to the composer.
sl@0: */
sl@0: CWindowElementSet::CWindowElementSet(MWsScene& aScene) :
sl@0: 	iScene(aScene)
sl@0: 	{}
sl@0: 
sl@0: /** Searches for the entry in iElements with the given window
sl@0: 
sl@0: @param aWindow The window to find the entry of / where it should be inserted.
sl@0: @param aIndex aIndex is set to entry found or the insertion point, respectively.
sl@0: @param aLinearSearch ETrue if a linear search of the window element set is required.
sl@0: @return KErrNone if found or KErrNotFound.
sl@0: */
sl@0: TInt CWindowElementSet::FindEntry(const CWsClientWindow& aWindow, TInt& aIndex, TBool aLinearSearch /*= EFalse*/) const
sl@0: 	{
sl@0: 	CWindowElement winelement(aWindow);
sl@0: 	
sl@0: 	// The array order makes use of the parent pointer, which gets reset during
sl@0: 	// window shutdown, so if it is clear fall back to a linear search.
sl@0: 	if (!aWindow.BaseParent() || aLinearSearch)
sl@0: 		{
sl@0: 		TIdentityRelation<CWindowElement> match(WindowMatch);
sl@0: 		
sl@0: 		aIndex = iElements.Find(&winelement, match);
sl@0: 		return (aIndex == KErrNotFound) ? KErrNotFound : KErrNone;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TLinearOrder<CWindowElement> order(WindowOrder);
sl@0: 		return iElements.FindInOrder(&winelement, aIndex, order);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** Used to find an entry in the set when order cannot be used. 
sl@0: 
sl@0: @param aFirst First windowelement to compare.
sl@0: @param aSecond Second windowelement to compare.
sl@0: @return ETrue if the entries are the same, and EFalse if they are not.
sl@0: */
sl@0: TBool CWindowElementSet::WindowMatch(const CWindowElement& aFirst, const CWindowElement& aSecond)
sl@0: 	{
sl@0: 	return (&aFirst.iWindow == &aSecond.iWindow);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Used to determine the order of entries in the set.
sl@0: 
sl@0: @param aFirst First windowelement to compare.
sl@0: @param aSecond Second windowelement to compare.
sl@0: @return zero if the entries are the same, a negative value if 
sl@0: aFirst is behind aSecond or a positive value if aFirst is in front of aSecond.
sl@0: */
sl@0: TInt CWindowElementSet::WindowOrder(const CWindowElement& aFirst, const CWindowElement& aSecond)
sl@0: 	{
sl@0: 	TInt result = 0;
sl@0: 
sl@0: 	if (&aFirst.iWindow != &aSecond.iWindow)
sl@0: 		{
sl@0: 		result = aFirst.iWindow.IsInfrontOf(&aSecond.iWindow) ? 1 : -1;
sl@0: 		}
sl@0: 
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Re-sends the extents for all the elements (in this window) to the scene  	
sl@0:  * 	This allows the renderstage to re-scale those element extents
sl@0:  * 
sl@0:  * 
sl@0:  **/
sl@0: void CWindowElement::ResubmitAllElementExtents()
sl@0: 	{
sl@0: 	if (MWsElement* element=iBackgroundElement.iElement)
sl@0: 		{
sl@0: 		TRect extent(TRect::EUninitialized);
sl@0: 		element->GetDestinationRectangle(extent);
sl@0: 		element->SetDestinationRectangle(extent);
sl@0: 		}
sl@0: 	TInt elementCount = iPlacedElements.Count();
sl@0: 	for (TInt index = 0; index < elementCount; index++)
sl@0: 		{
sl@0: 		if (MWsElement* element=iPlacedElements[index].iElement)
sl@0: 			{
sl@0: 			TRect extent(TRect::EUninitialized);
sl@0: 			element->GetDestinationRectangle(extent);
sl@0: 			element->SetDestinationRectangle(extent);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**	Re-sends the extents for all the elements (in all the windows) to the scene  	
sl@0:  * 	This allows the renderstage to re-scale those element extents
sl@0:  * 
sl@0:  * 
sl@0:  **/
sl@0: void CWindowElementSet::ResubmitAllElementExtents()
sl@0: 	{
sl@0: 	TInt elementCount = iElements.Count();
sl@0: 	for (TInt index = 0; index < elementCount; index++)
sl@0: 		{
sl@0: 		iElements[index]->ResubmitAllElementExtents();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Debug functions
sl@0: //
sl@0: 
sl@0: /** Returns background attributes for the specified window index.
sl@0: For use with debug client interface.
sl@0: 
sl@0: @param aWin Window index to get the surface attributes from.
sl@0: @return Background attributes for the specified window.  NULL if the window index is invalid.
sl@0: */
sl@0: const TBackgroundAttributes* CWindowElementSet::DebugBackgroundAt(TUint aWin)const
sl@0: 	{
sl@0: 	if (aWin>=Count())
sl@0: 		return NULL;
sl@0: 	return &iElements[aWin]->iBackgroundElement;
sl@0: 	}
sl@0: 
sl@0: /** Returns the client window for the specified window index.
sl@0: For use with debug client interface.
sl@0: 
sl@0: @param aWin Window index to get the client window from.
sl@0: @return Client window for the specified window.  NULL if the window index is invalid.
sl@0: */
sl@0: const CWsClientWindow* CWindowElementSet::DebugWindowAt(TUint aWin)const
sl@0: 	{
sl@0: 	if (aWin>=Count())
sl@0: 		return NULL;
sl@0: 	return &iElements[aWin]->iWindow;
sl@0: 	}
sl@0: 
sl@0: /** Returns how many placed surfaces are on the specified window
sl@0: For use with debug client interface.
sl@0: 
sl@0: @param aWin Window index to get the client window from.
sl@0: @return Amount of placed surfaces for the specified window index
sl@0: */
sl@0: TInt CWindowElementSet::DebugPlacedCountAt(TUint aWin)const
sl@0: 	{
sl@0: 	if (aWin>=Count())
sl@0: 		return -1;
sl@0: 	return iElements[aWin]->iPlacedElements.Count();
sl@0: 	}
sl@0: 
sl@0: /** Returns the placed attributes for the specified placed surface index in the
sl@0: specified window index.
sl@0: For use with debug client interface.
sl@0: 
sl@0: @param aWin Window index to get the client window from.
sl@0: @param aPlace Placed surface index to get the placed surface attributes
sl@0: @return Placed surface attributes.  NULL if either index was invalid.
sl@0: */
sl@0: const TPlacedAttributes* CWindowElementSet::DebugPlacedAt(TUint aWin,TUint aPlace)const
sl@0: 	{
sl@0: 	if (aWin>=Count())
sl@0: 		return NULL;
sl@0: 	if (aPlace>=iElements[aWin]->iPlacedElements.Count())
sl@0: 		return NULL;
sl@0: 	return &iElements[aWin]->iPlacedElements[aPlace];
sl@0: 	}
sl@0: 
sl@0: MWsElement* CWindowElementSet::GetElementFromWindow(const CWsClientWindow& aWindow) const
sl@0:     {
sl@0:     CWindowElement* windowElement = FindElement(aWindow);
sl@0:     if (windowElement)
sl@0:         return windowElement->Element();
sl@0:     else 
sl@0:         return NULL; 
sl@0:     }