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

//

/**

 @file

 @test

 @internalComponent

*/

#include <e32const.h>	//KNullUidValue

#include <pixelformats.h>

#include "t_pseudoappsurfacedwindow.h"

#include "t_testsurfacerasterizer.h"

#include "t_pseudoapputils.h"

#include "t_pseudoappscreen.h" //KScreenWindow

#include "t_pseudoappcfbsbitmapanim.h"

#include "t_pseudoappvganimation.h"

#include "t_pseudoappopenglanimation.h"

#include "t_pseudoappperformanceanim.h"

CTestSurfacedWindow* CTestSurfacedWindow::NewL(TInt aScreenNo, TInt aWindowNumber, TDisplayMode aMode, TInt aFrameDuration, const TSize& aScreenSize, TGceTestResults* aGceTestResults,

							const TDesC& aConfigFileName, CTPseudoAppShared& aPseudoAppShared)

	{

	RDebug::Print(_L("Creating CTestSurfacedWindow class\n"));

    CTestSurfacedWindow* self = new (ELeave) CTestSurfacedWindow(aScreenNo, aWindowNumber, aPseudoAppShared);

    CleanupStack::PushL(self);

    self->ConstructL(aScreenNo, aWindowNumber, aMode, aFrameDuration, aScreenSize, aGceTestResults, aConfigFileName);

    CleanupStack::Pop(); // self;

    return self;

	}

void CTestSurfacedWindow::ConstructL(TInt aScreenNo, TInt aWindowNumber, TDisplayMode aMode, TInt aFrameDuration, const TSize& aScreenSize, TGceTestResults* aGceTestResults,

							const TDesC& aConfigFileName)

	{

	RDebug::Print(_L("Constructing CTestSurfacedWindow for screen %d\n"), aScreenNo);

	//Create CIniData class for reading in values form ini files

	iUtils = CIniData::NewL(aConfigFileName);

	TSize surfaceSize;

	TInt surfacePresent = 0;

	TPixelFormat pixelFormat  = EFormatRgb;

	RDebug::Print(_L("Import configuration for ui window class and create it\n"));

	ImportWindowConfigL(aScreenNo, aWindowNumber, aMode, aFrameDuration, aScreenSize, aGceTestResults);

	RDebug::Print(_L("Import configuration for test surface class and create it\n"));

	ImportSurfaceConfigL(aScreenNo, aWindowNumber, aScreenSize, surfaceSize, surfacePresent, pixelFormat);

	RDebug::Print(_L("Surface height = %d Surface Width = %d\n"),surfaceSize.iHeight, surfaceSize.iWidth);

	RDebug::Print(_L("Import configuration for test animation class and create it\n"));

	ImportAnimConfigL(aScreenNo, aWindowNumber, aMode, surfaceSize, pixelFormat);

	if(surfacePresent)

		{

		RDebug::Print(_L("Create Surface Rasterizer\n"));

		iSurfaceRasterizer = CTestSurfaceRasterizer::NewL(iSurfaceId, iSurfaceScreenNumber, &iSurfaceManager);

		if(iSurfaceRasterizer == 0)

			{

			RDebug::Print(_L("Fatal error creating Surface Rasterizer, aborting\n"));

			User::Exit(0);

			}

		}

	iGceTestResults = aGceTestResults;

	}

CTestSurfacedWindow::CTestSurfacedWindow(TInt aScreenNo, TInt aWindowNumber, CTPseudoAppShared& aPseudoAppShared)

:iScreenNo(aScreenNo), iWindowNumber(aWindowNumber), iPseudoAppShared(aPseudoAppShared)

{

}

void CTestSurfacedWindow::UpdateL(SurfaceDetails& aSurfDetails)

	{

	//Test to see if the surfaced window has an animation associated with it

	if(iTestAnimation)

		   {

		   iTestAnimation->DrawL(iSurfaceRasterizer, aSurfDetails);

		   }

	//Draw the window last to avoid appearance of "black" surface

	iTestWindow->DrawL();

	}

CTestSurfacedWindow::~CTestSurfacedWindow()

	{

	delete iUtils;

	if(iSizeArray)

		{

		TInt noElements = iSizeArray->Count();

		iSizeArray->Delete(0, noElements);

		delete iSizeArray;

		iSizeArray = 0;

		}

	if(iPositionArray)

		{

		TInt noElements = iPositionArray->Count();

		iPositionArray->Delete(0, noElements);

		delete iPositionArray;

		iPositionArray = 0;

		}

	if(iLoadsarects)

		{

		TInt noElements = iLoadsarects->Count();

		iLoadsarects->Delete(0, noElements);

		delete iLoadsarects;

		iLoadsarects = 0;

		}

	if(iLoadsaParameters)

		{

		TInt noElements = iLoadsaParameters->Count();

		iLoadsaParameters->Delete(0, noElements);

		delete iLoadsaParameters;

		iLoadsaParameters = 0;

		}

	delete iSurfaceRasterizer;

	delete iTestWindow;

	delete iTestAnimation;

	DestroySurface();

	DestroySurfaceManager();

	}

