/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 "T_DataWsScreenDevice.h"
#include "T_GraphicsUtil.h"

/*@{*/
_LIT(KDataClassname,							"CWsScreenDevice");

///	Fields
_LIT(KFldAlgStyle,								"alg_style");
_LIT(KFldBackLight,								"backlight");
_LIT(KFldBitmap,								"bitmap");
_LIT(KFldDefaultScreenNumber,					"defaultscreennumber");
_LIT(KFldExpected,								"expected");
_LIT(KFldExpectedCount,							"expectedcount");
_LIT(KFldFinish,								"finish");
_LIT(KFldFlags,									"flags");
_LIT(KFldFormatFieldNumber,						"%S%d");
_LIT(KFldFontUid,								"font_uid");
_LIT(KFldMode,									"mode");
_LIT(KFldPalette,								"palette");
_LIT(KFldPixel,									"pixel");
_LIT(KFldPixelSize,								"pixelsize");
_LIT(KFldRect,									"rect");
_LIT(KFldRect1,									"rect1");
_LIT(KFldRect2,									"rect2");
_LIT(KFldRotation,								"rotation");
_LIT(KFldStart,									"start");
_LIT(KFldTwips,									"twips");
_LIT(KFldTwipsSize,								"twipssize");
_LIT(KFldWindowGc,								"windowgc");
_LIT(KFldWs,									"ws");
_LIT(KFldFont,									"font");
_LIT(KFldContext,								"context");

///	Commands
_LIT(KCmdnew,									"new");
_LIT(KCmddisown,								"disown");
_LIT(KCmdDestructor,							"~CWsScreenDevice");
_LIT(KCmdDestructorGeneral,						"~");
_LIT(KCmdConstruct,								"Construct");
_LIT(KCmdCopyScreenToBitmap,					"CopyScreenToBitmap");
_LIT(KCmdCreateContext,							"CreateContext");
_LIT(KCmdCurrentScreenMode,						"CurrentScreenMode");
_LIT(KCmdGetCurrentScreenModeScale,				"GetCurrentScreenModeScale");
_LIT(KCmdGetCurrentScreenModeScaledOrigin,		"GetCurrentScreenModeScaledOrigin");
_LIT(KCmdGetDefaultScreenModeOrigin,			"GetDefaultScreenModeOrigin");
_LIT(KCmdGetDefaultScreenSizeAndRotation,		"GetDefaultScreenSizeAndRotation");
_LIT(KCmdGetFontById,							"GetFontById");
_LIT(KCmdGetRotationsList,						"GetRotationsList");
_LIT(KCmdGetScreenModeDisplayMode,				"GetScreenModeDisplayMode");
_LIT(KCmdGetScreenModeOrigin,					"GetScreenModeOrigin");
_LIT(KCmdGetScreenModeScale,					"GetScreenModeScale");
_LIT(KCmdGetScreenModeScaledOrigin,				"GetScreenModeScaledOrigin");
_LIT(KCmdGetScreenModeSizeAndRotation,			"GetScreenModeSizeAndRotation");
_LIT(KCmdGetScreenNumber,						"GetScreenNumber");
_LIT(KCmdGetScreenSizeModeList,					"GetScreenSizeModeList");
_LIT(KCmdNumScreenModes,						"NumScreenModes");
_LIT(KCmdRectCompare,							"RectCompare");
_LIT(KCmdPointerRect,							"PointerRect");
_LIT(KCmdScreenModeEnforcement,					"ScreenModeEnforcement");
_LIT(KCmdSetAppScreenMode,						"SetAppScreenMode");
_LIT(KCmdSetBackLight,							"SetBackLight");
_LIT(KCmdSetCustomPalette,						"SetCustomPalette");
_LIT(KCmdSetScreenSizeAndRotation,				"SetScreenSizeAndRotation");

_LIT(KCmdcheckPixels,							"checkPixels");
_LIT(KCmdcheckLineColor,						"checkLineColor");
_LIT(KCmdcheckRectColor,						"checkRectColor");

_LIT(KFormatFieldNumber,	"%S%d");

///	Logging
_LIT(KLogColor,									"Color Red=%d Green=%d Blue=%d Alpha=%d");
_LIT(KLogPoint,									"Point X=%d Y=%d");
_LIT(KLogError,									"Error=%d");
_LIT(KLogMissingParameter,						"Missing parameter '%S'");
_LIT(KLogNotExpectedValue,						"Not expected value");
/*@}*/

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CT_DataWsScreenDevice* CT_DataWsScreenDevice::NewL()
/**
 * Two phase constructor
 */
	{
	CT_DataWsScreenDevice*	ret=new (ELeave) CT_DataWsScreenDevice();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}

CT_DataWsScreenDevice::CT_DataWsScreenDevice()
/**
 * Protected constructor. First phase construction
 */
:	CT_DataBitmapDevice()
,	iWsScreenDevice(NULL)
	{
	}

void CT_DataWsScreenDevice::ConstructL()
/**
 * Second phase construction
 */
	{
	}

CT_DataWsScreenDevice::~CT_DataWsScreenDevice()
/**
 * Public destructor
 */
	{
	DestroyData();
	}

TAny* CT_DataWsScreenDevice::GetObject()
/**
 * Return a pointer to the object that the data wraps
 *
 * @return	pointer to the object that the data wraps
 */
	{
	return iWsScreenDevice;
	}

