MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/test/t_integ/src/t_pseuodappsurfacedwindow.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @test

    19  @internalComponent

    20 */

    21 #include <e32const.h>	//KNullUidValue

    22 #include <pixelformats.h>

    23 #include "t_pseudoappsurfacedwindow.h"

    24 

    25 #include "t_testsurfacerasterizer.h"

    26 #include "t_pseudoapputils.h"

    27 #include "t_pseudoappscreen.h" //KScreenWindow

    28 #include "t_pseudoappcfbsbitmapanim.h"

    29 #include "t_pseudoappvganimation.h"

    30 #include "t_pseudoappopenglanimation.h"

    31 #include "t_pseudoappperformanceanim.h"

    32 

    33 

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

    35 							const TDesC& aConfigFileName, CTPseudoAppShared& aPseudoAppShared)

    36 	{

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

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

    39     CleanupStack::PushL(self);

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

    41     CleanupStack::Pop(); // self;

    42     return self;

    43 	}

    44 

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

    46 							const TDesC& aConfigFileName)

    47 	{

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

    49 

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

    51 	iUtils = CIniData::NewL(aConfigFileName);

    52 

    53 	TSize surfaceSize;

    54 	TInt surfacePresent = 0;

    55 	TPixelFormat pixelFormat  = EFormatRgb;

    56 

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

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

    59 

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

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

    62 	

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

    64 

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

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

    67 

    68 	if(surfacePresent)

    69 		{

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

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

    72 

    73 		if(iSurfaceRasterizer == 0)

    74 			{

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

    76 			User::Exit(0);

    77 			}

    78 		}

    79 

    80 	iGceTestResults = aGceTestResults;

    81 	}

    82 

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

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

    85 {

    86 }

    87 

    88 void CTestSurfacedWindow::UpdateL(SurfaceDetails& aSurfDetails)

    89 	{

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

    91 	if(iTestAnimation)

    92 		   {

    93 		   iTestAnimation->DrawL(iSurfaceRasterizer, aSurfDetails);

    94 		   }

    95 

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

    97 	iTestWindow->DrawL();

    98 	}

    99 

   100 CTestSurfacedWindow::~CTestSurfacedWindow()

   101 	{

   102 	delete iUtils;

   103 	if(iSizeArray)

   104 		{

   105 		TInt noElements = iSizeArray->Count();

   106 		iSizeArray->Delete(0, noElements);

   107 		delete iSizeArray;

   108 		iSizeArray = 0;

   109 		}

   110 

   111 	if(iPositionArray)

   112 		{

   113 		TInt noElements = iPositionArray->Count();

   114 		iPositionArray->Delete(0, noElements);

   115 		delete iPositionArray;

   116 		iPositionArray = 0;

   117 		}

   118 

   119 	if(iLoadsarects)

   120 		{

   121 		TInt noElements = iLoadsarects->Count();

   122 		iLoadsarects->Delete(0, noElements);

   123 		delete iLoadsarects;

   124 		iLoadsarects = 0;

   125 		}

   126 

   127 	if(iLoadsaParameters)

   128 		{

   129 		TInt noElements = iLoadsaParameters->Count();

   130 		iLoadsaParameters->Delete(0, noElements);

   131 		delete iLoadsaParameters;

   132 		iLoadsaParameters = 0;

   133 		}

   134 

   135 	delete iSurfaceRasterizer;

   136 	delete iTestWindow;

   137 	delete iTestAnimation;

   138 

   139 	DestroySurface();

   140 	DestroySurfaceManager();

   141 	}

   142 

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

   144 	{

   145 	if(iTestAnimation)

   146 		{

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

   148 		TSize surfaceSize;

   149 		TInt surfacePresent = 0;

   150 		TPixelFormat pixelFormat  = EFormatRgb;

   151 

   152 		delete iSurfaceRasterizer;

   153 		delete iTestAnimation;

   154 

   155 		DestroySurface();

   156 

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

   158 

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

   160 

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

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

   163 

   164 		if(surfacePresent)

   165 			{

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

   167 

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

   169 

   170 			if(iSurfaceRasterizer == 0)

   171 				{

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

   173 				User::Exit(0);

   174 				}

   175 			}

   176 

   177 		if(iTestAnimation->RotationSupported())

   178 			{

   179 			//Continue animation from the last unrotated frame number

   180 			iTestAnimation->SetFrameNumber(aFrameNumber);

   181 			}

   182 		}

   183 

   184 	iTestWindow->Rotate(aScreenSize);

   185 	}

   186 

   187 TBool CTestSurfacedWindow::RotationSupported()

   188 	{

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

   190 		{

   191 		if(iTestAnimation)

   192 			{

   193 			return iTestAnimation->RotationSupported();

   194 			}

   195 		else

   196 			{

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

   198 			return ETrue;

   199 			}

   200 		}

   201 	else

   202 		{

   203 		return EFalse;

   204 		}

   205 

   206 	}

   207 	

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

   209 	{

   210 	TBuf<KMaxUiBitmapNameLength>	tempStore;

   211 	tempStore.Format(KScreenWindowNumber, aScreenNo, aWindowNo);

   212 

   213 	TSize windowSize;

   214 	TInt windowType;

   215 	TInt windowChangeGeometry;

   216 	TInt windowChangeBehavior;

   217 

   218 	tempStore.Format(KScreenWindowNumber, aScreenNo, aWindowNo);

   219 

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

   221 	           windowType, EUiWindow, EEcomWindow, EEmptyWindow, iUtils);

   222 

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

   224 	switch(windowType)

   225 		{

   226 		case EEcomWindow:

   227 			{

   228 			TPtrC multiBitmapEcomFile;

   229 			TInt multiBitmapEcomFileSize;

   230 

   231 			READ_INI1A(tempStore, multi_bitmap_ecom_file, multiBitmapEcomFile, iUtils);

   232 			READ_INI1A(tempStore, multi_bitmap_ecom_file_size, multiBitmapEcomFileSize, iUtils);

   233 

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

   235 			           position_and_size_with_opacity, windowChangeGeometry, ENoChanges, EWindowSize,

   236 			           EWindowPosition, EWindowPositionAndSize, EWindowPositionAndSizeWithOpacity, iUtils);

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

   238 			           ENoChange, EIncremental, ECyclic, iUtils);

   239 

   240 		 	

   241 

   242 			iSizeArray = ImportWindowSizeChangeParamsL(tempStore);

   243 			iPositionArray = ImportWindowPositionChangeParamsL(tempStore);

   244 

   245 			BuildDimensionArrayL(aScreenSize, aFrameDuration, windowChangeGeometry, windowChangeBehavior);

   246 

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

   248 			break;

   249 			}

   250 		case EEmptyWindow:

   251 	 		{

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

   253 	 		break;

   254 	 		}

   255 	 	case EUiWindow:

   256 	 		{

   257 			TPtrC multiBitmapUiFile;

   258 			TInt multiBitmapUiFileSize;

   259 			TInt multiBitmapUiFileTransparency;

   260 

   261 			READ_INI1A(tempStore, multi_bitmap_ui_file, multiBitmapUiFile, iUtils);

   262 			READ_INI1A(tempStore, multi_bitmap_ui_file_size, multiBitmapUiFileSize, iUtils);

   263 			READ_INI2A(tempStore, multi_bitmap_ui_file_transparency, True,  False,

   264 	                   multiBitmapUiFileTransparency, ETrue, EFalse, iUtils);

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

   266 			           position_and_size_with_opacity, windowChangeGeometry, ENoChanges, EWindowSize,

   267 			           EWindowPosition, EWindowPositionAndSize, EWindowPositionAndSizeWithOpacity, iUtils);

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

   269 			           ENoChange, EIncremental, ECyclic, iUtils);

   270 

   271 

   272 			iSizeArray = ImportWindowSizeChangeParamsL(tempStore);

   273 			iPositionArray = ImportWindowPositionChangeParamsL(tempStore);

   274 

   275 			BuildDimensionArrayL(aScreenSize, aFrameDuration, windowChangeGeometry, windowChangeBehavior);

   276 

   277 			iLoadsarects = ImportWindowBitmapParamsL(tempStore, multiBitmapUiFileSize, aScreenSize);

   278 

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

   280 											  aFrameDuration,

   281 											  multiBitmapUiFileTransparency,

   282 											  aGceTestResults, iLoadsaParameters);

   283 			break;

   284 	 		}

   285 	 	default:

   286 	 		{

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

   288 			}

   289 		}

   290 	}

   291 

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

   293 	{

   294 	TBuf<KMaxUiBitmapNameLength>	tempStore;

   295 	tempStore.Format(KScreenSurface, aScreenNo, aWindowNo);

   296 

   297 	TInt shareScreenNumber;

   298 	TInt shareWindowNumber;

   299 

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

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

   302 

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

   304 	iSurfaceId = iPseudoAppShared.GetSurfaceId(aScreenNo, aWindowNo);

   305 	

   306 	if(shareSurface && iSurfaceId.IsNull())

   307 		{

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

   309 		iSurfaceId = iPseudoAppShared.GetSurfaceId(shareScreenNumber, shareWindowNumber);

   310 		}

   311 

   312 	if(!iSurfaceId.IsNull())

   313 		{

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

   315 		

   316 		//Create a surface manager session

   317 		CreateSurfaceManager();

   318 

   319 		iSurfaceManager.OpenSurface(iSurfaceId);

   320 		RSurfaceManager::TInfoBuf infoBuf;

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

   322 		RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

   323 		aSurfaceSize = info.iSize;

   324 		if(info.iPixelFormat == EUidPixelFormatYUV_422Interleaved)

   325 			{

   326 			aPixelFormat =EFormatYuv;

   327 			}

   328 		aSurfacePresent = ETrue;

   329 		shareSurface = ETrue;

   330 		}

   331 	else

   332 		{

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

   334 

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

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

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

   338 	

   339 		//Convert surface size percentages to pixel sizes

   340 		if(aScreenSize.iWidth <= 0)

   341 			{

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

   343 			User::Exit(0);

   344 			}

   345 		else

   346 			{

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

   348 			}

   349 	

   350 		if(aScreenSize.iHeight <= 0)

   351 			{

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

   353 			User::Exit(0);

   354 			}

   355 		else

   356 			{

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

   358 			}

   359 

   360 		if(!aSurfacePresent && !shareSurface)

   361 			{

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

   363 			return;

   364 			}

   365 

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

   367 		TInt bytesPerPixel;

   368 		TInt pixelFormat;

   369 		RSurfaceManager::TSurfaceCreationAttributesBuf attribBuf;

   370 		RSurfaceManager::TSurfaceCreationAttributes& buffer = attribBuf();

   371 	    buffer.iMappable = ETrue;

   372 

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

   374 		           EUidPixelFormatYUV_422Interleaved, pixelFormat, EUidPixelFormatARGB_8888, EUidPixelFormatRGB_565, EUidPixelFormatARGB_8888_PRE,

   375 		           EUidPixelFormatYUV_422Interleaved, iUtils);

   376 		READ_INI1A(tempStore, surface_bytes_per_pixel, bytesPerPixel, iUtils);

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

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

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

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

   381 	

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

   383 		iSurfaceBufferNumber = buffer.iBuffers;

   384 		iSurfaceScreenNumber = aScreenNo;

   385 		if(buffer.iPixelFormat == EUidPixelFormatYUV_422Interleaved)

   386 			{

   387 			aPixelFormat =EFormatYuv;

   388 			}

   389 	

   390 		//Assign size attribute to surface size calculated above

   391 		buffer.iSize = aSurfaceSize;

   392 	

   393 		//Calculate required stride

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

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

   396 

   397 		//Create a surface manager session

   398 		CreateSurfaceManager();

   399 

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

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

   402 		if (err != KErrNone)

   403 			{

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

   405 			User::Exit(0);

   406 			}

   407 		}

   408 

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

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

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

   412 

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

   414 	if(ret != KErrNone)

   415 		{

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

   417 	 	User::Exit(0);

   418 	 	}

   419 

   420 	// Update PseudoAppShared SurfaceId array

   421 	iPseudoAppShared.SetSurfaceIdL(aScreenNo, aWindowNo, iSurfaceId);

   422 	if(shareSurface)

   423 		{

   424 		iPseudoAppShared.SetSurfaceIdL(shareScreenNumber, shareWindowNumber, iSurfaceId);

   425 		}

   426 	}

   427 

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

   429 	{

   430 	TInt applicationType;

   431 	TBuf<KMaxUiBitmapNameLength>	tempStore;

   432 	tempStore.Format(KScreenAnimation, aScreenNo, aWindowNo);

   433 

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

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

   436 

   437 	if(applicationType == ENoApp)

   438 		{

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

   440 		return;

   441 		}

   442 

   443 	TInt imageSize;

   444 	TPtrC multiBitmapAnimFile;

   445 	TInt verticalRate;

   446 	TInt horizontalRate;

   447 

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

   449 	READ_INI1A(tempStore, image_size, imageSize, iUtils);

   450 	READ_INI1A(tempStore, multi_bitmap_anim_file, multiBitmapAnimFile, iUtils);

   451 	READ_INI1A(tempStore, vertical_frames_per_traverse, verticalRate, iUtils);

   452 	READ_INI1A(tempStore, horizontal_frames_per_traverse, horizontalRate, iUtils);

   453 

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

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

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

   457 

   458 	//Convert image size percentage into a pixel size

   459 	if(imageSize <= 0)

   460 		{

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

   462 		User::Exit(0);

   463 		}

   464 	else

   465 		{

   466 		//Scale the bitmap to the short screen dimension

   467 		if(aSurfaceSize.iWidth > aSurfaceSize.iHeight)

   468 			{

   469 			imageSize = imageSize*aSurfaceSize.iHeight/100;

   470 			}

   471 		else

   472 			{

   473 			imageSize = imageSize*aSurfaceSize.iWidth/100;

   474 			}

   475 		}

   476 

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

   478 		                              aSurfaceSize, multiBitmapAnimFile, aMode,

   479 		                              horizontalRate, verticalRate, aPixelFormat);

   480 	}

   481 

   482 

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

   484                                                        TPtrC& aBitmapFile, TDisplayMode aDisplayMode,

   485                                                        TInt aHorizontalRate, TInt aVerticalRate,

   486                                                        TPixelFormat aPixelFormat)

   487 	{

   488 	CTestAnimation* anim = 0;

   489 	switch(aAppType)

   490 		{

   491 		case EFbsBitmap:

   492 			{

   493 			anim = CCFbsBitmapAnimation::NewL(aDisplayMode,

   494 			                                  aAnimSize,

   495 			                                  aSurfaceSize,

   496 			                                  aBitmapFile,

   497 			                                  aHorizontalRate,

   498 			                                  aVerticalRate,

   499 			                                  aPixelFormat);

   500 			break;

   501 			}

   502 

   503 		case EOpenVG:

   504 			{

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

   506 									  aDisplayMode,

   507 			                          aSurfaceSize,

   508 			                          aHorizontalRate,

   509 			                          aVerticalRate);

   510 			break;

   511 			}

   512 		case EOpenGLes:

   513 			{

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

   515 										  aDisplayMode,

   516 				                          aSurfaceSize,

   517 				                          aHorizontalRate,

   518 				                          aVerticalRate);

   519 			break;

   520 			}

   521 

   522 		case EPerformance:

   523 			{

   524 			anim = CPerformanceAnimation::NewL();

   525 			break;

   526 			}

   527 		case ENoApp:

   528 			{

   529 			break;

   530 			}

   531 		default:

   532 			{

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

   534 			}

   535 		}

   536 	return anim;

   537 	}

   538 

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

   540 	{

   541 	TBuf<KMaxUiBitmapNameLength>	temp;

   542 	TBuf<KMaxUiBitmapNameLength>	tempStore1;

   543 

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

   545 

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

   547 		{

   548 		TPtrC rectString;

   549 		TRect aRect;

   550 

   551 		tempStore1.Format(KUiBitmapScaling, i);

   552 		temp = tempStore;

   553 		temp.Append(tempStore1);

   554 

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

   556 

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

   558 			{

   559 			loadsarects->ExtendL() = aRect;

   560 			}

   561 		else

   562 			{

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

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

   565 			}

   566 		}

   567 	return loadsarects;

   568 	}

   569 

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

   571 	{

   572 	TBuf<KMaxUiBitmapNameLength> temp = tempStore;

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

   574 

   575 	TInt windowSizeValues;

   576 	TBuf<KMaxUiBitmapNameLength>	tempStore1;

   577 

   578 	READ_INI1A(tempStore, window_size_values, windowSizeValues, iUtils);

   579 

   580 	TInt windowSize;

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

   582 		{

   583 		tempStore1.Format(KWindowSizes, i);

   584 		temp = tempStore;

   585 		temp.Append(tempStore1);

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

   587 		intArray->ExtendL() = windowSize;

   588 		}

   589 

   590 	return intArray;

   591 	}

   592 

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

   594 	{

   595 	TBuf<KMaxUiBitmapNameLength> temp = tempStore;

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

   597 

   598 	TInt windowPositionValues;

   599 	TBuf<KMaxUiBitmapNameLength>	tempStore1;

   600 

   601 	READ_INI1A(tempStore, window_position_values, windowPositionValues, iUtils);

   602 

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

   604 		{

   605 		TPoint point;

   606 		TPtrC windowPosition;

   607 		tempStore1.Format(KWindowPositions, i);

   608 		temp = tempStore;

   609 		temp.Append(tempStore1);

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

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

   612 			{

   613 

   614 			intArray->ExtendL() = point.iX;

   615 			intArray->ExtendL() = point.iY;

   616 			}

   617 		else

   618 			{

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

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

   621 			}

   622 		}

   623 	return intArray;

   624 	}

   625 

   626 void CTestSurfacedWindow::CreateSurfaceManager()

   627 	{

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

   629 

   630 	TInt ret;

   631 

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

   633 	ret = iSurfaceManager.Open();

   634 	if(ret==KErrNone)

   635 		{

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

   637 		}

   638 	else

   639 		{

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

   641 		}

   642 	}

   643 

   644 void CTestSurfacedWindow::DestroySurfaceManager()

   645 	{

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

   647 	iSurfaceManager.Close();

   648 	}

   649 

   650 void CTestSurfacedWindow::DestroySurface()

   651 	{

   652 	// Remove SurfaceId entry from surface array

   653 	iPseudoAppShared.RemoveSurfaceIdEntry(iScreenNo, iWindowNumber);

   654 

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

   656 	TInt ret = iSurfaceManager.CloseSurface(iSurfaceId);

   657 

   658 	if(ret!=KErrNone)

   659 		{

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

   661 		}

   662 	}

   663 

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

   665 	{

   666 	TInt indexX;

   667 	TInt indexY;

   668 

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

   670 

   671 	TDrawParameters drawParams;

   672 

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

   674 		{

   675 		if(i)

   676 			{

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

   678 			}

   679 		else

   680 			{

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

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

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

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

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

   686 			drawParams.iBitmapAlpha = 127;

   687 			}

   688 

   689 		switch(aWindowChangeBehavior)

   690 			{

   691 			case ECyclic:

   692 				{

   693 				switch(aWindowChangeGeometry)

   694 					{

   695 					case ENoChanges:

   696 						{

   697 						drawParams.iWindowSize = aScreenSize;

   698 						break;

   699 						}

   700 					case EWindowSize:

   701 						{

   702 						if(i < aFrameDuration/2)

   703 							{

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

   705 							}

   706 						else

   707 							{

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

   709 							}

   710 

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

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

   713 

   714 						break;

   715 						}

   716 					case EWindowPosition:

   717 						{

   718 						ParamChangeCyclicPosition(drawParams, i, aFrameDuration, aScreenSize);

   719 						break;

   720 						}

   721 					case EWindowPositionAndSize:

   722 						{

   723 						ParamChangeCyclicPositionAndSize(drawParams, i, aFrameDuration, aScreenSize);

   724 						break;

   725 						}

   726 					default:

   727 						{

   728 						break;

   729 						}

   730 					}

   731 				break;

   732 				}

   733 			case EIncremental:

   734 				{

   735 				switch(aWindowChangeGeometry)

   736 					{

   737 					case ENoChanges:

   738 						{

   739 						break;

   740 						}

   741 					case EWindowSize:

   742 						{

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

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

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

   746 						break;

   747 						}

   748 					case EWindowPosition:

   749 						{

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

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

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

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

   754 						break;

   755 						}

   756 					case EWindowPositionAndSize:

   757 						{

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

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

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

   761 

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

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

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

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

   766 						break;

   767 						}

   768 					case EWindowPositionAndSizeWithOpacity:

   769 						{

   770 						ParamChangeOpacity(i, aFrameDuration, drawParams);

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

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

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

   774 

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

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

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

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

   779 						break;

   780 						}

   781 					default:

   782 						{

   783 						break;

   784 						}

   785 					}

   786 				break;

   787 				}

   788 

   789 			case ENoChange:

   790 			default:

   791 				{

   792 				break;

   793 				}

   794 			}

   795 

   796 		iLoadsaParameters->ExtendL() = drawParams;

   797 		}

   798 	}

   799 

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

   801 	{

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

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

   804 

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

   806 		{

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

   808 		}

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

   810 		{

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

   812 		}

   813 	else

   814 		{

   815 		aDrawParams.iWindowPos.iY -= increment;

   816 		}

   817 	}

   818 

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

   820 	{

   821 	TInt incrementX = 2*aScreenSize.iWidth/aFrameDuration;

   822 	TInt incrementY = 2*aScreenSize.iHeight/aFrameDuration;

   823 	TSize incrementSize(incrementX, incrementY);

   824 	TInt eigth = aFrameDuration/8;

   825 

   826 	if(aFrameCounter < eigth)

   827 		{

   828 		aDrawParams.iWindowSize -= incrementSize;

   829 		aDrawParams.iWindowPos.iY += incrementY;

   830 		aDrawParams.iWindowPos.iX = 0;

   831 		}

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

   833 		{

   834 		aDrawParams.iWindowSize -= incrementSize;

   835 		aDrawParams.iWindowPos.iY += incrementY;

   836 		aDrawParams.iWindowPos.iX += 2*incrementX;

   837 		}

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

   839 		{

   840 		aDrawParams.iWindowSize -= incrementSize;

   841 		aDrawParams.iWindowPos.iY -= 2*incrementY;

   842 		aDrawParams.iWindowPos.iX += incrementX;

   843 		}

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

   845 		{

   846 		aDrawParams.iWindowSize -= incrementSize;

   847 		aDrawParams.iWindowPos.iY = 0;

   848 		aDrawParams.iWindowPos.iX -= 3*incrementX;

   849 		}

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

   851 		{

   852 		aDrawParams.iWindowSize += incrementSize;

   853 		aDrawParams.iWindowPos.iY = 0;

   854 		aDrawParams.iWindowPos.iX += 3*incrementX;

   855 		}

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

   857 		{

   858 		aDrawParams.iWindowSize += incrementSize;

   859 		aDrawParams.iWindowPos.iY += 2*incrementY;

   860 		aDrawParams.iWindowPos.iX -= incrementX;

   861 		}

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

   863 		{

   864 		aDrawParams.iWindowSize += incrementSize;

   865 		aDrawParams.iWindowPos.iY -= incrementY;

   866 		aDrawParams.iWindowPos.iX -= 2*incrementX;

   867 		}

   868 	else

   869 		{

   870 		aDrawParams.iWindowSize += incrementSize;

   871 		aDrawParams.iWindowPos.iY -= incrementY;

   872 		aDrawParams.iWindowPos.iX = 0;

   873 		}

   874 	}

   875 

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

   877 	{

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

   879 	if(alpha > 255)

   880 		{

   881 		alpha = 511 - alpha;

   882 		}

   883 

   884 	aDrawParams.iBitmapAlpha = alpha;

   885 	}

   886 

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

   888 	{

   889 	if(aDrawParams.iWindowPos.iX <= 0)

   890 		{

   891 		aDrawParams.iWindowPos.iX = 0;

   892 		aDrawParams.iWindowPos.iY += aIncrement*aDirection;

   893 		}

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

   895 		{

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

   897 		aDrawParams.iWindowPos.iX += aIncrement*aDirection;

   898 		}

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

   900 		{

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

   902 		aDrawParams.iWindowPos.iY -= aIncrement*aDirection;

   903 		}

   904 	if(aDrawParams.iWindowPos.iY <= 0)

   905 		{

   906 		aDrawParams.iWindowPos.iY = 0;

   907 		aDrawParams.iWindowPos.iX -= aIncrement*aDirection;

   908 		}

   909 	}
Symaptic