// Copyright (c) 2008-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 <graphics/wsgraphicdrawerinterface.h>

#include <e32cmn.h>

#include <u32hal.h>

#include "displaypolicy.h"

#include "panic.h"

CDisplayPolicy::CDisplayPolicy():iLastAppMode(KErrNotReady),iSmallestAppMode(KErrNotReady)

	{

	// No implementation required

	}

CDisplayPolicy::~CDisplayPolicy()

	{

	}

CDisplayPolicy* CDisplayPolicy::NewLC(MWsGraphicDrawerEnvironment* aEnv,MWsScreen* aScreen,TInt aScreenNumber)

	{

	CDisplayPolicy* self = new (ELeave)CDisplayPolicy();

	CleanupStack::PushL(self);

	self->ConstructL(aEnv,aScreen,aScreenNumber);

	return self;

	}

CDisplayPolicy* CDisplayPolicy::NewL(MWsGraphicDrawerEnvironment* aEnv,MWsScreen* aScreen,TInt aScreenNumber)

	{

	CDisplayPolicy* self=CDisplayPolicy::NewLC(aEnv,aScreen,aScreenNumber);

	CleanupStack::Pop(); // self;

	return self;

	}

void CDisplayPolicy::ConstructL(MWsGraphicDrawerEnvironment* aEnv,MWsScreen* aScreen,TInt aScreenNumber)

	{

	iScreenIniFile=aEnv->ObjectInterface<MWsIniFile>();

	if (iScreenIniFile)

		{

		_LIT(KScale,"DP_SCALING");

		//_LIT(KScaleNone,"none");

		_LIT(KScaleInteger,"integer");

		_LIT(KScaleIsotropic,"isotropic");

		_LIT(KScaleAnisotropic,"anisotropic");

		_LIT(KScreenDisconnected,"SIMULATE_STARTUP_DISCONNECTED");

		iUiScaling = ENone;

		TPtrC scalingModeName;

		if (iScreenIniFile->FindVar(aScreenNumber,KScale,scalingModeName))

			{

			if (scalingModeName == KScaleInteger)

				{

				iUiScaling = EInteger;

				}

			else if (scalingModeName == KScaleIsotropic)

				{

				iUiScaling = EIsotropic;

				}

			else if (scalingModeName == KScaleAnisotropic)

				{

				iUiScaling = EAnisotropic;

				}

			}

		if (iScreenIniFile->FindVar(aScreenNumber,KScreenDisconnected))

			{

			//Simulate starting up with this screen disconnected

			TDisplayConnectState displayState = EDisconnect;

			TInt err = UserSvr::HalFunction(EHalGroupDisplay | (aScreenNumber<<16), EDisplayHalSetDisplayState, &displayState, NULL);

			STD_ASSERT_ALWAYS(err == KErrNone, EPluginPanicHalSetDisplayState);

			}

		}

	iScreen=aScreen;

	}

void CDisplayPolicy::NewAppModesAvailable()

	{

	//This notification allows the list to be first populated after Wserv has finished initialising itself

	//It also allows for the WServ debug method CWsScreenDevice::SetCurrentScreenModeAttributes

	GetAppModeList();	//get the app size mode list again because some settings have changed

	}

void CDisplayPolicy::GetModeInfoL(const MWsScreenConfigList& aList,TInt aIndex,TPoint& aOffset,TSize& aSize,TAppMode& aMode)const

	{

	aOffset=aList.OriginL(aIndex);

	aSize=aList.ScreenModeSizeInPixelsL(aIndex);

	aMode.iPixels=TRect(aOffset,aSize);

	aMode.iTwips=aList.ScreenModeSizeInTwipsL(aIndex);

	aMode.iOrientations=aList.AvailableOrientationsL(aIndex);

	}