void CT_DataWsScreenDevice::SetObjectL(TAny* aAny)
/**
 * Set the object that the data wraps
 *
 * @param	aObject object that the wrapper is testing
 *
 */
	{
	DestroyData();
	iWsScreenDevice = static_cast<CWsScreenDevice*> (aAny);
	}

void CT_DataWsScreenDevice::DisownObjectL()
/**
 * The object will no longer be owned by this
 *
 * @leave	KErrNotSupported if the the function is not supported
 */
	{
	iWsScreenDevice = NULL;
	}

void CT_DataWsScreenDevice::DestroyData()
	{
	delete iWsScreenDevice;
	iWsScreenDevice=NULL;
	}

MWsClientClass* CT_DataWsScreenDevice::GetClientClass() const
	{
	return iWsScreenDevice;
	}

MGraphicsDeviceMap*	CT_DataWsScreenDevice::GetGraphicsDeviceMap() const
	{
	return iWsScreenDevice;
	}

CGraphicsDevice*	CT_DataWsScreenDevice::GetGraphicsDevice() const
	{
	return iWsScreenDevice;
	}

CBitmapDevice*	CT_DataWsScreenDevice::GetBitmapDevice() const
	{
	return iWsScreenDevice;
	}


/**
* Process a command read from the ini file
*
* @param aCommand			the command to process
* @param aSection			the entry in the ini file requiring the command to be processed
* @param aAsyncErrorIndex	index of command. used for async calls
*
* @return ETrue if the command is processed
*/
TBool CT_DataWsScreenDevice::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
	{
	TBool	ret = ETrue;

	if ( aCommand==KCmdDestructor || aCommand==KCmdDestructorGeneral )
		{
		DoCmdDestructor();
		}
	else if ( aCommand==KCmdnew || aCommand==KDataClassname )
		{
		DoCmdnewL(aSection);
		}
	else if ( aCommand==KCmddisown )
		{
		DisownObjectL();
		}	
	else if ( aCommand==KCmdConstruct )
		{
		DoCmdConstruct(aSection);
		}
	else if ( aCommand==KCmdCopyScreenToBitmap )
		{
		DoCmdCopyScreenToBitmapL(aSection);
		}
	else if ( aCommand==KCmdCreateContext )
		{
		DoCmdCreateContextL(aSection);
		}
	else if ( aCommand==KCmdCurrentScreenMode )
		{
		DoCmdCurrentScreenMode(aSection);
		}
	else if ( aCommand==KCmdGetCurrentScreenModeScale )
		{
		DoCmdGetCurrentScreenModeScale(aSection);
		}
	else if ( aCommand==KCmdGetCurrentScreenModeScaledOrigin )
		{
		DoCmdGetCurrentScreenModeScaledOrigin(aSection);
		}
	else if ( aCommand==KCmdGetDefaultScreenModeOrigin )
		{
		DoCmdGetDefaultScreenModeOrigin(aSection);
		}
	else if ( aCommand==KCmdGetDefaultScreenSizeAndRotation )
		{
		DoCmdGetDefaultScreenSizeAndRotation(aSection);
		}
	else if ( aCommand==KCmdGetFontById )
		{
		DoCmdGetFontByIdL(aSection);
		}
	else if ( aCommand==KCmdGetRotationsList )
		{
			DoCmdGetRotationsListL(aSection);
		}
	else if ( aCommand==KCmdGetScreenModeDisplayMode )
		{
		DoCmdGetScreenModeDisplayMode(aSection);
		}
	else if ( aCommand==KCmdGetScreenModeOrigin )
		{
		DoCmdGetScreenModeOrigin(aSection);
		}
	else if ( aCommand==KCmdGetScreenModeScale )
		{
		DoCmdGetScreenModeScale(aSection);
		}
	else if ( aCommand==KCmdGetScreenModeScaledOrigin )
		{
		DoCmdGetScreenModeScaledOrigin(aSection);
		}
	else if ( aCommand==KCmdGetScreenModeSizeAndRotation )
		{
		DoCmdGetScreenModeSizeAndRotation(aSection);
		}
	else if ( aCommand==KCmdGetScreenNumber )
		{
		DoCmdGetScreenNumber(aSection);
		}
	else if ( aCommand==KCmdGetScreenSizeModeList )
		{
		DoCmdGetScreenSizeModeListL(aSection);
		}
	else if ( aCommand==KCmdNumScreenModes )
		{
		DoCmdNumScreenModes(aSection);
		}
	else if ( aCommand==KCmdPointerRect )
		{
		DoCmdPointerRect(aSection);
		}
	else if ( aCommand==KCmdRectCompare )
		{
		DoCmdRectCompare(aSection);
		}
	else if ( aCommand==KCmdScreenModeEnforcement )
		{
		DoCmdScreenModeEnforcement(aSection);
		}
	else if ( aCommand==KCmdSetAppScreenMode )
		{
		DoCmdSetAppScreenMode(aSection);
		}
	else if ( aCommand==KCmdSetBackLight )
		{
		DoCmdSetBackLight(aSection);
		}
	else if ( aCommand==KCmdSetCustomPalette )
		{
		DoCmdSetCustomPaletteL(aSection);
		}
	else if ( aCommand==KCmdSetScreenSizeAndRotation )
		{
		DoCmdSetScreenSizeAndRotation(aSection);
		}
	else if ( aCommand==KCmdcheckPixels )
		{
		DoCmdcheckPixels(aSection);
		}
	else if ( aCommand==KCmdcheckLineColor )
		{
		DoCmdcheckLineColor(aSection);
		}
	else if ( aCommand==KCmdcheckRectColor )
		{
		DoCmdcheckRectColor(aSection);
		}
	else if ( CT_DataBitmapDevice::DoCommandL(aCommand, aSection, aAsyncErrorIndex) )
		{
		}
	else
		{
		ret=CT_DataWsClientClass::DoCommandL(*this, aCommand, aSection, aAsyncErrorIndex);
		}

	return ret;
	}