void CTestSurfacedWindow::RotateL(TInt aScreenNo, TInt aWindowNumber, const TSize& aScreenSize, TInt aFrameNumber)

	{

	if(iTestAnimation)

		{

		//Destroy the current surface and create a new surface with the new screen dimensions

		TSize surfaceSize;

		TInt surfacePresent = 0;

		TPixelFormat pixelFormat  = EFormatRgb;

		delete iSurfaceRasterizer;

		delete iTestAnimation;

		DestroySurface();

		ImportSurfaceConfigL(aScreenNo, aWindowNumber, aScreenSize, surfaceSize, surfacePresent, pixelFormat);

		RDebug::Print(_L("Surface height = %d Surface Width = %d\n"),surfaceSize.iHeight, surfaceSize.iWidth);

		RDebug::Print(_L("Import configuration for test animation class and create it\n"));

		ImportAnimConfigL(0, 1, EColor16MA, surfaceSize, pixelFormat);

		if(surfacePresent)

			{

			RDebug::Print(_L("Create Surface Rasterizer\n"));

			iSurfaceRasterizer = CTestSurfaceRasterizer::NewL(iSurfaceId, iSurfaceScreenNumber, &iSurfaceManager);

			if(iSurfaceRasterizer == 0)

				{

				RDebug::Print(_L("Fatal error creating Surface Rasterizer, aborting\n"));

				User::Exit(0);

				}

			}

		if(iTestAnimation->RotationSupported())

			{

			//Continue animation from the last unrotated frame number

			iTestAnimation->SetFrameNumber(aFrameNumber);

			}

		}

	iTestWindow->Rotate(aScreenSize);

	}

TBool CTestSurfacedWindow::RotationSupported()

	{

	if(iPseudoAppShared.RotationSupported(iScreenNo, iWindowNumber, iSurfaceId))

		{

		if(iTestAnimation)

			{

			return iTestAnimation->RotationSupported();

			}

		else

			{

			//If no test animation is present, rotation is possible

			return ETrue;

			}

		}

	else

		{

		return EFalse;

		}

	}