void CDisplayPolicy::GetAppModeList()

	{

	if (iScreen)

		{

		iSmallestAppMode = KErrNotFound;

		iSmallestAppSize = TSize(10000,10000);

		MWsScreenConfigList* screenConfigList=iScreen->ObjectInterface<MWsScreenConfigList>();

		iNumNormalAppModes=0;

		TSize largestAppMode;

		if (screenConfigList)

			{

			RArray<TInt> goodModeIndices;

			if (screenConfigList->GetScreenSizeModeList(goodModeIndices)!=KErrNone)

				{

				//If reserve fails then list is empty later - we can't change display res from app mode request, just use current and try to centre app area

				iAppModes.Reserve(goodModeIndices.Count());

				//iScreenIniFile: First time in, it should be a good pointer from which to extract the basicFlags

				//Repeat calls only update the values inside app mode list entries, and the ini file should not be read again. 

				//Specify some basic flags by reading ini file for this screen number?

				TInt basicFlags=0;

				//Our demo policy uses the app mode list to generate a list of virtual resolutions.

				for (TInt modeIndex=0;modeIndex<goodModeIndices.Count();modeIndex++)

					{

					TInt modeNum=goodModeIndices[modeIndex];

					TAppMode mode;

					TSize size;

					TPoint offset;

					mode.iFlags=basicFlags;

					TRAP_IGNORE(mode.iFlags|=screenConfigList->ModeFlagsL(modeNum)); //we know modeNum is valid-wont leave

					//any further flags to read from ini file for this appmode on this screen number?

					//Probably should ignore modes flagged with Hal or Dynamic

					// at the moment we want all modes in the list! 

					TInt err = KErrNone;

					TRAP(err,GetModeInfoL(*screenConfigList,goodModeIndices[modeIndex],offset,size,mode));

					if (err == KErrNone)	//should never fail - we never ask for info for a bad mode

						{

						if (1<<CFbsBitGc::EGraphicsOrientationRotated90&mode.iOrientations 

								|| 1<<CFbsBitGc::EGraphicsOrientationRotated270&mode.iOrientations)

							{	//flip rect and twips

							mode.iPixels = TRect(mode.iPixels.iTl.iY,mode.iPixels.iTl.iX,mode.iPixels.iBr.iY,mode.iPixels.iBr.iX);

							mode.iTwips = TSize(mode.iTwips.iHeight,mode.iTwips.iWidth);

							}

						mode.iModeIndex=modeNum;

						if (modeIndex==iAppModes.Count())

							{

							iAppModes.Append(mode);	//can't fail if reserve succeeded

							}

						else if (modeIndex<iAppModes.Count())

							{

							iAppModes[modeIndex]=mode;	//update - wserv implementation means order never changes.

							}

						//This is to help policy code decide what the minimum buffer size should be 

						//Switching between modes requiring smaller screen area than this will not invoke memory reallocation, so will not fail.

						//Perhaps an implementation would also consider the current lowest physical resolution as a guide.

						//The HAL mode may be significantly larger than the app modes require

						if (!(mode.iFlags&(MWsScreenConfigList::EDynamic|MWsScreenConfigList::EHalDefault)))

							{

							TSize borderedSize=offset.AsSize()+size;

							if (borderedSize.iWidth>largestAppMode.iWidth)

								largestAppMode.iWidth=borderedSize.iWidth;

							if (borderedSize.iHeight>largestAppMode.iHeight)

								largestAppMode.iHeight=borderedSize.iHeight;

							iNumNormalAppModes++;

							}

						//find the smallest appmode. this will be used when display is disconnected

						if (!(mode.iFlags&(MWsScreenConfigList::EDynamic|MWsScreenConfigList::EHalDefault)))

							{

							TSize borderedSize=offset.AsSize()+size;

							if(borderedSize.iWidth*borderedSize.iHeight < iSmallestAppSize.iWidth*iSmallestAppSize.iHeight)

								{

								iSmallestAppSize = borderedSize;

								iSmallestAppMode = modeNum;

								}

							}

						}

					}

				}

			goodModeIndices.Close();

			}

		iMinUiBufferSize=largestAppMode;

		}

	iScreenIniFile=NULL;

	}

TInt CDisplayPolicy::MapCompositionToUi(const TRect& aSource, TRect& aTarget, TBool aIsReverseMapping) const

	{

	// only scaling is involved in mapping from composition to UI

	// no offset change

	TFraction widthFraction;

	TFraction heightFraction;

	if (	iCompositionSizePixels.iWidth<=0

		||	iUiSizePixels.iWidth<=0

		||	iCompositionSizePixels.iHeight<=0

		||	iUiSizePixels.iHeight<=0)

		{

		aTarget=aSource;

		return KErrNotReady;

		}

	if(aIsReverseMapping)

		{

		//Ui to composition

		widthFraction.iNumer = iCompositionSizePixels.iWidth;

		widthFraction.iDenom = iUiSizePixels.iWidth;

		heightFraction.iNumer = iCompositionSizePixels.iHeight;

		heightFraction.iDenom = iUiSizePixels.iHeight;

		}

	else

		{

		//composition to ui

		widthFraction.iNumer = iUiSizePixels.iWidth;

		widthFraction.iDenom = iCompositionSizePixels.iWidth;

		heightFraction.iNumer = iUiSizePixels.iHeight;

		heightFraction.iDenom = iCompositionSizePixels.iHeight;

		}

	aTarget.iTl.iX = widthFraction * aSource.iTl.iX;

	aTarget.iBr.iX = widthFraction * aSource.iBr.iX;

	aTarget.iTl.iY = heightFraction * aSource.iTl.iY;

	aTarget.iBr.iY = heightFraction * aSource.iBr.iY;

	return KErrNone;

	}