/**
Test Constructor
*/
void CT_DataWsScreenDevice::DoCmdnewL(const TDesC& aSection)
	{
	DestroyData();

	// Get test data for command input parameter(s)
	RWsSession*	ws=NULL;
	TPtrC		wsName;
	if ( GetStringFromConfig(aSection, KFldWs, wsName) )
		{
		ws = static_cast<RWsSession*>(GetDataObjectL(wsName));
		}

	TInt	err;
	if ( ws!= NULL )
		{
		// Execute command and log parameters
		INFO_PRINTF1(_L("execute new CWsScreenDevice(RWsSession)"));
		TRAP( err, iWsScreenDevice = new (ELeave) CWsScreenDevice(*ws) );
		}
	else
		{
		// Execute command and log parameters
		INFO_PRINTF1(_L("execute new CWsScreenDevice()"));
		TRAP(err, iWsScreenDevice = new (ELeave) CWsScreenDevice());
		}

	if ( err!=KErrNone )
		{
		ERR_PRINTF2(KLogError, err);
		SetError(err);
		}
	}

/**
Test Destructor
*/
void CT_DataWsScreenDevice::DoCmdDestructor()
	{
	INFO_PRINTF1(_L("execute ~CWsScreenDevice()"));
	DestroyData();
	}

/**
Test Construct()
*/
void CT_DataWsScreenDevice::DoCmdConstruct(const TDesC& aSection)
	{
	// Get test data for command input parameter(s)
	TInt	err=KErrNone;

	TInt	datDefaultScreenNumber;
	if ( GetIntFromConfig(aSection, KFldDefaultScreenNumber, datDefaultScreenNumber) )
		{
		// Execute command and log parameters
		INFO_PRINTF1(_L("execute Construct(TInt)"));
		err=iWsScreenDevice->Construct(datDefaultScreenNumber);
		}
	else
		{
		// Execute command and log parameters
		INFO_PRINTF1(_L("execute Construct()"));
		err=iWsScreenDevice->Construct();
		}

	// Check the command return code.
	if ( err!=KErrNone )
		{
		ERR_PRINTF2(KLogError, err);
		SetError(err);
		}
	}

/**
Test CopyScreenToBitmap()
*/
void CT_DataWsScreenDevice::DoCmdCopyScreenToBitmapL(const TDesC& aSection)
	{
	// Get test data for command input parameter(s)
	CFbsBitmap*	bitmap=NULL;
	TBool	hasBitmap=CT_GraphicsUtil::GetFbsBitmapL(*this, aSection, KFldBitmap, bitmap);
	if ( !hasBitmap )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldBitmap);
		SetBlockResult(EFail);
		}
	else
		{
		// Execute command and log parameters
		TInt	err=KErrNone;

		TRect	datRect;
		if ( GetRectFromConfig(aSection, KFldRect, datRect) )
			{
			INFO_PRINTF1(_L("execute CopyScreenToBitmap(CFbsBitmap, TRect)"));
			err=iWsScreenDevice->CopyScreenToBitmap(bitmap, datRect);
			}
		else
			{
			INFO_PRINTF1(_L("execute CopyScreenToBitmap(CFbsBitmap)"));
			err=iWsScreenDevice->CopyScreenToBitmap(bitmap);
			}

		// Check the command return code.
		if ( err!=KErrNone )
			{
			ERR_PRINTF2(KLogError, err);
			SetError(err);
			}
		}
	}

/**
Test CreateContext()
*/
void CT_DataWsScreenDevice::DoCmdCreateContextL(const TDesC& aSection)
	{
	// Get test data for command input parameter(s)
	TPtrC	datWindowGc;
	if ( !GetStringFromConfig(aSection, KFldWindowGc, datWindowGc) )
		{
		//CT_DataBitmapDevice::DoCommandL(aCommand, aSection, aAsyncErrorIndex);
		
		// get BitmapUtilData object from parameters
		if ( !GetStringFromConfig(aSection, KFldContext, datWindowGc) )
			{
			ERR_PRINTF2(KLogMissingParameter, &KFldContext());
			SetBlockResult(EFail);
			}
		else
			{
			CGraphicsContext*	context=NULL;
			INFO_PRINTF1(_L("execute CreateContext(CGraphicsContext*&)"));
			TInt	returnCode=GetGraphicsDevice()->CreateContext(context);
			// Check the command return code.
			if ( returnCode!=KErrNone )
				{
				ERR_PRINTF2(KLogError, returnCode);
				SetError(returnCode);
				}
			else
				{
				SetDataObjectL(datWindowGc, context);
				}
			}
		}
	else
		{
		// Execute command and log parameters
		CWindowGc*	windowGc;

		INFO_PRINTF1(_L("execute CreateContext(CWindowGc)"));
		TInt	returnCode = iWsScreenDevice->CreateContext(windowGc);

		// Check the command return code.
		if ( returnCode!=KErrNone )
			{
			ERR_PRINTF2(KLogError, returnCode);
			SetError(returnCode);
			}
		else
			{
			SetDataObjectL(datWindowGc, windowGc);
			}
		}
	}

