diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfappimagetestcase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfappimagetestcase.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1153 @@ +/* +* Copyright (c) 2008 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: CAlfPerfAppImageTestCase implementation. +* +*/ + + +#include "alfperfappbasetestcasecontrol.h" +#include "alfperfappimagetestcase.h" +#include "alfperfapp.hrh" +#include "alfperfappconfigconstants.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef __NVG + #include +#endif +#include + +#include + +/* + * Square root of sequence length for the image sequence cases + */ +const TInt SEQUENCE_LENGTH_SQRT = 7; + +/** + * Control group for image test cases. + */ +const TInt KAlfPerfAppImageControlGroup = 1; + +/** + * Start next 'cycle' command. + */ +const TInt KAlfPerfAppImageCmdNext = 0x5001; + +/** + * Amount of image visuals. + */ +const TInt KAlfPerfAppImageTestCaseBasicImageCount = 16; + +/** + * Image data for test cases. + */ +_LIT( KAlfPerfAppImageTestCaseData, "\\resource\\apps\\alfperfapp_imagetest.mif" ); +_LIT( KAlfPerfAppImageTestCaseNvgCSData, "\\resource\\apps\\alfperfapp_imagetest_NVGCS.mif" ); +// NVG TLV Files have to be loaded from a certain place defined by icontype.cfg (in c:\ root) +_LIT( KAlfPerfAppImageTestCaseNvgTLVData, "\\data\\nvg_mif\\3musk.mif" ); + +#ifdef __NVG +// Enum that defines what icon (normal or NVG) is being used +// with the basic scale & movement test +enum TMoveScaleIcon + { + EMoveScaleIconMif = 0, + EMoveScaleIconCS, + EMoveScaleIconTLV + }; +#endif + +/** + * Basic image scale & movement test case. + */ +class CAlfPerfAppImageTestCaseBasic : public CAlfPerfAppBaseTestCaseControl +#ifdef __NVG + , public MAlfBitmapProvider +#endif + { +public: + CAlfPerfAppImageTestCaseBasic(); + ~CAlfPerfAppImageTestCaseBasic(); + + virtual void ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ); + virtual void DoStartExecuteL(); + virtual TBool OfferEventL( const TAlfEvent& aEvent ); + virtual void SetVisibleArea( const TRect& aVisibleArea ); + +#ifdef __NVG + void SetIconType( TMoveScaleIcon aIconType ); +#endif + +private: + + /** + * Next cycle. + */ + void NextCycleL(); + + /** + * Returns opacity for index. + */ + TReal32 OpacityForIndex( TInt aIndex ); + + /** + * Returns size for index. + */ + TAlfRealSize SizeForIndex( TInt aIndex ); + + /** + * Returns position for index. + */ + TAlfRealPoint PositionForIndex( TInt aIndex, const TAlfRealSize& aSize ); + +#ifdef __NVG + void ProvideBitmapL(TInt aId, CFbsBitmap*& aBitmap, CFbsBitmap*& aMaskBitmap); + CFbsBitmap* iBitmapToBeProvided; + TMoveScaleIcon iIconType; +#endif + +private: + + /** + * Image visuals. + */ + RPointerArray< CAlfImageVisual > iImages; + + /** + * Cycle counter. + */ + TInt iCycleCounter; + + /** + * Image loader utility. + * Owned. + */ + CAlfImageLoaderUtil* iLoader; + }; + +/** + * Many images at the same time + */ +#ifdef __NVG +class CAlfPerfAppImageTestCaseManyImages : public CAlfPerfAppBaseTestCaseControl, public MAlfBitmapProvider +#else +class CAlfPerfAppImageTestCaseManyImages : public CAlfPerfAppBaseTestCaseControl +#endif + { +public: + CAlfPerfAppImageTestCaseManyImages(); + ~CAlfPerfAppImageTestCaseManyImages(); + + virtual void ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea, TInt aSequenceIndex, TInt aVisualCount ); + virtual void DoStartExecuteL(); + virtual TBool OfferEventL( const TAlfEvent& aEvent ); + virtual void SetVisibleArea( const TRect& aVisibleArea ); + +#ifdef __NVG + void ProvideBitmapL(TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& /*aMaskBitmap*/); +#endif + +private: + + /** + * Next cycle. + */ + void NextCycleL(); + + /** + * Returns opacity for index. + */ + TBool OpacityForIndex( TInt aIndex, TReal32& aOpacity ); + + /** + * Returns size for index. + */ + TBool SizeForIndex( TInt aIndex, TAlfRealSize& aSize ); + + /** + * Returns position for index. + */ + TBool PositionForIndex( TInt aIndex, TAlfRealPoint& aPos ); + + + +private: + +#ifdef __NVG + CFbsBitmap* iBitmapToBeProvided; +#endif + /** + * Image visuals. + */ + RPointerArray< CAlfImageVisual > iImages; + + /** + * Cycle counter. + */ + TInt iCycleCounter; + + /** + * Image loader utility. + * Owned. + */ + CAlfImageLoaderUtil* iLoader; + + + /** + * Test case parameters + */ + TInt iVisualCount; // Number of visual to be created + TInt iVisualColums; + TInt iVisualRows; + TAlfRealPoint iVisualSpeed; // Pixels to move between cycles + TFileName iImageFileName; // File name of the texture image file + TInt iImageCount; // Number of different images + TSize iImageSize; // Image size + TAlfTextureFlags iTextureFlags; // Texture flags + TAlfRealSize iVisualSize; // Initial size of the visual + TAlfRealPoint iVisualSizeVel; // Velocity of visual size change per cycle + TInt iSimulatedPointerEventCount; // Number of pointer events sent to visula in one cycle + //TSize iAnimatedAreaSize; + TInt iLastIndexInAnimatedArea; // the index of the last visual that is animated, all before this are also animated + TInt iSequenceIndex; + }; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// Checks if specified case is supported by this class. +// ----------------------------------------------------------------------------- +// +TBool CAlfPerfAppImageTestCase::IsSupported( TInt aCaseId ) + { + return aCaseId > EAlfPerfAppImageMin && + aCaseId < EAlfPerfAppImageMax; + } + +CAlfPerfAppImageTestCase* CAlfPerfAppImageTestCase::NewL( TInt aCaseId, TInt aSequenceIndex ) + { + if ( !IsSupported( aCaseId ) ) + { + User::Leave( KErrNotSupported ); + } + + CAlfPerfAppImageTestCase* self = + new (ELeave) CAlfPerfAppImageTestCase( aCaseId, aSequenceIndex ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +CAlfPerfAppImageTestCase::~CAlfPerfAppImageTestCase() + { + if ( iEnv && iControl ) + { + iControl->CancelExecution(); + iEnv->DeleteControlGroup( KAlfPerfAppImageControlGroup ); + } + } + +// ----------------------------------------------------------------------------- +// Starts setup phase. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppImageTestCase::SetupL( + CAlfEnv& aEnv, const TRect& aVisibleArea, TRequestStatus& aStatus ) + { + + iEnv = &aEnv; + + CAlfDisplay* display = 0; + CAlfControlGroup& group = iEnv->NewControlGroupL( KAlfPerfAppImageControlGroup ); + CAlfPerfAppBaseTestCaseControl* control = 0; + iTotalVisualCount = -1; + iAnimationDivider = 0; + + if(SequenceIndex() != 0) + { + // Calculate + TInt caseNum = SEQUENCE_LENGTH_SQRT - (SequenceIndex()-1) / SEQUENCE_LENGTH_SQRT - 1; + TReal trg = 0.0; + Math::Pow(trg, 2.0, caseNum); + iAnimationDivider = trg+0.5; + + TRect rect; + AknLayoutUtils::LayoutMetricsRect( + AknLayoutUtils::EApplicationWindow, + rect ); + iEnv->SetFullScreenDrawing( ETrue ); + + + TInt counter = 10 - ((SequenceIndex()-1)%SEQUENCE_LENGTH_SQRT) - 1; // 2^3...2^9 always choose the + trg = 0.0; + Math::Pow(trg, 2.0, counter); + iTotalVisualCount = trg+0.5; + + display = &iEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayFullScreen ); + + display->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground ); + + control = new (ELeave) CAlfPerfAppImageTestCaseManyImages(); + CleanupStack::PushL( control ); + ((CAlfPerfAppImageTestCaseManyImages*)control)->ConstructL( *iEnv, iCaseId, aVisibleArea,SequenceIndex(),iTotalVisualCount ); + + } + else + { + display = &iEnv->NewDisplayL( aVisibleArea, CAlfEnv::ENewDisplayAsCoeControl); + display->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground ); + + switch ( iCaseId ) + { + case EAlfPerfAppImageBasicMoveScale: + control = new (ELeave) CAlfPerfAppImageTestCaseBasic; + CleanupStack::PushL( control ); + control->ConstructL( *iEnv, iCaseId, aVisibleArea ); + break; + +#ifdef __NVG + case EAlfPerfAppImageBasicMoveScaleNvgCS: + CAlfPerfAppImageTestCaseBasic* temp = new (ELeave) CAlfPerfAppImageTestCaseBasic; + temp->SetIconType(EMoveScaleIconCS); + control = temp; + CleanupStack::PushL( control ); + control->ConstructL( *iEnv, iCaseId, aVisibleArea); + break; + + case EAlfPerfAppImageBasicMoveScaleNvgTLV: + CAlfPerfAppImageTestCaseBasic* temp2 = new (ELeave) CAlfPerfAppImageTestCaseBasic; + temp2->SetIconType(EMoveScaleIconTLV); + control = temp2; + CleanupStack::PushL( control ); + control->ConstructL( *iEnv, iCaseId, aVisibleArea); + break; + + case EAlfPerfAppImageManyNvgCSImages: + case EAlfPerfAppImageManyNvgTLVImages: +#endif + case EAlfPerfAppImageManyImages: + case EAlfPerfAppImageManyGifImages: + case EAlfPerfAppImageManyPngImages: + case EAlfPerfAppImageManySvgImages: + case EAlfPerfAppImageManyImagesWithPointerEvent: + case EAlfPerfAppImageManyImagesWithAutoSize: + case EAlfPerfAppImageAnimateFull: + case EAlfPerfAppImageAnimate1of2: + case EAlfPerfAppImageAnimate1of4: + case EAlfPerfAppImageAnimate1of8: + control = new (ELeave) CAlfPerfAppImageTestCaseManyImages; + CleanupStack::PushL( control ); + ((CAlfPerfAppImageTestCaseManyImages*)control)->ConstructL( *iEnv, iCaseId, aVisibleArea,SequenceIndex(),iTotalVisualCount ); + break; + + default: + User::Leave( KErrNotSupported ); + break; + } + + } + group.AppendL( control ); // ownership passed to control group. + iControl = control; + CleanupStack::Pop( control ); + + display->Roster().ShowL( group ); + + // This must be last statement. + CAlfPerfAppTestCase::CompleteNow( aStatus, KErrNone ); + } + +// ----------------------------------------------------------------------------- +// Starts execution phase. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppImageTestCase::ExecuteL( TRequestStatus& aStatus ) + { + // SetupL must have been called first. + __ASSERT_ALWAYS( iEnv, User::Invariant() ); + __ASSERT_ALWAYS( iControl, User::Invariant() ); + + iControl->StartExecuteL( aStatus ); + } + +// ----------------------------------------------------------------------------- +// Tears down. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppImageTestCase::TearDown() + { + // Execution side will delete CAlfEnv, so it will delete everything + // related to this. + iEnv = NULL; + iControl = NULL; + } + +void CAlfPerfAppImageTestCase::HandleVisibleAreaChange( const TRect& aRect ) + { + if ( iEnv && iControl ) + { + if ( iEnv->DisplayCount() > 0 ) + { + iEnv->PrimaryDisplay().SetVisibleArea( aRect ); + } + iControl->SetVisibleArea( aRect ); + } + } + +TInt CAlfPerfAppImageTestCase::CaseID() + { + return iCaseId; + } + +CAlfPerfAppImageTestCase::CAlfPerfAppImageTestCase( TInt aCaseId, TInt aSequenceIndex ) + : CAlfPerfAppTestCase(aSequenceIndex), iCaseId ( aCaseId ) + { + } + +void CAlfPerfAppImageTestCase::ConstructL() + { + } + +// Implementation of CAlfPerfAppImageTestCaseBasic: +#ifdef __NVG +CAlfPerfAppImageTestCaseBasic::CAlfPerfAppImageTestCaseBasic(): iIconType(EMoveScaleIconMif) +#else +CAlfPerfAppImageTestCaseBasic::CAlfPerfAppImageTestCaseBasic() +#endif + { + } + +CAlfPerfAppImageTestCaseBasic::~CAlfPerfAppImageTestCaseBasic() + { + iImages.Close(); + + delete iLoader; + } + +void CAlfPerfAppImageTestCaseBasic::ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ) + { + CAlfPerfAppBaseTestCaseControl::ConstructL( aEnv, aCaseId, aVisibleArea ); + CAlfTextureManager& textureManager = aEnv.TextureManager(); + + iLoader = new (ELeave) CAlfImageLoaderUtil; + iLoader->SetSize( TSize( 64, 64 ) ); + + const TInt max = 4; + TInt count = 0; + TInt baseId = 16384; + + TFileName imageFile; + +#ifdef __NVG + TBool isNvg = EFalse; + if (iIconType == EMoveScaleIconCS) + { + imageFile.Append( KAlfPerfAppImageTestCaseNvgCSData ); + isNvg = ETrue; + } + else if (iIconType == EMoveScaleIconTLV) + { + imageFile.Append( KAlfPerfAppImageTestCaseNvgTLVData ); + isNvg = ETrue; + } + else if (iIconType == EMoveScaleIconMif) + { + imageFile.Append( KAlfPerfAppImageTestCaseData ); + } + else + { + // Error! Leave + User::Leave(KErrArgument); + } + // Add the drive letter to the imageFile path + ::CompleteWithAppPath( imageFile ); +#else + imageFile.Append( KAlfPerfAppImageTestCaseData ); + ::CompleteWithAppPath( imageFile ); +#endif + + while ( count < max && baseId < EMbmAlfperfapp_imagetestLastElement ) + { +#ifdef __NVG + if (isNvg) + { + TAlfTextureFlags flags = EAlfTextureFlagDefault; + // Use the modified AknIconUtils to create the extended bitmap + CFbsBitmap* extendedBitmap; + CFbsBitmap* extendedMask; + if(iIconType == EMoveScaleIconTLV) + { + // The TLV icon file has only one icon + AknIconUtils::CreateIconL(extendedBitmap, extendedMask, imageFile, 16384, 16385); + } + else + { + AknIconUtils::CreateIconL(extendedBitmap, extendedMask, imageFile, baseId, baseId + 1); + } + AknIconUtils::ExcludeFromCache(extendedBitmap); + AknIconUtils::SetSize( extendedBitmap, TSize(64,64) ); + + // This will be returned, when ProvideBitmapL is called for creating the texture + //delete iBitmapToBeProvided; + iBitmapToBeProvided = extendedBitmap; + delete extendedMask; + + count++; + textureManager.CreateTextureL(count, this, flags); + } + else + { + // Else load the icons normally from the mif file + count++; + textureManager.CreateTextureL( + count, + iLoader->CreateImageLoaderL( + KAknsIIDNone, + imageFile, + baseId, + baseId + 1 ), + EAlfTextureFlagDefault ); + } +#else + count++; + textureManager.CreateTextureL( + count, + iLoader->CreateImageLoaderL( + KAknsIIDNone, + imageFile, + baseId, + baseId + 1 ), + EAlfTextureFlagDefault ); +#endif + baseId += 2; // odd values are masks + } + + for ( TInt ii = 0; ii < KAlfPerfAppImageTestCaseBasicImageCount; ii++ ) + { + CAlfImageVisual* visual = CAlfImageVisual::AddNewL( *this ); + visual->SetFlag( EAlfVisualFlagManualLayout ); + visual->SetOpacity( 1.0f ); + + visual->SetOpacity( OpacityForIndex( ii ) ); + TAlfRealSize sz = SizeForIndex( ii ); + visual->SetSize( sz ); + visual->SetPos( PositionForIndex( ii, sz ) ); + + const CAlfTexture* texture = textureManager.Texture( 1 + ( ii & 3 ) ); + TAlfImage image( *texture ); + visual->SetImage( image ); + + iImages.AppendL( visual ); + } + } + +#ifdef __NVG +void CAlfPerfAppImageTestCaseBasic::SetIconType(TMoveScaleIcon aIconType) + { + iIconType = aIconType; + } +#endif + +void CAlfPerfAppImageTestCaseBasic::DoStartExecuteL() + { + NextCycleL(); + + CompleteAfterL( 5000 ); + } + +void CAlfPerfAppImageTestCaseBasic::SetVisibleArea( + const TRect& /*aVisibleArea*/ ) + { + if ( IsExecutionOngoing() ) + { + Env().CancelCustomCommands( this, KAlfPerfAppImageCmdNext ); + TRAPD( err, NextCycleL() ); + if ( err != KErrNone ) + { + CompleteNow( err ); + } + } + } + +TBool CAlfPerfAppImageTestCaseBasic::OfferEventL( const TAlfEvent& aEvent ) + { + if ( aEvent.IsCustomEvent() && + aEvent.CustomParameter() == KAlfPerfAppImageCmdNext ) + { + TRAPD( err, NextCycleL() ); + if ( err != KErrNone ) + { + CompleteNow( err ); + } + return ETrue; + } + + return CAlfPerfAppBaseTestCaseControl::OfferEventL( aEvent ); + } + +void CAlfPerfAppImageTestCaseBasic::NextCycleL() + { + TAlfCustomEventCommand command( KAlfPerfAppImageCmdNext, this ); + User::LeaveIfError( Env().Send( command, 500 ) ); + + iCycleCounter++; + + for ( TInt ii = 0; ii < iImages.Count(); ii++ ) + { + CAlfImageVisual* visual = iImages[ ii ]; + + TInt speed = KVisualAnimSpeed; + if ( ii & 1 ) + { + speed /= 2; + } + + visual->SetOpacity( TAlfTimedValue( OpacityForIndex( ii ), speed ) ); + TAlfRealSize sz = SizeForIndex( ii ); + visual->SetSize( sz, speed ); + visual->SetPos( PositionForIndex( ii, sz ), speed ); + } + } + +TReal32 CAlfPerfAppImageTestCaseBasic::OpacityForIndex( TInt aIndex ) + { + switch ( ( iCycleCounter + aIndex ) % 3 ) + { + case 0: + return 1.0f; + case 1: + return 0.5f; + case 2: + default: + return 0.25f; + } + } + +TAlfRealSize CAlfPerfAppImageTestCaseBasic::SizeForIndex( TInt aIndex ) + { + switch ( ( iCycleCounter + aIndex ) % 3 ) + { + case 0: + return TAlfRealSize( 25.f, 25.f ); + case 1: + return TAlfRealSize( 50.f, 50.f ); + case 2: + default: + return TAlfRealSize( 100.f, 100.f ); + } + } + +TAlfRealPoint CAlfPerfAppImageTestCaseBasic::PositionForIndex( + TInt aIndex, const TAlfRealSize& aSize ) + { + const TSize KSize( Env().PrimaryDisplay().VisibleArea().Size() ); + + switch ( ( iCycleCounter + aIndex ) & 3 ) + { + case 0: + return TAlfRealPoint( 0.0f, 0.0f ); + + case 1: + return TAlfRealPoint( KSize.iWidth - aSize.iWidth, KSize.iHeight - aSize.iHeight ); + + case 2: + return TAlfRealPoint( KSize.iWidth - aSize.iWidth, 0.0f ); + + case 3: + default: + return TAlfRealPoint( 0.0f, KSize.iHeight - aSize.iHeight ); + } + } + +#ifdef __NVG +void CAlfPerfAppImageTestCaseBasic::ProvideBitmapL(TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& /*aMaskBitmap*/) + { + aBitmap = iBitmapToBeProvided; + } +#endif + +// Implementation of CAlfPerfAppImageTestCaseManyImages: + +CAlfPerfAppImageTestCaseManyImages::CAlfPerfAppImageTestCaseManyImages() + { + } + +CAlfPerfAppImageTestCaseManyImages::~CAlfPerfAppImageTestCaseManyImages() + { + iImages.Close(); + + delete iLoader; + } + +void CAlfPerfAppImageTestCaseManyImages::ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea, TInt aSequenceIndex, TInt aVisualCount ) + { + CAlfPerfAppBaseTestCaseControl::ConstructL( aEnv, aCaseId, aVisibleArea ); + CAlfTextureManager& textureManager = aEnv.TextureManager(); + + TFileName privatePath; + CEikonEnv::Static()->FsSession().PrivatePath( privatePath ); + ::CompleteWithAppPath( privatePath ); + textureManager.SetImagePathL( privatePath ); + + TSize displaySize(Env().PrimaryDisplay().VisibleArea().Size()); + TInt KItemStep = 20; + + // Parameters for test cases + + iImageFileName = _L("\\resource\\apps\\alfperfapp_imagetest.mif"); + iVisualSpeed = TAlfRealPoint(1,0); + iImageCount = 4; + iVisualCount = (aVisualCount != -1) ? aVisualCount : KVisualCout; + iVisualColums = displaySize.iWidth/KItemStep; + iVisualRows = displaySize.iHeight/KItemStep;; + iTextureFlags = EAlfTextureFlagDefault; + iVisualSize = TAlfRealSize( 25.f, 25.f ); + iVisualSizeVel = TAlfRealPoint(); + iSimulatedPointerEventCount = 0; + iLastIndexInAnimatedArea = iVisualCount; + iImageSize = TSize( 64, 64 ); + iSequenceIndex = aSequenceIndex; + + if (iSequenceIndex != 0) + { + TInt caseNum = SEQUENCE_LENGTH_SQRT - (aSequenceIndex-1) / SEQUENCE_LENGTH_SQRT - 1; + TReal trg = 0.0; + Math::Pow(trg, 2.0, caseNum); + TInt pow = trg+0.5; + TReal animatedAreaRelativeSize = 1.f/pow; + + iImageFileName = _L("alfperfapp_imagetest.png"); + iLastIndexInAnimatedArea = iVisualCount*animatedAreaRelativeSize+0.5; + iLastIndexInAnimatedArea = (iLastIndexInAnimatedArea < 1) ? 1 : iLastIndexInAnimatedArea; + RDebug::Print(_L("CAlfPerfAppImageTestCaseManyImages::ConstructL(). Animated visual count = %d, percentage=%3.2f"), iLastIndexInAnimatedArea, animatedAreaRelativeSize); + + trg = 0.0; + Math::Sqrt(trg,TReal(iVisualCount)); + iVisualColums = (trg + 0.5); + iVisualRows = ((TReal)iVisualCount/iVisualColums) + 0.5; + + TSize displaySize(Env().PrimaryDisplay().VisibleArea().Size()); + iVisualSize = TAlfRealSize((TReal32)displaySize.iWidth/iVisualColums, (TReal32)displaySize.iHeight/iVisualRows); + iImageCount = 1; + iImageSize = TSize(iVisualSize.iWidth+0.5, iVisualSize.iHeight+0.5); + + iTextureFlags = EAlfTextureFlagDoNotRetainResolution; + } + else + { + + switch(CaseId()) + { + case EAlfPerfAppImageManyImages: + break; + + case EAlfPerfAppImageManyGifImages: + iImageFileName = _L("alfperfapp_imagetest.gif"); + break; + + case EAlfPerfAppImageManyPngImages: + iImageFileName = _L("alfperfapp_imagetest.png"); + break; + + case EAlfPerfAppImageManySvgImages: + iImageFileName = _L("alfperfapp_imagetest.svg"); + break; +#ifdef __NVG + case EAlfPerfAppImageManyNvgCSImages: + iImageFileName = KAlfPerfAppImageTestCaseNvgCSData; + //iImageFileName = _L("icons_mif_new2.mif"); + break; + + case EAlfPerfAppImageManyNvgTLVImages: + iImageFileName = KAlfPerfAppImageTestCaseNvgTLVData; + //iImageFileName = _L("TLV\\3musk.mif"); + break; +#endif + case EAlfPerfAppImageManyImagesWithPointerEvent: + iSimulatedPointerEventCount = 10; + break; + + case EAlfPerfAppImageManyImagesWithAutoSize: + iTextureFlags = EAlfTextureFlagAutoSize; + iVisualSizeVel = TAlfRealPoint(10,10); + break; + + case EAlfPerfAppImageAnimateFull: + { + iVisualCount = KVisualCout; + iLastIndexInAnimatedArea = iVisualCount * KRelativeAnimatedArea ; + iImageFileName = _L("alfperfapp_imagetest.svg"); + + TReal trg = 0.0; + Math::Sqrt(trg,TReal(iVisualCount)); + iVisualColums = (trg + 0.5); + iVisualRows = ((TReal)iVisualCount/iVisualColums) + 0.5; + + iVisualSize = TAlfRealSize((TReal32)displaySize.iWidth/iVisualColums, (TReal32)displaySize.iHeight/iVisualRows); + iImageCount = 1; + iImageSize = TSize(iVisualSize.iWidth+0.5, iVisualSize.iHeight+0.5); + + break; + } + case EAlfPerfAppImageAnimate1of2: + { + TReal animatedAreaRelativeSize = 1.f/2.f; + iVisualCount = KVisualCout; + iImageFileName = _L("alfperfapp_imagetest.svg"); + iLastIndexInAnimatedArea = iVisualCount*animatedAreaRelativeSize; + + TReal trg = 0.0; + Math::Sqrt(trg,TReal(iVisualCount)); + iVisualColums = (trg + 0.5); + iVisualRows = ((TReal)iVisualCount/iVisualColums) + 0.5; + + iVisualSize = TAlfRealSize((TReal32)displaySize.iWidth/iVisualColums, (TReal32)displaySize.iHeight/iVisualRows); + iImageCount = 1; + iImageSize = TSize(iVisualSize.iWidth+0.5, iVisualSize.iHeight+0.5); + + break; + } + + case EAlfPerfAppImageAnimate1of4: + { + TReal animatedAreaRelativeSize = 1.f/4.f; + iVisualCount = KVisualCout; + iImageFileName = _L("alfperfapp_imagetest.svg"); + iLastIndexInAnimatedArea = iVisualCount*animatedAreaRelativeSize; + + TReal trg = 0.0; + Math::Sqrt(trg,TReal(iVisualCount)); + iVisualColums = (trg + 0.5); + iVisualRows = ((TReal)iVisualCount/iVisualColums) + 0.5; + + iVisualSize = TAlfRealSize((TReal32)displaySize.iWidth/iVisualColums, (TReal32)displaySize.iHeight/iVisualRows); + iImageCount = 1; + iImageSize = TSize(iVisualSize.iWidth+0.5, iVisualSize.iHeight+0.5); + + break; + } + + case EAlfPerfAppImageAnimate1of8: + { + TReal animatedAreaRelativeSize = 1.f/8.f; + iVisualCount = KVisualCout; + iImageFileName = _L("alfperfapp_imagetest.svg"); + iLastIndexInAnimatedArea = iVisualCount*animatedAreaRelativeSize; + + TReal trg = 0.0; + Math::Sqrt(trg,TReal(iVisualCount)); + iVisualColums = (trg + 0.5); + iVisualRows = ((TReal)iVisualCount/iVisualColums) + 0.5; + + iVisualSize = TAlfRealSize((TReal32)displaySize.iWidth/iVisualColums, (TReal32)displaySize.iHeight/iVisualRows); + iImageCount = 1; + iImageSize = TSize(iVisualSize.iWidth+0.5, iVisualSize.iHeight+0.5); + + break; + } + + default: + User::Leave( KErrNotSupported ); + break; + } + } + + TParsePtr parse(iImageFileName); + + +#ifdef __NVG + if ( (CaseId() == EAlfPerfAppImageManyNvgCSImages || + CaseId() == EAlfPerfAppImageManyNvgTLVImages) && + parse.Ext().CompareF(_L(".mif")) == KErrNone) + { + TAlfTextureFlags flags = EAlfTextureFlagDefault; + // Use the modified AknIconUtils to create the extended bitmap + CFbsBitmap* extendedBitmap; + CFbsBitmap* extendedMask; + + AknIconUtils::CreateIconL( extendedBitmap, extendedMask, iImageFileName, 16384, 16385); + AknIconUtils::ExcludeFromCache(extendedBitmap); + AknIconUtils::SetSize( extendedBitmap, TSize(64,64) ); + + // This will be returned, when ProvideBitmapL is called for creating the texture + delete iBitmapToBeProvided; + iBitmapToBeProvided = extendedBitmap; + // We don't need the mask + delete extendedMask; + + for ( TInt count = 0; count < iImageCount; count++ ) + { + CAlfTexture& texture = textureManager.CreateTextureL(count+1, this, flags); + } + } + else if (parse.Ext().CompareF(_L(".mif")) == KErrNone) +#else + if (parse.Ext().CompareF(_L(".mif")) == KErrNone) +#endif + { + iLoader = new (ELeave) CAlfImageLoaderUtil; + iLoader->SetSize( iImageSize ); + + // mif file is from absolute path \\resource\\apps\\ + textureManager.SetImagePathL(_L("")); + + TInt baseId = 16384; + TInt count = 0; + while ( count < iImageCount ) + { + count++; + textureManager.CreateTextureL( + count, + iLoader->CreateImageLoaderL( + KAknsIIDNone, + iImageFileName, + baseId, + baseId + 1 ), + iTextureFlags ); + baseId += 2; // odd values are masks + } + } + else if (parse.Ext().CompareF(_L(".svg")) == KErrNone) + + { + iLoader = new (ELeave) CAlfImageLoaderUtil; + iLoader->SetSize( iImageSize ); + + TInt count = 0; + while ( count < iImageCount ) + { + count++; + textureManager.CreateTextureL( + count, + iLoader->CreateSVGImageLoaderL( + iImageFileName), + iTextureFlags ); + } + } + else + { + for ( TInt count = 0; count < iImageCount; count++ ) + { + CAlfTexture& texture = textureManager.LoadTextureL(iImageFileName, iTextureFlags, count+1); + } + } + + for ( TInt ii = 0; ii < iVisualCount; ii++ ) + { + CAlfImageVisual* visual = CAlfImageVisual::AddNewL( *this ); + iImages.AppendL( visual ); + + visual->SetFlag( EAlfVisualFlagManualLayout ); + visual->SetOpacity( 1.0f ); + TReal32 opacity = 1.0; + if (OpacityForIndex( ii, opacity )) + { + visual->SetOpacity( opacity ); + } + visual->SetSize( iVisualSize ); + TAlfRealSize size(0,0); + if (SizeForIndex( ii, size )) + { + visual->SetSize( size ); + } + + visual->SetPos( TAlfRealPoint(0,0) ); + TAlfRealPoint pos(0,0); + if (PositionForIndex( ii, pos )) + { + visual->SetPos( pos ); + } + + const CAlfTexture* texture = textureManager.Texture( 1 + ( ii % iImageCount ) ); + TAlfImage image( *texture ); + visual->SetImage( image ); + + } + } + +#ifdef __NVG +void CAlfPerfAppImageTestCaseManyImages::ProvideBitmapL(TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& /*aMaskBitmap*/) + { + CFbsBitmap* bmp = new(ELeave) CFbsBitmap(); + bmp->Duplicate(iBitmapToBeProvided->Handle()); + aBitmap = bmp; + }; +#endif + +void CAlfPerfAppImageTestCaseManyImages::DoStartExecuteL() + { + NextCycleL(); + + CompleteAfterL( 5000 ); + } + +void CAlfPerfAppImageTestCaseManyImages::SetVisibleArea( + const TRect& /*aVisibleArea*/ ) + { + if ( IsExecutionOngoing() ) + { + Env().CancelCustomCommands( this, KAlfPerfAppImageCmdNext ); + TRAPD( err, NextCycleL() ); + if ( err != KErrNone ) + { + CompleteNow( err ); + } + } + } + +TBool CAlfPerfAppImageTestCaseManyImages::OfferEventL( const TAlfEvent& aEvent ) + { + if ( aEvent.IsCustomEvent() && + aEvent.CustomParameter() == KAlfPerfAppImageCmdNext ) + { + TRAPD( err, NextCycleL() ); + if ( err != KErrNone ) + { + CompleteNow( err ); + } + return ETrue; + } + + return CAlfPerfAppBaseTestCaseControl::OfferEventL( aEvent ); + } + +void CAlfPerfAppImageTestCaseManyImages::NextCycleL() + { + TAlfCustomEventCommand command( KAlfPerfAppImageCmdNext, this ); + User::LeaveIfError( Env().Send( command, 500 ) ); + + iCycleCounter++; + + // Update cycle state + for ( TInt ii = 0; ii < iImages.Count(); ii++ ) + { + CAlfImageVisual* visual = iImages[ ii ]; + + TInt speed = KVisualAnimSpeed; + TReal32 opacity = 1.0; + if (OpacityForIndex( ii, opacity )) + { + visual->SetOpacity( TAlfTimedValue( opacity, speed ) ); + } + TAlfRealSize size(0,0); + if (SizeForIndex( ii, size )) + { + visual->SetSize( size, speed ); + } + + TAlfRealPoint pos(0,0); + if (PositionForIndex( ii, pos )) + { + visual->SetPos( pos, speed ); + } + } + + // Send pointer events, if wanted + for (TInt i=0; i Size().Target(); + aSize = TAlfRealSize( size.iWidth + iVisualSizeVel.iX, size.iHeight + iVisualSizeVel.iY ); + return ETrue; + } + return EFalse; + } + + +TBool CAlfPerfAppImageTestCaseManyImages::PositionForIndex( + TInt aIndex, TAlfRealPoint& aPos ) + { + if (iCycleCounter == 0 || aIndex <= iLastIndexInAnimatedArea) + { + TInt index = aIndex + iCycleCounter; + TInt gridIndex = index; + TInt columnPos = gridIndex % iVisualColums; + TInt rowPos = aIndex / iVisualColums; + columnPos = columnPos % iVisualColums; + aPos = TAlfRealPoint( columnPos*iVisualSize.iWidth, rowPos*iVisualSize.iHeight ); + return ETrue; + } + else + { + return EFalse; + } + } + + +TTestCaseSpecificResultText CAlfPerfAppImageTestCase::getCaseSpecificResultL() + { + TTestCaseSpecificResultText result = HBufC::NewL(KAlfPerfAppMaxCharsInSpecificResultText); + if(SequenceIndex() != 0 && CaseID() == EAlfPerfAppImageManyImages) + { + result->Des().Append(_L("Total Visual Count: ")); + result->Des().AppendNum(iTotalVisualCount); + result->Des().Append(_L(" Animated: 1/")); + result->Des().AppendNum(iAnimationDivider); + } + return result; + + }