void CDisplayPolicy::MapUiToApplication(const TRect& aSource, TRect& aTarget, TBool aIsReverseMapping) const

	{

	// only offset is involved in mapping from Ui to App

	// no scaling

	TPoint offset = iAppSizePixels.iTl;;

	if(aIsReverseMapping)

		{

		//App to ui

		aTarget.iTl = aSource.iTl + offset;

		aTarget.iBr = aSource.iBr + offset;

		}

	else

		{

		//Ui to App

		aTarget.iTl = aSource.iTl - offset;

		aTarget.iBr = aSource.iBr - offset;

		}

	}

TInt CDisplayPolicy::MapUiToDSA(const TRect& aSource, TRect& aTarget, TBool aIsReverseMapping) const 

	{

	//only offset is involved in mapping from Ui to DSA

	//no scaling

	TPoint dsaOffset(0, 0);

	MWsScreenConfig *screenConfig = iScreen->ObjectInterface<MWsScreenConfig>();

	if(screenConfig)

		{

		dsaOffset = screenConfig->Origin();

		}

	TRect rectInApp;

	if(aIsReverseMapping)

		{

		//DSA to ui

		//DSA to App first

		rectInApp.iTl = aSource.iTl - dsaOffset;

		rectInApp.iBr = aSource.iBr - dsaOffset;

		//then app to UI

		MapUiToApplication(rectInApp, aTarget, ETrue);

		}

	else

		{

		//Ui to DSA

		//Ui to App first

		MapUiToApplication(aSource, rectInApp, EFalse);

		//then app to DSA

		aTarget.iTl = rectInApp.iTl + dsaOffset;

		aTarget.iBr = rectInApp.iBr + dsaOffset;

		}

	return KErrNone;

	}

TInt CDisplayPolicy::MapCoordinates(TCoordinateSpace aSourceSpace, const TRect& aSource, TCoordinateSpace aTargetSpace, TRect& aTarget) const

	{

	TInt returnCode=KErrNone;

	switch (aSourceSpace)

		{

		case ECompositionSpace:

			{

			if(aTargetSpace == ECompositionSpace)

				{

				aTarget = aSource;

				}

			else if(aTargetSpace == EFullScreenSpace)

				{

				//composition to Ui

				returnCode=MapCompositionToUi(aSource, aTarget, EFalse);

				}

			else if(aTargetSpace == EApplicationSpace)

				{

				//composition to App

				TRect rectInUi;

				returnCode=MapCompositionToUi(aSource, rectInUi, EFalse);

				MapUiToApplication(rectInUi, aTarget, EFalse);

				}

			else if(aTargetSpace == EDirectScreenAccessSpace)

				{

				//composition to DSA

				TRect rectInUi;

				returnCode=MapCompositionToUi(aSource, rectInUi, EFalse);

				if(returnCode < 0)

					break;

				returnCode=MapUiToDSA(rectInUi, aTarget, EFalse);

				}

			else

				{

				return KErrNotSupported;

				}

			}

			break;

		case EFullScreenSpace:

			{

			if(aTargetSpace == ECompositionSpace)

				{

				//Ui to composition

				returnCode=MapCompositionToUi(aSource, aTarget, ETrue);

				}

			else if(aTargetSpace == EFullScreenSpace)

				{

				aTarget = aSource;

				}

			else if(aTargetSpace == EApplicationSpace)

				{

				//Ui to app

				MapUiToApplication(aSource, aTarget, EFalse);

				}

			else if(aTargetSpace == EDirectScreenAccessSpace)

				{

				//Ui to DSA

				returnCode = MapUiToDSA(aSource, aTarget, EFalse);

				}

			else

				{

				return KErrNotSupported;

				}

			}

			break;

		case EApplicationSpace:

			{

			if(aTargetSpace == ECompositionSpace)

				{

				//App to composition

				TRect rectInUi;

				MapUiToApplication(aSource, rectInUi, ETrue);

				returnCode=MapCompositionToUi(rectInUi, aTarget, ETrue);

				}

			else if(aTargetSpace == EFullScreenSpace)

				{

				//App to Ui

				MapUiToApplication(aSource, aTarget, ETrue);

				}

			else if(aTargetSpace == EApplicationSpace)

				{

				aTarget = aSource;

				}

			else if(aTargetSpace == EDirectScreenAccessSpace)

				{

				//App to DSA

				TRect rectInUi;

				MapUiToApplication(aSource, rectInUi, ETrue);

				returnCode = MapUiToDSA(rectInUi, aTarget, EFalse);

				}

			else

				{

				return KErrNotSupported;

				}

			}

			break;

		case EDirectScreenAccessSpace:

			{

			if(aTargetSpace == ECompositionSpace)

				{

				//DSA to composition

				TRect rectInUi;

				returnCode = MapUiToDSA(aSource, rectInUi, ETrue);

				if(returnCode < KErrNone)

					break;

				returnCode = MapCompositionToUi(rectInUi, aTarget, ETrue);

				}

			else if(aTargetSpace == EFullScreenSpace)

				{

				//DSA to Ui

				returnCode = MapUiToDSA(aSource, aTarget, ETrue);

				}

			else if(aTargetSpace == EApplicationSpace)

				{

				//DSA to app

				TRect rectInUi;

				returnCode = MapUiToDSA(aSource, rectInUi, ETrue);

				MapUiToApplication(rectInUi, aTarget, EFalse);

				}

			else if(aTargetSpace == EDirectScreenAccessSpace)

				{

				aTarget = aSource;

				}

			else

				{

				return KErrNotSupported;

				}

			break;

			}

		default:

			returnCode= KErrNotSupported;

		}

	return returnCode;

	}