/**
Test CurrentScreenMode()
*/
void CT_DataWsScreenDevice::DoCmdCurrentScreenMode(const TDesC& aSection)
	{
	TInt	actual=iWsScreenDevice->CurrentScreenMode();
	INFO_PRINTF2(_L("CurrentScreenMode()=%d"), actual);

	TInt	expected;
	if ( !GetIntFromConfig(aSection, KFldExpected, expected) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
		SetBlockResult(EFail);
		}
	else
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test GetCurrentScreenModeScale()
*/
void CT_DataWsScreenDevice::DoCmdGetCurrentScreenModeScale(const TDesC& aSection)
	{
	TSize	actual=iWsScreenDevice->GetCurrentScreenModeScale();
	INFO_PRINTF3(_L("GetCurrentScreenModeScale(TInt) height=%d width=%d"), actual.iHeight, actual.iWidth);

	TSize	expected;
	if ( !GetSizeFromConfig(aSection, KFldExpected, expected) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
		SetBlockResult(EFail);
		}
	else
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test GetCurrentScreenModeScaledOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetCurrentScreenModeScaledOrigin(const TDesC& aSection)
	{
	TPoint	actual=iWsScreenDevice->GetCurrentScreenModeScaledOrigin();
	INFO_PRINTF3(_L("GetCurrentScreenModeScaledOrigin() x=%d y=%d"), actual.iX, actual.iY);

	TPoint	expected;
	if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
		SetBlockResult(EFail);
		}
	else
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test GetDefaultScreenModeOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetDefaultScreenModeOrigin(const TDesC& aSection)
	{
	TPoint	actual=iWsScreenDevice->GetDefaultScreenModeOrigin();
	INFO_PRINTF3(_L("GetDefaultScreenModeOrigin() x=%d y=%d"), actual.iX, actual.iY);

	TPoint	expected;
	if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
		SetBlockResult(EFail);
		}
	else
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test GetDefaultScreenSizeAndRotation()
*/
void CT_DataWsScreenDevice::DoCmdGetDefaultScreenSizeAndRotation(const TDesC& aSection)
	{
	CFbsBitGc::TGraphicsOrientation	rotation;
	TBool							checkRotation=CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, KFldRotation, rotation);

	TSize	pixelSize;
	TBool	checkPixelSize=GetSizeFromConfig(aSection, KFldPixelSize, pixelSize);

	TBool	twips=EFalse;
	GetBoolFromConfig(aSection, KFldTwips, twips);
	if ( twips )
		{
		TPixelsTwipsAndRotation	param;
		iWsScreenDevice->GetDefaultScreenSizeAndRotation(param);
		INFO_PRINTF2(_L("GetDefaultScreenSizeAndRotation(TPixelsTwipsAndRotation) Rotation=%d"), param.iRotation);
		INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);
		INFO_PRINTF3(_L("Twips height=%d width=%d"), param.iTwipsSize.iHeight, param.iTwipsSize.iWidth);

		if ( checkRotation )
			{
			if ( rotation!=param.iRotation )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}

		if ( checkPixelSize )
			{
			if ( pixelSize!=param.iPixelSize )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}

		TSize	twipsSize;
		if ( GetSizeFromConfig(aSection, KFldTwipsSize, twipsSize) )
			{
			if ( twipsSize!=param.iTwipsSize )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	else
		{
		TPixelsAndRotation	param;
		iWsScreenDevice->GetDefaultScreenSizeAndRotation(param);
		INFO_PRINTF2(_L("GetDefaultScreenSizeAndRotation(TPixelsAndRotation) Rotation=%d"), param.iRotation);
		INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);

		if ( checkRotation )
			{
			if ( rotation!=param.iRotation )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}

		if ( checkPixelSize )
			{
			if ( pixelSize!=param.iPixelSize )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test GetFontById()
*/
void CT_DataWsScreenDevice::DoCmdGetFontByIdL(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("Call GetFontById()"));
	TBool	dataOk=ETrue;

	// get font uid from parameters
	TInt	fontUid;
	if(!GetIntFromConfig(aSection, KFldFontUid(), fontUid))
		{
		dataOk=EFalse;
		ERR_PRINTF2(_L("No %S"), &KFldFontUid());
		SetBlockResult(EFail);
		}
	// get TAlgStyle from parameters
	TAlgStyle*	algStyle=NULL;
	CT_GraphicsUtil::GetAlgStyleL(*this, aSection, KFldAlgStyle(), algStyle);
	if ( algStyle==NULL )
		{
		dataOk=EFalse;
		ERR_PRINTF2(_L("No %S"), &KFldAlgStyle());
		SetBlockResult(EFail);
		}
	// get font wrapper name
	TPtrC datFbsFont;
	if( !GetStringFromConfig(aSection, KFldFont, datFbsFont) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldFont());
		SetBlockResult(EFail);
		}
	// call GetFontById()
	else
		{
		if ( dataOk )
			{
			CFont* fbsFont=NULL;
			INFO_PRINTF1(_L("execute GetFontById(CFont *&aFont, TUid aUid, const TAlgStyle &aAlgStyle)"));
			TInt err = iWsScreenDevice->GetFontById(fbsFont, TUid::Uid(fontUid), *algStyle);
			
			if ( err!=KErrNone )
				{
				ERR_PRINTF2(KLogError, err);
				SetError(err);
				}
			else
				{
				SetDataObjectL(datFbsFont, fbsFont);
				}
			}
		}
	}

/**
Test GetRotationsList()
*/
void CT_DataWsScreenDevice::DoCmdGetRotationsListL(const TDesC& aSection)
	{
	CArrayFixFlat<TInt>*	rotations=new(ELeave) CArrayFixFlat<TInt>(1);
	CleanupStack::PushL(rotations);

	TInt	mode=0;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldMode);
		SetBlockResult(EFail);
		}
	else
		{
		TInt	err=iWsScreenDevice->GetRotationsList(mode, rotations);
		if ( err!=KErrNone )
			{
			ERR_PRINTF2(KLogError, err);
			SetError(err);
			}
		else
			{
			INFO_PRINTF2(_L("GetRotationsList count=%d"), rotations->Count());
			TInt	expectedCount;
			if ( GetIntFromConfig(aSection, KFldExpectedCount, expectedCount) )
				{
				if ( expectedCount!=rotations->Count() )
					{
					ERR_PRINTF1(KLogNotExpectedValue);
					SetBlockResult(EFail);
					}
				else
					{
					INFO_PRINTF1(_L("Check elements in the rotations list"));
					TBuf<KMaxTestExecuteCommandLength>	tempStore;

					TBool	ok=ETrue;
					for ( TInt index = 0; (index < expectedCount) && (ok); )
						{
						tempStore.Format(KFormatFieldNumber, &KFldRotation, ++index);
						
						CFbsBitGc::TGraphicsOrientation	rotation;
						ok = CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, tempStore, rotation);
						if ( !ok )
							{
							ERR_PRINTF2(KLogMissingParameter, &tempStore);
							SetBlockResult(EFail);
							}
						else
							{
							if( rotation != (*rotations)[index-1])
								{
								ERR_PRINTF1(KLogNotExpectedValue);
								SetBlockResult(EFail);
								ok = EFalse;
								}
							}
						}
					}
				}
			}
		}

	CleanupStack::PopAndDestroy();
	}

