// Copyright (c) 2007-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 "registeredsurfacemap.h"

#include "panics.h"

#include <graphics/wsscene.h>

#include <w32std.h>

/**

Destructor for the surface map, will unregister every surface in every client.

*/

CRegisteredSurfaceMap::~CRegisteredSurfaceMap()

	{

	TInt tempCount = iSessionSurfaces.Count();

	for (TInt ii = 0; ii < tempCount; ii++)

		{

		iSessionSurfaces[ii].RemoveAll(iScene);

		}

	iSessionSurfaces.Close();

	}

/**

Constructor for the surface map.

*/

CRegisteredSurfaceMap::CRegisteredSurfaceMap(MWsScene& aScene):iScene(aScene)

	{}

/**

Basic compare function, looking at the address of each session.

@param aLeft Left session for comparison.

@param aRight Right session for comparison.

@return Negative if left is smaller than right, positive if left is greater than right,

zero if they are the same.

*/

TInt CRegisteredSurfaceMap::CompareDeviceSurfaces (const TSessionSurfaces& aLeft, const TSessionSurfaces& aRight)

	{

	return (TInt)&aLeft.Session()-(TInt)&aRight.Session();

	}

/**

Function to register a surface on a client.  Will go through a process to add the surface to a list

for the client to keep track of which surfaces are registered for which clients.

@param aClient The client for which to register the surface.

@param aSurfaceId The surface to register on the client.

@return KErrNone on success or a system-wide error code.

@see CWsClient::RegisterSurface

*/

TInt CRegisteredSurfaceMap::Add(const CWsClient& aClient, const TSurfaceId& aSurfaceId)

	{

	TInt err;

	TInt tempPos;

	TSessionSurfaces tempDeviceSurface(aClient);

	//find client

	err = iSessionSurfaces.FindInOrder(tempDeviceSurface, tempPos, TLinearOrder<TSessionSurfaces>(CompareDeviceSurfaces));

	//if the client is found

	if (err == KErrNone)

		{

		err = iSessionSurfaces[tempPos].AddSurfaceId(aSurfaceId, iScene);

		}

	else

		{

		if (err == KErrNotFound)

			{

			err = iSessionSurfaces.Insert(tempDeviceSurface, tempPos);

			if (err == KErrNone)

				{

				err = iSessionSurfaces[tempPos].AddSurfaceId(aSurfaceId, iScene);

				if ((err != KErrNone) && (err != KErrInUse))	//it didnt manage to register the surface id

					{

					iSessionSurfaces.Remove(tempPos);

					}

				}

			}

		}

	return err;

	}

/**

Function to unregister a specific surface on a specific client.  Goes through a process to check

that the surface is registered for the client before remove it from the list and unregistering it.

@param aClient The client for which to unregister the surface.

@param aSurfaceId The surface to unregister on the client.

@return KErrNone on success or a system-wide error code.

@see CWsClient::UnregisterSurface

*/

TInt CRegisteredSurfaceMap::Remove(CWsClient& aClient, const TSurfaceId& aSurfaceId)

	{

	TInt err;

	TInt tempPos;

	TSessionSurfaces tempDeviceSurface(aClient);

	//find client

	err = iSessionSurfaces.FindInOrder(tempDeviceSurface, tempPos, TLinearOrder<TSessionSurfaces>(CompareDeviceSurfaces));

	TInt surfaceAmountLeftOrError;

	//if found

	if (err == KErrNone)

		{

		surfaceAmountLeftOrError = iSessionSurfaces[tempPos].RemoveSurfaceId(aSurfaceId, iScene);

		if (surfaceAmountLeftOrError == 0)	//there are no more surfaces registered for the client

			{

			iSessionSurfaces.Remove(tempPos);

			}

		if (surfaceAmountLeftOrError < 0)	//if an error was returned

			{

			err = surfaceAmountLeftOrError;

			}

		}

	return err;

	}

/**

Function that will unregister all surfaces for a specific client.

@param aClient The client for which to unregister all clients.

@return KErrNone on success or a system-wide error code.

@see CWsTop::ClearSurfaceMap

@see CWsClient::~CWsClient()

*/

