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

			{