/**
Test GetScreenModeDisplayMode()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeDisplayMode(const TDesC& aSection)
	{
	TInt	mode=0;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldMode);
		SetBlockResult(EFail);
		}
	else
		{
		TDisplayMode	actual=iWsScreenDevice->GetScreenModeDisplayMode(mode);
		INFO_PRINTF2(_L("GetScreenModeDisplayMode(TInt)=%d"), actual);

		TDisplayMode	expected;
		if ( !CT_GraphicsUtil::ReadDisplayMode(*this, aSection, KFldExpected, expected) )
			{
			ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
			SetBlockResult(EFail);
			}
		else
			{
			if ( actual!=expected )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test GetScreenModeOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeOrigin(const TDesC& aSection)
	{
	TInt	mode=0;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldMode);
		SetBlockResult(EFail);
		}
	else
		{
		TPoint	actual=iWsScreenDevice->GetScreenModeOrigin(mode);
		INFO_PRINTF3(_L("GetScreenModeOrigin(TInt) x=%d y=%d"), actual.iX, actual.iY);

		TPoint	expected;
		if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
			{
			ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
			SetBlockResult(EFail);
			}
		else
			{
			if ( actual!=expected )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test GetScreenModeScale()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeScale(const TDesC& aSection)
	{
	TInt	mode=0;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldMode);
		SetBlockResult(EFail);
		}
	else
		{
		TSize	actual=iWsScreenDevice->GetScreenModeScale(mode);
		INFO_PRINTF3(_L("GetScreenModeScale(TInt) height=%d width=%d"), actual.iHeight, actual.iWidth);

		TSize	expected;
		if ( !GetSizeFromConfig(aSection, KFldExpected, expected) )
			{
			ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
			SetBlockResult(EFail);
			}
		else
			{
			if ( actual!=expected )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test GetScreenModeScaledOrigin()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeScaledOrigin(const TDesC& aSection)
	{
	TInt	mode=0;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldMode);
		SetBlockResult(EFail);
		}
	else
		{
		TPoint	actual=iWsScreenDevice->GetScreenModeScaledOrigin(mode);
		INFO_PRINTF3(_L("GetScreenModeScaledOrigin(TInt) x=%d y=%d"), actual.iX, actual.iY);

		TPoint	expected;
		if ( !GetPointFromConfig(aSection, KFldExpected, expected) )
			{
			ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
			SetBlockResult(EFail);
			}
		else
			{
			if ( actual!=expected )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test GetScreenModeSizeAndRotation()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenModeSizeAndRotation(const TDesC& aSection)
	{
	TInt	mode=0;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldMode);
		SetBlockResult(EFail);
		}

	CFbsBitGc::TGraphicsOrientation	rotation;
	TBool							checkRotation=CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, KFldRotation, rotation);

	TSize	pixelSize;
	TBool	checkPixelSize=GetSizeFromConfig(aSection, KFldPixelSize, pixelSize);

	TBool	twips=EFalse;
	GetBoolFromConfig(aSection, KFldTwips, twips);
	if ( twips )
		{
		TPixelsTwipsAndRotation	param;
		iWsScreenDevice->GetScreenModeSizeAndRotation(mode, param);
		INFO_PRINTF2(_L("GetScreenModeSizeAndRotation(TInt, TPixelsTwipsAndRotation) Rotation=%d"), param.iRotation);
		INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);
		INFO_PRINTF3(_L("Twips height=%d width=%d"), param.iTwipsSize.iHeight, param.iTwipsSize.iWidth);

		if ( checkRotation )
			{
			if ( rotation!=param.iRotation )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}

		if ( checkPixelSize )
			{
			if ( pixelSize!=param.iPixelSize )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}

		TSize	twipsSize;
		if ( GetSizeFromConfig(aSection, KFldTwipsSize, twipsSize) )
			{
			if ( twipsSize!=param.iTwipsSize )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	else
		{
		TPixelsAndRotation	param;
		iWsScreenDevice->GetScreenModeSizeAndRotation(mode, param);
		INFO_PRINTF2(_L("GetScreenModeSizeAndRotation(TInt, TPixelsAndRotation) Rotation=%d"), param.iRotation);
		INFO_PRINTF3(_L("Pixel height=%d width=%d"), param.iPixelSize.iHeight, param.iPixelSize.iWidth);

		if ( checkRotation )
			{
			if ( rotation!=param.iRotation )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}

		if ( checkPixelSize )
			{
			if ( pixelSize!=param.iPixelSize )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test GetScreenNumber()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenNumber(const TDesC& aSection)
	{
	// Execute command and log parameters
	TInt	actual=iWsScreenDevice->GetScreenNumber();
	INFO_PRINTF2(_L("execute GetScreenNumber()=%d"), actual);

	// Diaplay command return value, check if it matches the expected value
	TInt	expected;
	if ( !GetIntFromConfig(aSection, KFldExpected, expected) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
		SetBlockResult(EFail);
		}
	else
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test GetScreenSizeModeList()
*/
void CT_DataWsScreenDevice::DoCmdGetScreenSizeModeListL(const TDesC& aSection)
	{
	RArray<TInt>	screenModes;
	CleanupClosePushL(screenModes);

	TInt	number = iWsScreenDevice->GetScreenSizeModeList(&screenModes);

	if (number < 0)
		{
		ERR_PRINTF2(KLogError, number);
		SetError(number);
		}
	else
		{
		INFO_PRINTF2(_L("GetScreenSizeModeList count=%d"), screenModes.Count());
		TInt	expectedCount;
		if ( GetIntFromConfig(aSection, KFldExpectedCount, expectedCount) )
			{
			if ( expectedCount!=screenModes.Count() || expectedCount != number)
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF1(_L("Check elements in the modes list"));
				TBuf<KMaxTestExecuteCommandLength>	tempStore;

				TBool	ok=ETrue;
				for ( TInt index = 0; (index < number) && (ok); )
					{
					tempStore.Format(KFormatFieldNumber, &KFldMode, ++index);
					
					TInt expectedMode = 0;
					ok=GetIntFromConfig(aSection, tempStore, expectedMode);
					if ( !ok )
						{
						ERR_PRINTF2(KLogMissingParameter, &tempStore);
						SetBlockResult(EFail);
						}
					else
						{
						if( expectedMode != screenModes[index-1])
							{
							ERR_PRINTF1(KLogNotExpectedValue);
							SetBlockResult(EFail);
							ok = EFalse;
							}
						}
					}
				}
			}
		}

	CleanupStack::PopAndDestroy(&screenModes);
	}