void CTestSurfacedWindow::ImportWindowConfigL(TInt aScreenNo, TInt aWindowNo, TDisplayMode aMode, TInt aFrameDuration, const TSize& aScreenSize, TGceTestResults* aGceTestResults)

	{

	TBuf<KMaxUiBitmapNameLength>	tempStore;

	tempStore.Format(KScreenWindowNumber, aScreenNo, aWindowNo);

	TSize windowSize;

	TInt windowType;

	TInt windowChangeGeometry;

	TInt windowChangeBehavior;

	tempStore.Format(KScreenWindowNumber, aScreenNo, aWindowNo);

	READ_INI3A(tempStore,  type,  ui_window, ecom_window, empty_window,

	           windowType, EUiWindow, EEcomWindow, EEmptyWindow, iUtils);

	//viewfinder and empty windows are both catered for by the CTestEmptyWindow class

	switch(windowType)

		{

		case EEcomWindow:

			{

			TPtrC multiBitmapEcomFile;

			TInt multiBitmapEcomFileSize;

			READ_INI1A(tempStore, multi_bitmap_ecom_file, multiBitmapEcomFile, iUtils);

			READ_INI1A(tempStore, multi_bitmap_ecom_file_size, multiBitmapEcomFileSize, iUtils);

			READ_INI5A(tempStore, window_change_geometry, none, size, position, position_and_size,

			           position_and_size_with_opacity, windowChangeGeometry, ENoChanges, EWindowSize,

			           EWindowPosition, EWindowPositionAndSize, EWindowPositionAndSizeWithOpacity, iUtils);

			READ_INI3A(tempStore, window_change_behavior, none, incremental, cyclic, windowChangeBehavior,

			           ENoChange, EIncremental, ECyclic, iUtils);

			iSizeArray = ImportWindowSizeChangeParamsL(tempStore);

			iPositionArray = ImportWindowPositionChangeParamsL(tempStore);

			BuildDimensionArrayL(aScreenSize, aFrameDuration, windowChangeGeometry, windowChangeBehavior);

	 		iTestWindow = CTestEcomWindow::NewL(aScreenNo, aMode, multiBitmapEcomFile, multiBitmapEcomFileSize, aGceTestResults, iLoadsaParameters);

			break;

			}

		case EEmptyWindow:

	 		{

	 		iTestWindow = CTestEmptyWindow::NewL(aScreenNo, aMode, aScreenSize);

	 		break;

	 		}

	 	case EUiWindow:

	 		{

			TPtrC multiBitmapUiFile;

			TInt multiBitmapUiFileSize;

			TInt multiBitmapUiFileTransparency;

			READ_INI1A(tempStore, multi_bitmap_ui_file, multiBitmapUiFile, iUtils);

			READ_INI1A(tempStore, multi_bitmap_ui_file_size, multiBitmapUiFileSize, iUtils);

			READ_INI2A(tempStore, multi_bitmap_ui_file_transparency, True,  False,

	                   multiBitmapUiFileTransparency, ETrue, EFalse, iUtils);

			READ_INI5A(tempStore, window_change_geometry, none, size, position, position_and_size,

			           position_and_size_with_opacity, windowChangeGeometry, ENoChanges, EWindowSize,

			           EWindowPosition, EWindowPositionAndSize, EWindowPositionAndSizeWithOpacity, iUtils);

			READ_INI3A(tempStore, window_change_behavior, none, incremental, cyclic, windowChangeBehavior,

			           ENoChange, EIncremental, ECyclic, iUtils);

			iSizeArray = ImportWindowSizeChangeParamsL(tempStore);

			iPositionArray = ImportWindowPositionChangeParamsL(tempStore);

			BuildDimensionArrayL(aScreenSize, aFrameDuration, windowChangeGeometry, windowChangeBehavior);

			iLoadsarects = ImportWindowBitmapParamsL(tempStore, multiBitmapUiFileSize, aScreenSize);

			iTestWindow = CTestUiWindow::NewL(aScreenNo, aMode, multiBitmapUiFile, multiBitmapUiFileSize, iLoadsarects,

											  aFrameDuration,

											  multiBitmapUiFileTransparency,

											  aGceTestResults, iLoadsaParameters);

			break;

	 		}

	 	default:

	 		{

			break;	//Cannot reach default, Lint warning removal only

			}

		}

	}

