diff -r 000000000000 -r bde4ae8d615e os/graphics/windowing/windowserver/test/t_integ/src/t_pseuodappsurfacedwindow.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/windowing/windowserver/test/t_integ/src/t_pseuodappsurfacedwindow.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,909 @@ +// 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 //KNullUidValue +#include +#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 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 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(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 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* CTestSurfacedWindow::ImportWindowBitmapParamsL(const TDesC& tempStore, TInt aMultiBitmapUiFileSize, const TSize& aScreenSize) + { + TBuf temp; + TBuf tempStore1; + + CArrayFixFlat* loadsarects = new (ELeave) CArrayFixFlat(1); + + for(TInt i=0; iExtendL() = 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* CTestSurfacedWindow::ImportWindowSizeChangeParamsL(const TDesC& tempStore) + { + TBuf temp = tempStore; + CArrayFixFlat* intArray = new (ELeave) CArrayFixFlat(1); + + TInt windowSizeValues; + TBuf tempStore1; + + READ_INI1A(tempStore, window_size_values, windowSizeValues, iUtils); + + TInt windowSize; + for(TInt i=1; iExtendL() = windowSize; + } + + return intArray; + } + +CArrayFixFlat* CTestSurfacedWindow::ImportWindowPositionChangeParamsL(const TDesC& tempStore) + { + TBuf temp = tempStore; + CArrayFixFlat* intArray = new (ELeave) CArrayFixFlat(1); + + TInt windowPositionValues; + TBuf tempStore1; + + READ_INI1A(tempStore, window_position_values, windowPositionValues, iUtils); + + for(TInt i=1; iExtendL() = 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(1); + + TDrawParameters drawParams; + + for(TInt i=0; iCount()))/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; + } + }