/**
Test NumScreenModes()
*/
void CT_DataWsScreenDevice::DoCmdNumScreenModes(const TDesC& aSection)
	{
	TInt	actual=iWsScreenDevice->NumScreenModes();
	INFO_PRINTF2(_L("NumScreenModes()=%d"), actual);

	TInt	expected;
	if ( GetIntFromConfig(aSection, KFldExpected, expected) )
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test PointerRect()
*/
void CT_DataWsScreenDevice::DoCmdPointerRect(const TDesC& aSection)
	{
	TRect	actual=iWsScreenDevice->PointerRect();
	LogRect(_L("PointerRect()"), actual);

	TRect	expected;
	if ( GetRectFromConfig(aSection, KFldExpected, expected) )
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test RectCompare()
*/
void CT_DataWsScreenDevice::DoCmdRectCompare(const TDesC& aSection)
	{
	TBool	dataOk=ETrue;

	// Get test data for command input parameter(s)
	TRect	datRect1;
	if ( !GetRectFromConfig(aSection, KFldRect1, datRect1) )
		{
		dataOk=EFalse;
		ERR_PRINTF2(KLogMissingParameter, &KFldRect1);
		SetBlockResult(EFail);
		}

	TRect	datRect2;
	if ( !GetRectFromConfig(aSection, KFldRect2, datRect2) )
		{
		dataOk=EFalse;
		ERR_PRINTF2(KLogMissingParameter, &KFldRect2);
		SetBlockResult(EFail);
		}

	if ( dataOk )
		{
		TBool	actual=EFalse;

		// Execute command and log parameters
		TUint	datFlags;
		if ( CT_GraphicsUtil::ReadSpriteInCompare(*this, aSection, KFldFlags, datFlags) )
			{
			actual=iWsScreenDevice->RectCompare(datRect1, datRect2, datFlags);
			INFO_PRINTF2(_L("execute RectCompare(TRect, TRect, TUint)=%d"), actual);
			}
		else
			{
			actual=iWsScreenDevice->RectCompare(datRect1, datRect2);
			INFO_PRINTF2(_L("execute RectCompare(TRect, TRect)=%d"), actual);
			}

		// Diaplay command return value, check if it matches the expected value
		TBool	expected;
		if ( !GetBoolFromConfig(aSection, KFldExpected, expected) )
			{
			ERR_PRINTF2(KLogMissingParameter, &KFldExpected);
			SetBlockResult(EFail);
			}
		else
			{
			if ( actual!=expected )
				{
				ERR_PRINTF1(KLogNotExpectedValue);
				SetBlockResult(EFail);
				}
			}
		}
	}

/**
Test ScreenModeEnforcement()
*/
void CT_DataWsScreenDevice::DoCmdScreenModeEnforcement(const TDesC& aSection)
	{
	TScreenModeEnforcement	actual=iWsScreenDevice->ScreenModeEnforcement();
	INFO_PRINTF2(_L("execute ScreenModeEnforcement()=%d"), actual);

	TScreenModeEnforcement	expected;
	if ( CT_GraphicsUtil::ReadScreenModeEnforcement(*this, aSection, KFldExpected, expected) )
		{
		if ( actual!=expected )
			{
			ERR_PRINTF1(KLogNotExpectedValue);
			SetBlockResult(EFail);
			}
		}
	}

/**
Test SetAppScreenMode()
*/
void CT_DataWsScreenDevice::DoCmdSetAppScreenMode(const TDesC& aSection)
	{
	TInt	mode;
	if ( !GetIntFromConfig(aSection, KFldMode, mode) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldRect2);
		SetBlockResult(EFail);
		}
	else
		{
		INFO_PRINTF1(_L("SetAppScreenMode()"));
		iWsScreenDevice->SetAppScreenMode(mode);
		}
	}

/**
Test SetBackLight()
*/
void CT_DataWsScreenDevice::DoCmdSetBackLight(const TDesC& aSection)
	{
	TBool	backLight;
	if ( !GetBoolFromConfig(aSection, KFldBackLight, backLight) )
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldBackLight);
		SetBlockResult(EFail);
		}
	else
		{
		TInt	err=iWsScreenDevice->SetBackLight(backLight);
		if ( err!=KErrNone )
			{
			ERR_PRINTF2(KLogError, err);
			SetError(err);
			}
		}
	}