void CTestSurfacedWindow::ImportSurfaceConfigL(TInt aScreenNo, TInt aWindowNo, const TSize& aScreenSize, TSize& aSurfaceSize, TInt& aSurfacePresent, TPixelFormat& aPixelFormat)

	{

	TBuf<KMaxUiBitmapNameLength>	tempStore;

	tempStore.Format(KScreenSurface, aScreenNo, aWindowNo);

	TInt shareScreenNumber;

	TInt shareWindowNumber;

	// Check to see if window is sharing surface with another window

	TBool shareSurface = TImportScreenConfig::GetShareSurfaceInfoL(aScreenNo, aWindowNo, shareScreenNumber, shareWindowNumber, iUtils);

	// Check to see if this window already has a SurfaceId allocated for it s

	iSurfaceId = iPseudoAppShared.GetSurfaceId(aScreenNo, aWindowNo);

	if(shareSurface && iSurfaceId.IsNull())

		{

		// SurfaceId not found, but check to see if the sharing window already has a SurfaceId allocated for it

		iSurfaceId = iPseudoAppShared.GetSurfaceId(shareScreenNumber, shareWindowNumber);

		}

	if(!iSurfaceId.IsNull())

		{

		// SurfaceId found - open surface to use with this window

		//Create a surface manager session

		CreateSurfaceManager();

		iSurfaceManager.OpenSurface(iSurfaceId);

		RSurfaceManager::TInfoBuf infoBuf;

		User::LeaveIfError(KErrNone == iSurfaceManager.SurfaceInfo(iSurfaceId, infoBuf));

		RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

		aSurfaceSize = info.iSize;

		if(info.iPixelFormat == EUidPixelFormatYUV_422Interleaved)

			{

			aPixelFormat =EFormatYuv;

			}

		aSurfacePresent = ETrue;

		shareSurface = ETrue;

		}

	else

		{

		// SurfaceId not found - create surface to use with this window

		READ_INI2A(tempStore, surface_present, True, False, aSurfacePresent, ETrue, EFalse, iUtils);

		READ_INI1A(tempStore, sneeky_surface_height, aSurfaceSize.iHeight, iUtils);

		READ_INI1A(tempStore, surface_width, aSurfaceSize.iWidth, iUtils);

		//Convert surface size percentages to pixel sizes

		if(aScreenSize.iWidth <= 0)

			{

			RDebug::Print(_L("surface_width is zero or less, quitting\n"));

			User::Exit(0);

			}

		else

			{

			aSurfaceSize.iWidth = aSurfaceSize.iWidth*aScreenSize.iWidth/100;

			}

		if(aScreenSize.iHeight <= 0)

			{

			RDebug::Print(_L("surface_height is zero or less, quitting\n"));

			User::Exit(0);

			}

		else

			{

			aSurfaceSize.iHeight = aSurfaceSize.iHeight*aScreenSize.iHeight/100;

			}

		if(!aSurfacePresent && !shareSurface)

			{

			RDebug::Print(_L("Screen %d, Window %d has no backgroung surface\n"),aScreenNo, aWindowNo);

			return;

			}

		RDebug::Print(_L("Setting up surface attributes\n"));

		TInt bytesPerPixel;

		TInt pixelFormat;

		RSurfaceManager::TSurfaceCreationAttributesBuf attribBuf;

		RSurfaceManager::TSurfaceCreationAttributes& buffer = attribBuf();

	    buffer.iMappable = ETrue;

		READ_INI4A(tempStore, surface_pixel_format, EUidPixelFormatARGB_8888, EUidPixelFormatRGB_565, EUidPixelFormatARGB_8888_PRE,

		           EUidPixelFormatYUV_422Interleaved, pixelFormat, EUidPixelFormatARGB_8888, EUidPixelFormatRGB_565, EUidPixelFormatARGB_8888_PRE,

		           EUidPixelFormatYUV_422Interleaved, iUtils);

		READ_INI1A(tempStore, surface_bytes_per_pixel, bytesPerPixel, iUtils);

		READ_INI1A(tempStore, surface_offset_to_first_buffer, buffer.iOffsetToFirstBuffer, iUtils);

		READ_INI1A(tempStore, surface_alignment, buffer.iAlignment, iUtils);

		READ_INI2A(tempStore, surface_contiguous, True, False, buffer.iContiguous, ETrue, EFalse, iUtils);

		READ_INI1A(tempStore, surface_buffer_number, buffer.iBuffers, iUtils);

		buffer.iPixelFormat = static_cast<TUidPixelFormat>(pixelFormat);

		iSurfaceBufferNumber = buffer.iBuffers;

		iSurfaceScreenNumber = aScreenNo;

		if(buffer.iPixelFormat == EUidPixelFormatYUV_422Interleaved)

			{

			aPixelFormat =EFormatYuv;

			}

		//Assign size attribute to surface size calculated above

		buffer.iSize = aSurfaceSize;

		//Calculate required stride

		buffer.iStride = buffer.iSize.iWidth * bytesPerPixel;

		RDebug::Print(_L("Stride is %d\n"),buffer.iStride);

		//Create a surface manager session

		CreateSurfaceManager();

		RDebug::Print(_L("Call to CreateSurface()\n"));

		TInt err = iSurfaceManager.CreateSurface(attribBuf, iSurfaceId);

		if (err != KErrNone)

			{

			RDebug::Print(_L("Error creating surface, aborting\n"));

			User::Exit(0);

			}

		}

	//Assign the created surface to be the window background - surface needs to be open to do this ?????

	//Window must be activated at this point for the correct screen mode to be applied

	RDebug::Print(_L("Set Background Surface on the window\n"));

	TInt ret = iTestWindow->Window()->SetBackgroundSurface(iSurfaceId);

	if(ret != KErrNone)

		{

		RDebug::Print(_L("Error associating surface with window, SetBackgroundSurface returns %d aborting\n"), ret);

	 	User::Exit(0);

	 	}

	// Update PseudoAppShared SurfaceId array

	iPseudoAppShared.SetSurfaceIdL(aScreenNo, aWindowNo, iSurfaceId);

	if(shareSurface)

		{

		iPseudoAppShared.SetSurfaceIdL(shareScreenNumber, shareWindowNumber, iSurfaceId);

		}

	}

