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