/**
Test SetCustomPalette()
*/
void CT_DataWsScreenDevice::DoCmdSetCustomPaletteL(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("Calls CWsScreenDevice::SetCustomPalette() by previously created palette"));

	// get CPalette object passed as a parameter
	CPalette*	palette = NULL;
	
	if(!CT_GraphicsUtil::GetPaletteL(*this, aSection, KFldPalette(), palette))
		{
		ERR_PRINTF2(KLogMissingParameter, &KFldPalette);
		SetBlockResult(EFail);
		}
	else
		{
		// call SetPalette()
		TInt err = iWsScreenDevice->SetCustomPalette(palette);
		if(err != KErrNone)
			{
			ERR_PRINTF2(KLogError, err);
			SetError(err);
			}
		}	
	}

/**
Test SetScreenSizeAndRotation()
*/
void CT_DataWsScreenDevice::DoCmdSetScreenSizeAndRotation(const TDesC& aSection)
	{
	TBool	dataOk=ETrue;

	CFbsBitGc::TGraphicsOrientation	rotation;
	if ( !CT_GraphicsUtil::ReadGraphicsOrientation(*this, aSection, KFldRotation, rotation) )
		{
		dataOk=EFalse;
		ERR_PRINTF2(KLogMissingParameter, &KFldRotation);
		SetBlockResult(EFail);
		}

	TSize	pixelSize;
	if ( !GetSizeFromConfig(aSection, KFldPixelSize, pixelSize) )
		{
		dataOk=EFalse;
		ERR_PRINTF2(KLogMissingParameter, &KFldPixelSize);
		SetBlockResult(EFail);
		}

	if ( dataOk )
		{
		TSize	twipsSize;
		if ( GetSizeFromConfig(aSection, KFldTwipsSize, twipsSize) )
			{
			TPixelsTwipsAndRotation	param;
			param.iPixelSize=pixelSize;
			param.iRotation=rotation;
			param.iTwipsSize=twipsSize;
			INFO_PRINTF1(_L("execute SetScreenSizeAndRotation(const TPixelsTwipsAndRotation&)"));
			iWsScreenDevice->SetScreenSizeAndRotation(param);
			}
		else
			{
			TPixelsAndRotation	param;
			param.iPixelSize=pixelSize;
			param.iRotation=rotation;
			INFO_PRINTF1(_L("execute SetScreenSizeAndRotation(const TPixelsAndRotation&)"));
			iWsScreenDevice->SetScreenSizeAndRotation(param);
			}
		}
	}

/**
* The source codes hereafter are NOT simple wrapper functions of CWsScreenDevice class,
* but use combinations of CWsScreenDevice (and other) class functions to check if what
* take from the CWsScreenDevice matches with the expected value specified in TEF testdata.
*
*/