void CTestSurfacedWindow::ImportAnimConfigL(TInt aScreenNo, TInt aWindowNo, TDisplayMode aMode, const TSize& aSurfaceSize, TPixelFormat aPixelFormat)

	{

	TInt applicationType;

	TBuf<KMaxUiBitmapNameLength>	tempStore;

	tempStore.Format(KScreenAnimation, aScreenNo, aWindowNo);

	READ_INI5A(tempStore, application_type, none,   cfbsbitmap, openvg,  opengles,  performance,

               applicationType,  ENoApp, EFbsBitmap, EOpenVG, EOpenGLes, EPerformance, iUtils);

	if(applicationType == ENoApp)

		{

		RDebug::Print(_L("Screen %d, Window %d has no surface animation\n"),aScreenNo, aWindowNo);

		return;

		}

	TInt imageSize;

	TPtrC multiBitmapAnimFile;

	TInt verticalRate;

	TInt horizontalRate;

	//Read in the values from the ini file, taking specified action on failure

	READ_INI1A(tempStore, image_size, imageSize, iUtils);

	READ_INI1A(tempStore, multi_bitmap_anim_file, multiBitmapAnimFile, iUtils);

	READ_INI1A(tempStore, vertical_frames_per_traverse, verticalRate, iUtils);

	READ_INI1A(tempStore, horizontal_frames_per_traverse, horizontalRate, iUtils);

	//Ensure the animation step sizes are sub-multiples of the frame dimensions

	TImportScreenConfig::VerifyFramesPerTraverse(horizontalRate, aSurfaceSize.iWidth);

	TImportScreenConfig::VerifyFramesPerTraverse(verticalRate, aSurfaceSize.iHeight);

	//Convert image size percentage into a pixel size

	if(imageSize <= 0)

		{

		RDebug::Print(_L("image_size is zero or less, quitting\n"));

		User::Exit(0);

		}

	else

		{

		//Scale the bitmap to the short screen dimension

		if(aSurfaceSize.iWidth > aSurfaceSize.iHeight)

			{

			imageSize = imageSize*aSurfaceSize.iHeight/100;

			}

		else

			{

			imageSize = imageSize*aSurfaceSize.iWidth/100;

			}

		}

	iTestAnimation = CreateAnimationL(applicationType, TSize(imageSize,imageSize),

		                              aSurfaceSize, multiBitmapAnimFile, aMode,

		                              horizontalRate, verticalRate, aPixelFormat);

	}

CTestAnimation*  CTestSurfacedWindow::CreateAnimationL(TInt aAppType, const TSize& aAnimSize, const TSize& aSurfaceSize,

                                                       TPtrC& aBitmapFile, TDisplayMode aDisplayMode,

                                                       TInt aHorizontalRate, TInt aVerticalRate,

                                                       TPixelFormat aPixelFormat)

	{

	CTestAnimation* anim = 0;

	switch(aAppType)

		{

		case EFbsBitmap:

			{

			anim = CCFbsBitmapAnimation::NewL(aDisplayMode,

			                                  aAnimSize,

			                                  aSurfaceSize,

			                                  aBitmapFile,

			                                  aHorizontalRate,

			                                  aVerticalRate,

			                                  aPixelFormat);

			break;

			}

		case EOpenVG:

			{

			anim = CVgAnimation::NewL(iTestWindow->Window(),

									  aDisplayMode,

			                          aSurfaceSize,

			                          aHorizontalRate,

			                          aVerticalRate);

			break;

			}

		case EOpenGLes:

			{

			anim = COpenGLAnimation::NewL(iTestWindow->Window(),

										  aDisplayMode,

				                          aSurfaceSize,

				                          aHorizontalRate,

				                          aVerticalRate);

			break;

			}

		case EPerformance:

			{

			anim = CPerformanceAnimation::NewL();

			break;

			}

		case ENoApp:

			{

			break;

			}

		default:

			{

			break;	//Cannot reach the default, Lint warning removal purposes only

			}

		}

	return anim;

	}

CArrayFixFlat<TRect>* CTestSurfacedWindow::ImportWindowBitmapParamsL(const TDesC& tempStore, TInt aMultiBitmapUiFileSize, const TSize& aScreenSize)

	{

	TBuf<KMaxUiBitmapNameLength>	temp;

	TBuf<KMaxUiBitmapNameLength>	tempStore1;

	CArrayFixFlat<TRect>* loadsarects = new (ELeave) CArrayFixFlat<TRect>(1);

	for(TInt i=0; i<aMultiBitmapUiFileSize; i++)

		{

		TPtrC rectString;

		TRect aRect;

		tempStore1.Format(KUiBitmapScaling, i);

		temp = tempStore;

		temp.Append(tempStore1);

		TImportScreenConfig::ReadIni(temp, rectString, iUtils);

		if(TImportScreenConfig::ExtractRect(rectString, aRect, aScreenSize) == KErrNone)

			{

			loadsarects->ExtendL() = aRect;

			}

		else

			{

			RDebug::Print(_L("Cannot determine rectangle dimensions from string: %s\n"), rectString.Ptr());

			RDebug::Print(_L("Undefined behavior may result\n"));

			}

		}

	return loadsarects;

	}