CDisplayPolicy::TFraction::TFraction():iNumer(0),iDenom(1)

	{}

TInt CDisplayPolicy::TFraction::operator*(TInt aInt) const

	{

	if (iDenom == 0 || iNumer == 0 || aInt == 0)

		{

		return 0;

		}

	TInt aNumer = iNumer<<1;

	TInt aDenom = iDenom;

	TInt returnValue = (aNumer*aInt)/aDenom;

	returnValue ++;

	return returnValue>>1;

	}

void	CDisplayPolicy::CalculateMinBufferSize(RArray<MDisplayControlBase::TResolution>& aResolutions, TInt aConnectionStatus)

	{

	iConnectionStatus = aConnectionStatus;

	//preq2102: aResolutions is likely to be changed (in future)

	if(iUiScaling == ENone)

		{

		//this function is currently only used with no scaling

		//should not be called when display is disconnected

		//with scaling iMinUiBufferSize is calculated in CDisplayPolicy::GetAppModeList()

		TSize largestPhysicalRes = iMinUiBufferSize;		

		for(TInt i = 0;i < aResolutions.Count(); i++)

			{

			if(aResolutions[i].iPixelSize.iWidth > largestPhysicalRes.iWidth)

				{

				largestPhysicalRes.iWidth = aResolutions[i].iPixelSize.iWidth;

				}

			if(aResolutions[i].iPixelSize.iHeight > largestPhysicalRes.iHeight)

				{

				largestPhysicalRes.iHeight = aResolutions[i].iPixelSize.iHeight;

				}

			}

		iMinUiBufferSize = largestPhysicalRes;

		}

	}

void	CDisplayPolicy::AdjustStageBufferSize(const TSize& /*aOldSize*/,TSize& aNewSize)

	{

	if (iMinUiBufferSize.iWidth==0)

		{

		//just in case, should never happen

		iMinUiBufferSize=TSize(1,1);	

		}

	if ((aNewSize.iWidth == 0 || aNewSize.iHeight == 0

			|| iConnectionStatus <= 0) && iUiScaling != ENone 

			&& iSmallestAppMode >= 0) // if detached or turned off (iUiScaling != ENone) and smallestAppMode is found

		{

		aNewSize = iSmallestAppSize;

		return;

		}

	if (aNewSize.iWidth < iMinUiBufferSize.iWidth)

		{

		aNewSize.iWidth = iMinUiBufferSize.iWidth;

		}

	if (aNewSize.iHeight < iMinUiBufferSize.iHeight)

		{

		aNewSize.iHeight = iMinUiBufferSize.iHeight;

		}

	}

void CDisplayPolicy::AddVirtualResolutionCount(TInt& aDisplayCount) const 

	{

	if (iUiScaling != ENone && aDisplayCount>0)

		{

		aDisplayCount += iNumNormalAppModes;

		}

	} 

TInt CDisplayPolicy::AddVirtualResolutions(RArray<MDisplayControlBase::TResolution>& aResolutions) const

	{

	if (aResolutions.Count()==0 || iUiScaling == ENone)

		{

		return KErrNone;

		}

	if (aResolutions.Count()==1 && aResolutions[0].iPixelSize==TSize(0,0))

		{

		return KErrNone;

		}

	TInt appModeCount = iAppModes.Count();

	if (appModeCount == 0)

		{

		return KErrNone;

		}

	TInt resolutionCount = aResolutions.Count();

	TInt error = aResolutions.Reserve(iNumNormalAppModes + resolutionCount);

	if (error < KErrNone)

		{

		aResolutions.Reset();

		return error;	//could fail to reserve if out of memory 

		}

	for (TInt appMode = 0; appMode < appModeCount; appMode++)

		{

		if (!(iAppModes[appMode].iFlags&(MWsScreenConfigList::EDynamic|MWsScreenConfigList::EHalDefault)))

			{

			MDisplayControlBase::TResolution virtualResolution = AppModeToResolution(aResolutions,appMode);

			aResolutions.Append(virtualResolution);

			}

		}

	return KErrNone;