/**
* DoCmdcheckPixels: to check the color of specified pixels on the screen device, and compare
* with the expected color specidied in the TEF testdata.
*		pixel<n>: specify the position of the screen device to check
*		expected<n>: specify the expected color to be compared with
*
*/
void CT_DataWsScreenDevice::DoCmdcheckPixels(const TDesC& aSection)
	{
	TBuf<KMaxTestExecuteCommandLength>	tempStore;

	TBool	moreData=ETrue;
	for ( TInt index=1; moreData; ++index )
		{
		// get the pixel position on the screen to check/verify
		tempStore.Format(KFldFormatFieldNumber, &KFldPixel, index);
		TPoint	point;
		if ( !GetPointFromConfig(aSection, tempStore, point) )
			{
			moreData=EFalse;
			}
		else
			{
			TRgb	actual;
			iWsScreenDevice->GetPixel(actual, point);

			tempStore.Format(KFldFormatFieldNumber, &KFldExpected, index);
			TRgb	expected;
			if ( GetRgbFromConfig(aSection, tempStore, expected) )
				{
				if ( actual!=expected )
					{
					ERR_PRINTF5(KLogColor, actual.Red(), actual.Green(), actual.Blue(), actual.Alpha());
					ERR_PRINTF5(KLogColor, expected.Red(), expected.Green(), expected.Blue(), expected.Alpha());
					SetBlockResult(EFail);
					}
				}
			}
		}
	}

/**
* DoCmdcheckLineColor: to check the color of specified lines on the screen device, and compare
* with the expected color specidied in the TEF testdata.
*		start<n>: specify the starting position of the line on the screen device to check
*		finish<n>: specify the finish position of the line on the screen device to check
*		expected<n>: specify the expected color to be compared with
* Note: the straight line (from start to the finish points) is constructed by TLinearDDA
*
*/
void CT_DataWsScreenDevice::DoCmdcheckLineColor(const TDesC& aSection)
	{
	TBuf<KMaxTestExecuteCommandLength>	tempStore;

	CPalette*	palette=NULL;
	iWsScreenDevice->GetPalette(palette);

	TBool	moreData=ETrue;
	for ( TInt index=1; moreData; ++index )
		{
		// get the the start and finish points of the line to check/verify
		tempStore.Format(KFldFormatFieldNumber, &KFldStart, index);
		TPoint	startPoint;
		if ( !GetPointFromConfig(aSection, tempStore, startPoint) )
			{
			moreData=EFalse;
			}

		tempStore.Format(KFldFormatFieldNumber, &KFldFinish, index);
		TPoint	endPoint;
		if ( !GetPointFromConfig(aSection, tempStore, endPoint) )
			{
			moreData=EFalse;
			}

		if ( moreData )
			{
			// get the expected color from testdata
			tempStore.Format(KFldFormatFieldNumber, &KFldExpected, index);
			TRgb	expected;
			if ( !GetRgbFromConfig(aSection, tempStore, expected) )
				{
				ERR_PRINTF2(KLogMissingParameter, &tempStore);
				SetBlockResult(EFail);
				}
			else
				{
				if ( palette!=NULL )
					{
					expected=palette->NearestEntry(expected);
					}

				TLinearDDA	lineDDA;
				lineDDA.Construct(startPoint, endPoint, TLinearDDA::ECenter);

				// for each pixels on the line (from start to finish points), check if its color matches expected
				TPoint	point;
				while ( !lineDDA.SingleStep(point) )
					{
					TRgb	actual;
					iWsScreenDevice->GetPixel(actual, point);

					if ( actual!=expected )
						{
						ERR_PRINTF5(KLogColor, actual.Red(), actual.Green(), actual.Blue(), actual.Alpha());
						ERR_PRINTF5(KLogColor, expected.Red(), expected.Green(), expected.Blue(), expected.Alpha());
						ERR_PRINTF3(KLogPoint, point.iX, point.iY);
						SetBlockResult(EFail);
						}
					}
				}
			}
		}

	delete palette;
	}

/**
* DoCmdcheckRectColor: to check the color of specified rectangle on the screen device, and
* compare with the expected color specidied in the TEF testdata.
*		rect<n>: specify the rectangle area on the screen device to check
*		expected<n>: specify the expected color to be compared with
*
*/
void CT_DataWsScreenDevice::DoCmdcheckRectColor(const TDesC& aSection)
	{
	TBuf<KMaxTestExecuteCommandLength>	tempStore;

	CPalette*	palette=NULL;
	iWsScreenDevice->GetPalette(palette);

	TBool	moreData=ETrue;
	for ( TInt index=1; moreData; ++index )
		{
		// get the the rectangle to check/verify
		tempStore.Format(KFldFormatFieldNumber, &KFldRect, index);
		TRect	rect;
		if ( !GetRectFromConfig(aSection, tempStore, rect) )
			{
			moreData=EFalse;
			}
		else
			{
			// get the expected color from testdata
			tempStore.Format(KFldFormatFieldNumber, &KFldExpected, index);
			TRgb	expected;
			if ( !GetRgbFromConfig(aSection, tempStore, expected) )
				{
				ERR_PRINTF2(KLogMissingParameter, &tempStore);
				SetBlockResult(EFail);
				}
			else
				{
				if ( palette!=NULL )
					{
					expected=palette->NearestEntry(expected);
					}

				TPoint	point;
				for ( point.iX=rect.iTl.iX; point.iX<rect.iBr.iX; ++point.iX)
					{
					for ( point.iY=rect.iTl.iY; point.iY<rect.iBr.iY; ++point.iY )
						{
						TRgb	actual;
						iWsScreenDevice->GetPixel(actual, point);

						if ( actual!=expected )
							{
							ERR_PRINTF5(KLogColor, actual.Red(), actual.Green(), actual.Blue(), actual.Alpha());
							ERR_PRINTF5(KLogColor, expected.Red(), expected.Green(), expected.Blue(), expected.Alpha());
							ERR_PRINTF3(KLogPoint, point.iX, point.iY);
							SetBlockResult(EFail);
							}
						}
					}
				}
			}
		}

	delete palette;
	}