CArrayFixFlat<TInt>* CTestSurfacedWindow::ImportWindowSizeChangeParamsL(const TDesC& tempStore)

	{

	TBuf<KMaxUiBitmapNameLength> temp = tempStore;

	CArrayFixFlat<TInt>* intArray = new (ELeave) CArrayFixFlat<TInt>(1);

	TInt windowSizeValues;

	TBuf<KMaxUiBitmapNameLength>	tempStore1;

	READ_INI1A(tempStore, window_size_values, windowSizeValues, iUtils);

	TInt windowSize;

	for(TInt i=1; i<windowSizeValues+1; i++)

		{

		tempStore1.Format(KWindowSizes, i);

		temp = tempStore;

		temp.Append(tempStore1);

		TImportScreenConfig::ReadIni(temp, windowSize, iUtils);

		intArray->ExtendL() = windowSize;

		}

	return intArray;

	}

CArrayFixFlat<TInt>* CTestSurfacedWindow::ImportWindowPositionChangeParamsL(const TDesC& tempStore)

	{

	TBuf<KMaxUiBitmapNameLength> temp = tempStore;

	CArrayFixFlat<TInt>* intArray = new (ELeave) CArrayFixFlat<TInt>(1);

	TInt windowPositionValues;

	TBuf<KMaxUiBitmapNameLength>	tempStore1;

	READ_INI1A(tempStore, window_position_values, windowPositionValues, iUtils);

	for(TInt i=1; i<windowPositionValues+1; i++)

		{

		TPoint point;

		TPtrC windowPosition;

		tempStore1.Format(KWindowPositions, i);

		temp = tempStore;

		temp.Append(tempStore1);

		TImportScreenConfig::ReadIni(temp, windowPosition, iUtils);

		if(TImportScreenConfig::ExtractPoint(windowPosition, point) == KErrNone)

			{

			intArray->ExtendL() = point.iX;

			intArray->ExtendL() = point.iY;

			}

		else

			{

			RDebug::Print(_L("Cannot determine point dimensions from string: %s\n"), windowPosition.Ptr());

			RDebug::Print(_L("Undefined behavior may result\n"));

			}

		}

	return intArray;

	}

void CTestSurfacedWindow::CreateSurfaceManager()

	{

	RDebug::Print(_L("Create Surface Manager\n"));

	TInt ret;

	RDebug::Print(_L("Loading the device driver and Opening the Logical Channel\n"));

	ret = iSurfaceManager.Open();

	if(ret==KErrNone)

		{

		RDebug::Print(_L("Surface manager opened ok\n"));

		}

	else

		{

		RDebug::Print(_L("Error opening surface manager\n"));

		}

	}

void CTestSurfacedWindow::DestroySurfaceManager()

	{

	RDebug::Print(_L("Close the Logical Channel\n"));

	iSurfaceManager.Close();

	}

void CTestSurfacedWindow::DestroySurface()

	{

	// Remove SurfaceId entry from surface array

	iPseudoAppShared.RemoveSurfaceIdEntry(iScreenNo, iWindowNumber);

	RDebug::Print(_L("Closing surface\n"));

	TInt ret = iSurfaceManager.CloseSurface(iSurfaceId);

	if(ret!=KErrNone)

		{

		RDebug::Print(_L("Surface failed to close\n"));

		}

	}