TInt CRegisteredSurfaceMap::RemoveAll(CWsClient& aClient)

	{

	TInt err;

	TInt tempPos;

	TSessionSurfaces tempDeviceSurface(aClient);

	//find client

	err = iSessionSurfaces.FindInOrder(tempDeviceSurface, tempPos, TLinearOrder<TSessionSurfaces>(CompareDeviceSurfaces));

	//if found

	if (err == KErrNone)

		{

		err = iSessionSurfaces[tempPos].RemoveAll(iScene);

		}

	if (err == KErrNone || err == KErrInUse)

		{

		iSessionSurfaces.Remove(tempPos);

		}

	return err;

	}

TSessionSurfaces::TSessionSurfaces(const CWsClient& aSession):iSession(aSession)

	{}

TInt TSessionSurfaces::CompareIds(const TSurfaceId& aLeft, const TSurfaceId& aRight)

	{

	//Compare each internal id of the surface

	TUint32 ll;

	TUint32 rr;

	TInt32 tempResult;

	ll = aLeft.iInternal[0];

	rr = aRight.iInternal[0];

	tempResult = ll-rr;

	if (tempResult == 0)

		{

		ll = aLeft.iInternal[1];

		rr = aRight.iInternal[1];

		tempResult = ll-rr;

		if (tempResult == 0)

			{

			ll = aLeft.iInternal[2];

			rr = aRight.iInternal[2];

			tempResult = ll-rr;

			if (tempResult == 0)

				{

				ll = aLeft.iInternal[3];

				rr = aRight.iInternal[3];

				tempResult = ll-rr;

				}

			}

		}

	if (tempResult != 0)	//if they are different ids

		{

		if (ll < rr)

			{

			return -1;

			}

		else

			{

			return 1;

			}

		}

	return 0;

	}

TInt TSessionSurfaces::AddSurfaceId(const TSurfaceId& aSurfaceId, MWsScene& aScene)

	{

	TInt err;

	TInt tempPos;

	//find surface id

	err = iSurfaces.FindInOrder(aSurfaceId, tempPos, TLinearOrder<TSurfaceId>(CompareIds));

	if (err == KErrNotFound)

		{

		err = iSurfaces.Insert(aSurfaceId, tempPos);

		if (err == KErrNone)	//successfully added surface, can now register

			{

			err = aScene.RegisterSurface(aSurfaceId);

			}

		}

	else

		{

		if (err == KErrNone)

			{

			//shouldnt be registered more than once

			err = KErrInUse;

			}

		}

	return err;

	}

TInt TSessionSurfaces::RemoveSurfaceId(const TSurfaceId& aSurfaceId, MWsScene& aScene)

	{

	TInt surfaceAmountLeftOrError;

	TInt tempPos;

	//find surface id

	surfaceAmountLeftOrError = iSurfaces.FindInOrder(aSurfaceId, tempPos, 

			TLinearOrder<TSurfaceId>(CompareIds));

	if (surfaceAmountLeftOrError!=KErrNone)

		surfaceAmountLeftOrError = iSurfaces.FindInOrder(aSurfaceId, tempPos, 

				TLinearOrder<TSurfaceId>(CompareIds));

	//if found

	if (surfaceAmountLeftOrError == KErrNone)

		{

		surfaceAmountLeftOrError = aScene.UnregisterSurface(aSurfaceId);

		if ((surfaceAmountLeftOrError == KErrNone) || (surfaceAmountLeftOrError == KErrInUse))

			{

			iSurfaces.Remove(tempPos);

			surfaceAmountLeftOrError = iSurfaces.Count();

			}

		else

			{

			WS_ASSERT_DEBUG(EFalse,EWsPanicSurfaceMapError);	//Unexpected error

			}

		}

	return surfaceAmountLeftOrError;

	}

TInt TSessionSurfaces::RemoveAll(MWsScene& aScene)

	{

    TInt err = KErrNone;

    TInt returnValue = KErrNone;

    TInt tempSize = iSurfaces.Count();

    for (TInt ii = 0; ii < tempSize; ii++)

        {

        err = aScene.UnregisterSurface(iSurfaces[ii]);

        WS_ASSERT_ALWAYS((err == KErrNone) || (err == KErrInUse), EWsPanicSurfaceMapError);

        if (err != KErrNone && returnValue == KErrNone)

            {   //return first error code

            returnValue = err;

            }

        }

    iSurfaces.Close();

    return returnValue;

	}