void CTestSurfacedWindow::BuildDimensionArrayL(const TSize& aScreenSize, TInt aFrameDuration, TInt aWindowChangeGeometry, TInt aWindowChangeBehavior)

	{

	TInt indexX;

	TInt indexY;

	iLoadsaParameters = new (ELeave) CArrayFixFlat<TDrawParameters>(1);

	TDrawParameters drawParams;

	for(TInt i=0; i<aFrameDuration; i++)

		{

		if(i)

			{

			drawParams = (*iLoadsaParameters)[i - 1];

			}

		else

			{

			drawParams.iWindowSize = TSize((aScreenSize.iWidth * (*iSizeArray)[0])/100,

			                         	   (aScreenSize.iHeight * (*iSizeArray)[0])/100);

			drawParams.iWindowPos = TPoint((aScreenSize.iWidth * (*iPositionArray)[0])/100,

			                         	   (aScreenSize.iHeight * (*iPositionArray)[1])/100);

			drawParams.iBitmapScale = (*iSizeArray)[0];

			drawParams.iBitmapAlpha = 127;

			}

		switch(aWindowChangeBehavior)

			{

			case ECyclic:

				{

				switch(aWindowChangeGeometry)

					{

					case ENoChanges:

						{

						drawParams.iWindowSize = aScreenSize;

						break;

						}

					case EWindowSize:

						{

						if(i < aFrameDuration/2)

							{

							drawParams.iBitmapScale = (*iSizeArray)[0] + (2*((*iSizeArray)[1] - (*iSizeArray)[0])*i)/aFrameDuration;

							}

						else

							{

							drawParams.iBitmapScale = 2*((*iSizeArray)[1]) - (*iSizeArray)[0] + (2*((*iSizeArray)[0] - (*iSizeArray)[1])*i)/aFrameDuration;

							}

						drawParams.iWindowSize = TSize( (aScreenSize.iWidth*drawParams.iBitmapScale)/100,

														(aScreenSize.iHeight*drawParams.iBitmapScale)/100 );

						break;

						}

					case EWindowPosition:

						{

						ParamChangeCyclicPosition(drawParams, i, aFrameDuration, aScreenSize);

						break;

						}

					case EWindowPositionAndSize:

						{

						ParamChangeCyclicPositionAndSize(drawParams, i, aFrameDuration, aScreenSize);

						break;

						}

					default:

						{

						break;

						}

					}

				break;

				}

			case EIncremental:

				{

				switch(aWindowChangeGeometry)

					{

					case ENoChanges:

						{

						break;

						}

					case EWindowSize:

						{

						drawParams.iBitmapScale = (*iSizeArray)[ (i*(iSizeArray->Count()))/aFrameDuration];

						drawParams.iWindowSize = TSize( (aScreenSize.iWidth*drawParams.iBitmapScale)/100,

														(aScreenSize.iHeight*drawParams.iBitmapScale)/100 );

						break;

						}

					case EWindowPosition:

						{

						indexX = 2*((((i*(iPositionArray->Count()/2))))/aFrameDuration);

						indexY = 2*((((i*(iPositionArray->Count()/2))))/aFrameDuration) + 1;

						drawParams.iWindowPos.iX = (aScreenSize.iWidth * (*iPositionArray)[indexX])/100;

						drawParams.iWindowPos.iY = (aScreenSize.iHeight * (*iPositionArray)[indexY])/100;

						break;

						}

					case EWindowPositionAndSize:

						{

						drawParams.iBitmapScale = (*iSizeArray)[ (i*(iSizeArray->Count()))/aFrameDuration];

						drawParams.iWindowSize = TSize( (aScreenSize.iWidth*drawParams.iBitmapScale)/100,

														(aScreenSize.iHeight*drawParams.iBitmapScale)/100 );

						indexX = 2*((((i*(iPositionArray->Count()/2))))/aFrameDuration);

						indexY = 2*((((i*(iPositionArray->Count()/2))))/aFrameDuration) + 1;

						drawParams.iWindowPos.iX = (aScreenSize.iWidth * (*iPositionArray)[indexX])/100;

						drawParams.iWindowPos.iY = (aScreenSize.iHeight * (*iPositionArray)[indexY])/100;

						break;

						}

					case EWindowPositionAndSizeWithOpacity:

						{

						ParamChangeOpacity(i, aFrameDuration, drawParams);

						drawParams.iBitmapScale = (*iSizeArray)[ (i*(iSizeArray->Count()))/aFrameDuration];

						drawParams.iWindowSize = TSize( (aScreenSize.iWidth*drawParams.iBitmapScale)/100,

														(aScreenSize.iHeight*drawParams.iBitmapScale)/100 );

						indexX = 2*((((i*(iPositionArray->Count()/2))))/aFrameDuration);

						indexY = 2*((((i*(iPositionArray->Count()/2))))/aFrameDuration) + 1;

						drawParams.iWindowPos.iX = (aScreenSize.iWidth * (*iPositionArray)[indexX])/100;

						drawParams.iWindowPos.iY = (aScreenSize.iHeight * (*iPositionArray)[indexY])/100;

						break;

						}

					default:

						{

						break;

						}

					}

				break;

				}

			case ENoChange:

			default:

				{

				break;

				}

			}

		iLoadsaParameters->ExtendL() = drawParams;

		}

	}

void CTestSurfacedWindow::ParamChangeCyclicPosition(TDrawParameters& aDrawParams, TInt aFrameCounter, TInt aFrameDuration, const TSize& aScreenSize)

	{

	TInt increment = (aScreenSize.iHeight * (100 - (*iSizeArray)[0]) +

	                  aScreenSize.iWidth  * (100 - (*iSizeArray)[0]))/(aFrameDuration * 25);

	if(aFrameCounter < (aFrameDuration/2 - 1))

		{

		CalcNewWindowLocation(aScreenSize, increment, 1, aDrawParams);

		}

	else if(aFrameCounter != (aFrameDuration - 1))

		{

		CalcNewWindowLocation(aScreenSize, increment, -1, aDrawParams);

		}

	else

		{

		aDrawParams.iWindowPos.iY -= increment;

		}

	}

void CTestSurfacedWindow::ParamChangeCyclicPositionAndSize(TDrawParameters& aDrawParams, TInt aFrameCounter, TInt aFrameDuration, const TSize& aScreenSize)

	{

	TInt incrementX = 2*aScreenSize.iWidth/aFrameDuration;

	TInt incrementY = 2*aScreenSize.iHeight/aFrameDuration;

	TSize incrementSize(incrementX, incrementY);

	TInt eigth = aFrameDuration/8;

	if(aFrameCounter < eigth)

		{

		aDrawParams.iWindowSize -= incrementSize;

		aDrawParams.iWindowPos.iY += incrementY;

		aDrawParams.iWindowPos.iX = 0;

		}

	else if( (aFrameCounter >= eigth) && (aFrameCounter < 2*eigth) )

		{

		aDrawParams.iWindowSize -= incrementSize;

		aDrawParams.iWindowPos.iY += incrementY;

		aDrawParams.iWindowPos.iX += 2*incrementX;

		}

	else if( (aFrameCounter >= 2*eigth) && (aFrameCounter < 3*eigth) )

		{

		aDrawParams.iWindowSize -= incrementSize;

		aDrawParams.iWindowPos.iY -= 2*incrementY;

		aDrawParams.iWindowPos.iX += incrementX;

		}

	else if( (aFrameCounter >= 3*eigth) && (aFrameCounter < 4*eigth) )

		{

		aDrawParams.iWindowSize -= incrementSize;

		aDrawParams.iWindowPos.iY = 0;

		aDrawParams.iWindowPos.iX -= 3*incrementX;

		}

	else if( (aFrameCounter >= 4*eigth) && (aFrameCounter < 5*eigth) )

		{

		aDrawParams.iWindowSize += incrementSize;

		aDrawParams.iWindowPos.iY = 0;

		aDrawParams.iWindowPos.iX += 3*incrementX;

		}

	else if( (aFrameCounter >= 5*eigth) && (aFrameCounter < 6*eigth) )

		{

		aDrawParams.iWindowSize += incrementSize;

		aDrawParams.iWindowPos.iY += 2*incrementY;

		aDrawParams.iWindowPos.iX -= incrementX;

		}

	else if( (aFrameCounter >= 6*eigth) && (aFrameCounter < 7*eigth) )

		{

		aDrawParams.iWindowSize += incrementSize;

		aDrawParams.iWindowPos.iY -= incrementY;

		aDrawParams.iWindowPos.iX -= 2*incrementX;

		}

	else

		{

		aDrawParams.iWindowSize += incrementSize;

		aDrawParams.iWindowPos.iY -= incrementY;

		aDrawParams.iWindowPos.iX = 0;

		}

	}

void CTestSurfacedWindow::ParamChangeOpacity(TInt aFrameCounter, TInt aFrameDuration, TDrawParameters& aDrawParams)

	{

	TInt alpha = (512 * aFrameCounter)/(aFrameDuration);

	if(alpha > 255)

		{

		alpha = 511 - alpha;

		}

	aDrawParams.iBitmapAlpha = alpha;

	}

void CTestSurfacedWindow::CalcNewWindowLocation(const TSize& aScreensize, TInt aIncrement, TInt aDirection,TDrawParameters& aDrawParams)

	{

	if(aDrawParams.iWindowPos.iX <= 0)

		{

		aDrawParams.iWindowPos.iX = 0;

		aDrawParams.iWindowPos.iY += aIncrement*aDirection;

		}

	if((aDrawParams.iWindowPos.iY + aDrawParams.iWindowSize.iHeight) >= aScreensize.iHeight)

		{

		aDrawParams.iWindowPos.iY = aScreensize.iHeight - aDrawParams.iWindowSize.iHeight;

		aDrawParams.iWindowPos.iX += aIncrement*aDirection;

		}

	if((aDrawParams.iWindowPos.iX + aDrawParams.iWindowSize.iWidth) >= aScreensize.iWidth)

		{

		aDrawParams.iWindowPos.iX = aScreensize.iWidth - aDrawParams.iWindowSize.iWidth;

		aDrawParams.iWindowPos.iY -= aIncrement*aDirection;

		}

	if(aDrawParams.iWindowPos.iY <= 0)

		{

		aDrawParams.iWindowPos.iY = 0;

		aDrawParams.iWindowPos.iX -= aIncrement*aDirection;

		}

	}