diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfappcovertestcase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfappcovertestcase.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,948 @@ +/* +* 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: CAlfPerfAppCoverTestCase implementation. +* +*/ + + +#include "alfperfappcovertestcase.h" +#include "alfperfapp.hrh" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + + +/** + * Control group for Cover test cases. + */ +const TInt KAlfPerfAppCoverControlGroup = 2; + +/** + * Complete now command. + */ +const TInt KAlfPerfAppCoverCmdCompleteNow = 0x6000; + + +/** + * Cover flow test case control. + */ +class CAlfPerfAppCoverTestCaseControl : public CAlfControl + { +public: + + // Common constants + static const TInt KTransitionTime; + static const TInt KTransitionWaitTime; + static const TInt KRotationAngle; + + static CAlfPerfAppCoverTestCaseControl* NewL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ); + +protected: + /** + * Constructor. + */ + CAlfPerfAppCoverTestCaseControl(); + + /** + * Base class constructor. Derived classes may + * override this, but base class needs to be called. + */ + virtual void ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ); + +public: + /** + * Destructor. + */ + ~CAlfPerfAppCoverTestCaseControl(); + + /** + * Starts execution of the test case. By default, + * request status is stored to local variable. + */ + void StartExecuteL( TRequestStatus& aStatus ); + + /** + * Cancels execution. This control and environment will be + * deleted soon after calling this method. + */ + void CancelExecution(); + + /** + * Starts execution. + * If this method leaves, then request must not be completed. + * By default, this method completes immediately. + */ + virtual void DoStartExecuteL(); + + /** + * Sets visible area. + * @param aVisibleArea visible area. + */ + virtual void SetVisibleArea( const TRect& aVisibleArea ); + + // From base class CAlfControl: + + /** + * Handles events. + * Derived classes should forward to base class. + * @param aEvent event to be handled. + * @return ETrue if consumed, EFalse otherwise. + */ + virtual TBool OfferEventL( const TAlfEvent& aEvent ); + +protected: + /** + * Next cycle. + */ + void NextCycleL(); + + /** + * Changes the view port left or right according to the given amount. + * The amount can be negative or positive. + */ + void MoveImages( + TReal32 aAmount, + TReal32 aTransitionTime = KTransitionTime ); + + /** + * Changes the scaling. The current image is scaled to normal size. + * The previous image is scaled down. + * This should be called when images are moved. + * @see MoveImages + */ + void UpdateScaling( TReal32 aTransitionTime = KTransitionTime ); + + /** + * Rotates Image from 0to 360 and 0 to -360 in alternate cycles. + */ + void RotateImage( ); + + /** + * Clips the display layout, zooms into the image by scaling it to + * multiples of cycle count and also moves the image with X and Y offset of 5. + * It gives the Clip, zoom and panning effect to image. + */ + void ClipandZoom( ); + + /** + * A way to round floating point number to integer. + */ + TInt RoundFloatToInt( TReal32 aVal ); + + /** + * Completes automatically after specified duration. + * @param aDuration duration in ms + */ + void CompleteAfterL( TInt aDuration ); + + /** + * Completes current request. + */ + void CompleteNow( TInt aErrorCode ); + + /** + * Returns test case id. + */ + inline TInt CaseId() const; + + /** + * Returns ETrue if test case execution is still ongoing. + */ + inline TBool IsExecutionOngoing() const; + + /** + * Test case id. + */ + TInt iCaseId; + +private: + TInt iCycleCount; + + /** + * Pointer to request status. + * Not owned. + */ + TRequestStatus* iStatus; + + CAlfLayout* iLayout; + TReal32 iViewportPosition; + TReal32 iPreviousViewportPosition; + CAlfViewportLayout* iViewport; + }; + + +// ============================ MEMBER FUNCTIONS =============================== +// +// ----------------------------------------------------------------------------- +// Checks if specified case is supported by this class. +// ----------------------------------------------------------------------------- +// +TBool CAlfPerfAppCoverTestCase::IsSupported( TInt aCaseId ) + { + return aCaseId == EAlfPerfAppCover + || aCaseId == EAlfPerfAppCoverLandscape + || aCaseId == EAlfPerfAppCoverRotate + || aCaseId == EAlfPerfAppCoverClipZoomLargeImage + || aCaseId == EAlfPerfAppCoverClipZoomBigImage + || aCaseId == EAlfPerfAppCoverClipZoomVga + || aCaseId == EAlfPerfAppCoverClipZoomAutoSize; + } + +CAlfPerfAppCoverTestCase* CAlfPerfAppCoverTestCase::NewL( TInt aCaseId, TInt aSequenceIndex ) + { + if ( !IsSupported( aCaseId ) ) + { + User::Leave( KErrNotSupported ); + } + + CAlfPerfAppCoverTestCase* self = + new (ELeave) CAlfPerfAppCoverTestCase( aCaseId, aSequenceIndex); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +CAlfPerfAppCoverTestCase::~CAlfPerfAppCoverTestCase() + { + if ( iEnv && iControl ) + { + iEnv->TextureManager().RemoveLoadObserver( this ); + iControl->CancelExecution(); + iEnv->DeleteControlGroup( KAlfPerfAppCoverControlGroup ); + } + } + +// ----------------------------------------------------------------------------- +// Starts setup phase. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppCoverTestCase::SetupL( + CAlfEnv& aEnv, const TRect& /*aVisibleArea*/, TRequestStatus& aStatus ) + { + iEnv = &aEnv; + // the status pointer is taken for completing it + // when all the images are loaded. + iStatus = &aStatus; + + CAlfPerfAppAppUi* appUi = (CAlfPerfAppAppUi*) EikonEnv()->AppUi(); + iOrientation = appUi->Orientation(); + + switch ( iCaseId ) + { + case EAlfPerfAppCover: + { + appUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); + break; + } + + case EAlfPerfAppCoverLandscape: + { + appUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationLandscape ); + break; + } + case EAlfPerfAppCoverRotate: + case EAlfPerfAppCoverClipZoomLargeImage: + case EAlfPerfAppCoverClipZoomBigImage: + case EAlfPerfAppCoverClipZoomVga: + case EAlfPerfAppCoverClipZoomAutoSize: + { + break; + } + default: + User::Leave( KErrNotSupported ); + break; + } + + + TRect rect; + AknLayoutUtils::LayoutMetricsRect( + AknLayoutUtils::EApplicationWindow, + rect ); + + iEnv->SetFullScreenDrawing( ETrue ); + CAlfDisplay& display = + iEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayFullScreen ); + +#if 1 + // black seems to be the default color + display.SetClearBackgroundL( CAlfDisplay::EClearWithColor ); +#else + // for development/debugging purposes it is easier to see different + // components when there is a background. + display.SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground ); +#endif + + CAlfControlGroup& group = + iEnv->NewControlGroupL( KAlfPerfAppCoverControlGroup ); + + iLoadedImages = 0; + // the setup phase is completed only after the all images are + // loaded by the texture manager. see the construction of the + // control class. + aEnv.TextureManager().AddLoadObserverL( this ); + + iControl = CAlfPerfAppCoverTestCaseControl::NewL( + *iEnv, + iCaseId, + rect ); + + TRAPD(error,group.AppendL( iControl );) // ownership passed to control group. + if(error != KErrNone) + { + delete iControl; + iControl = 0; + } + + + display.Roster().ShowL( group ); + } + +// ----------------------------------------------------------------------------- +// Starts execution phase. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppCoverTestCase::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 CAlfPerfAppCoverTestCase::TearDown() + { + CAlfPerfAppAppUi* appUi = (CAlfPerfAppAppUi*) EikonEnv()->AppUi(); + TRAP_IGNORE( appUi->SetOrientationL( iOrientation ) ); + + // Execution side will delete CAlfEnv, so it will delete everything + // related to this. + iEnv = NULL; + iControl = NULL; + } + +void CAlfPerfAppCoverTestCase::HandleVisibleAreaChange( const TRect& aRect ) + { + if ( iEnv && iControl ) + { + if ( iEnv->DisplayCount() > 0 ) + { + iEnv->PrimaryDisplay().SetVisibleArea( aRect ); + } + + iControl->SetVisibleArea( aRect ); + } + } + +TInt CAlfPerfAppCoverTestCase::CaseID() + { + return iCaseId; + } + +CAlfPerfAppCoverTestCase::CAlfPerfAppCoverTestCase( TInt aCaseId, TInt aSequenceIndex ) + : CAlfPerfAppTestCase(aSequenceIndex), iCaseId ( aCaseId ) + { + } + +void CAlfPerfAppCoverTestCase::ConstructL() + { + } + +const TInt KNumberOfImages = 4; + +void CAlfPerfAppCoverTestCase::TextureLoadingCompleted( + CAlfTexture& /*aTexture*/, TInt /*aTextureId*/, TInt aErrorCode) + { + if( aErrorCode != KErrNone && iStatus ) + { + User::RequestComplete( iStatus, aErrorCode ); + iStatus = NULL; + } + iLoadedImages++; + TInt noOfImagesToLoad = 1; + if( CaseID() == EAlfPerfAppCover || + CaseID() == EAlfPerfAppCoverLandscape ) + { + noOfImagesToLoad = KNumberOfImages; + } + if ( iStatus && ( iLoadedImages == noOfImagesToLoad ) ) + { + User::RequestComplete( iStatus, KErrNone ); + iStatus = NULL; + } + } + +// Implementation of CAlfPerfAppCoverTestCaseControl: +const TInt CAlfPerfAppCoverTestCaseControl::KTransitionTime = 1000; +const TInt CAlfPerfAppCoverTestCaseControl::KTransitionWaitTime = 1000; +const TInt CAlfPerfAppCoverTestCaseControl::KRotationAngle = 360; + +CAlfPerfAppCoverTestCaseControl* CAlfPerfAppCoverTestCaseControl::NewL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ) + { + CAlfPerfAppCoverTestCaseControl* + result = new (ELeave) CAlfPerfAppCoverTestCaseControl; + CleanupStack::PushL( result ); + result->ConstructL( aEnv, aCaseId, aVisibleArea ); + CleanupStack::Pop(); + return result; + } + +CAlfPerfAppCoverTestCaseControl::CAlfPerfAppCoverTestCaseControl() + { + } + +CAlfPerfAppCoverTestCaseControl::~CAlfPerfAppCoverTestCaseControl() + { + CompleteNow( KErrCancel ); + } + +const TInt KShadowWidth = 20; // in pixels + + +static void AddBorderBrushL( + CAlfEnv& aEnv, + CAlfVisual& aVisual, + const TRgb& aColor, + TInt aThickness, + TInt aOffset ) + { + aVisual.EnableBrushesL(); + CAlfBorderBrush* brush = CAlfBorderBrush::NewLC( + aEnv, + aThickness, + aThickness, + aOffset, + aOffset ); + brush->SetColor( aColor ); + aVisual.Brushes()->AppendL( brush, EAlfHasOwnership ); + CleanupStack::Pop( brush ); + } + +static void AddFrameL( CAlfEnv& aEnv, CAlfVisual& aVisual ) + { + const TInt KNarrowBorderThickness = 2; + const TInt KBorderThickness = 4; + AddBorderBrushL( + aEnv, + aVisual, + TRgb( 75, 75, 75 ), + KNarrowBorderThickness, + KNarrowBorderThickness ); + AddBorderBrushL( + aEnv, + aVisual, + TRgb( 55, 55, 55 ), + KBorderThickness, + KNarrowBorderThickness + KBorderThickness ); + AddBorderBrushL( + aEnv, + aVisual, + TRgb( 25, 25, 25 ), + KNarrowBorderThickness, 2*KNarrowBorderThickness + KBorderThickness ); + } + +const TReal32 KFocusedImageScale = 1.0f; +const TReal32 KSmallImageScale = .65f; + +static void DownScaleImageL( CAlfVisual& aVisual, TInt aTransitionTime ) + { + TAlfTimedValue presser; + presser.SetValueNow( KFocusedImageScale ); + presser.SetTarget( KSmallImageScale, aTransitionTime ); + CAlfTransformation& lessening = aVisual.Transformation(); + lessening.LoadIdentity(); + lessening.Scale( presser, presser ); + } + +static CAlfGridLayout* AddItemL( + CAlfEnv& aEnv, + CAlfControl& aControl, + CAlfLayout& aLayout, + CAlfTexture& aTexture ) + { + // grid size: two lines, one item on the line + CAlfGridLayout* item = CAlfGridLayout::AddNewL( aControl, 1, 1, &aLayout ); + + // solid background for the item + item->EnableBrushesL(); + CAlfGradientBrush* brush = CAlfGradientBrush::NewLC( aEnv ); + brush->SetColor( TRgb( 60, 60, 60 ) ); // some gray + item->Brushes()->AppendL( brush, EAlfHasOwnership ); + CleanupStack::Pop( brush ); + + RArray weights; + CleanupClosePushL( weights ); + // this makes the image space much larger than the text box below it. + User::LeaveIfError( weights.Append( 100 ) ); + User::LeaveIfError( weights.Append( 15 ) ); + item->SetRowsL( weights ); + CleanupStack::PopAndDestroy(); + + CAlfImageVisual* visual = CAlfImageVisual::AddNewL( aControl, item ); + visual->SetImage( TAlfImage( aTexture ) ); + visual->EnableTransformationL(); + + return item; + } + +static CAlfGridLayout* AddItemTextL( + CAlfControl& aControl, + CAlfLayout& aParent, + const TDesC& aArtist, + const TDesC& aTitle ) + { + // creates a grid for holding text lines. + // grid size: two lines, one item on the line + CAlfGridLayout* texts = CAlfGridLayout::AddNewL( aControl, 1, 2, &aParent ); + texts->EnableTransformationL(); + + CAlfTextVisual* upper = CAlfTextVisual::AddNewL( aControl, texts ); + upper->SetStyle( EAlfTextStyleNormal, EAlfBackgroundTypeDark ); + upper->SetWrapping( CAlfTextVisual::ELineWrapTruncate ); + upper->SetTextL( aArtist ); + CAlfTextVisual* lower = CAlfTextVisual::AddNewL( aControl, texts ); + lower->SetStyle( EAlfTextStyleSmall ); + lower->SetWrapping( CAlfTextVisual::ELineWrapTruncate ); + lower->SetTextL( aTitle ); + + return texts; + } + +static void GetImageTestCasePrivatePath( TFileName& aPath ) + { + CEikonEnv::Static()->FsSession().PrivatePath( aPath ); + ::CompleteWithAppPath( aPath ); + } + +const TReal32 KViewportOffset = -.25f; +const TReal32 KViewportOffsetY = -.25f; + +void CAlfPerfAppCoverTestCaseControl::ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ) + { + iCaseId = aCaseId; + CAlfControl::ConstructL( aEnv ); + + TFileName privatePath; + GetImageTestCasePrivatePath( privatePath ); + aEnv.TextureManager().SetImagePathL( privatePath ); + + // this is the top most visual + CAlfDeckLayout* top = CAlfDeckLayout::AddNewL( *this ); + + // view port for scrolling + // this viewport needs to be added first for the deck + // to be under the shadows. + iViewport = CAlfViewportLayout::AddNewL( *this, top ); + iViewport->SetClipping( EFalse ); + + iViewport->SetViewportSize( TAlfRealSize( 1.5, 1.5 ), 0 ); + iViewport->SetViewportPos( + TAlfRealPoint( + iViewportPosition + KViewportOffset, + KViewportOffsetY ), + 0 ); + // building the grid for holding images and stuff scrolled + iLayout = CAlfGridLayout::AddNewL( + *this, + 1, + 1, // just one line of images + iViewport ); + TBuf<50> KImage = _L("alfphotos_small1.jpg"); + TInt textureFlag = EAlfTextureFlagRetainResolution; + switch(CaseId()) + { + case EAlfPerfAppCover: + case EAlfPerfAppCoverLandscape: + { + // one liner grid with left shadow, empty space, and right shadow + CAlfGridLayout* shadows = CAlfGridLayout::AddNewL( *this, 3, 1, top ); + + RArray weights; + CleanupClosePushL( weights ); + // the shadows are only small portition of + // the size of the empty space between them + User::LeaveIfError( weights.Append( 5 ) ); + User::LeaveIfError( weights.Append( 200 ) ); + User::LeaveIfError( weights.Append( 5 ) ); + shadows->SetColumnsL( weights ); + CleanupStack::PopAndDestroy(); + + // building of the left side shadow + CAlfImageVisual* leftShadow = CAlfImageVisual::AddNewL( *this, shadows ); + leftShadow->SetFlag( EAlfVisualFlagManualSize ); + leftShadow->SetSize( + TAlfRealPoint( KShadowWidth, aVisibleArea.Height() ) ); + leftShadow->EnableBrushesL(); + CAlfGradientBrush* leftBrush = CAlfGradientBrush::NewLC( aEnv ); + leftBrush->SetLayer( EAlfBrushLayerForeground ); + leftBrush->SetColor( KRgbBlack, 1.f ); + leftBrush->AppendColorL( 0.f, KRgbBlack, 1.f ); + leftBrush->AppendColorL( 1.0f, KRgbBlack, 0.f ); + leftShadow->Brushes()->AppendL( leftBrush, EAlfHasOwnership ); + CleanupStack::Pop( leftBrush ); + + // this is just an empty visual to get the layout correct, + // shadows take small portitions on left and right. + // middle part of the screen is left empty for the viewport. + CAlfImageVisual* emptySpace = CAlfImageVisual::AddNewL( *this, shadows ); + + // building of the right side shadow + CAlfImageVisual* rightShadow = CAlfImageVisual::AddNewL( *this, shadows ); + rightShadow->SetFlag( EAlfVisualFlagManualSize ); + rightShadow->SetSize( + TAlfRealPoint( KShadowWidth, aVisibleArea.Height() ) ); + rightShadow->EnableBrushesL(); + CAlfGradientBrush* rightBrush = CAlfGradientBrush::NewLC( aEnv ); + rightBrush->SetLayer( EAlfBrushLayerForeground ); + rightBrush->SetColor( KRgbBlack, 0.f ); + rightBrush->AppendColorL( .0f, KRgbBlack, 0.f ); + rightBrush->AppendColorL( 1.0f, KRgbBlack, 1.f ); + rightShadow->Brushes()->AppendL( rightBrush, EAlfHasOwnership ); + CleanupStack::Pop( rightBrush ); + + // NOTE: Now using small images for OpenVG, because of memory issues. + // These files may be replaced for BitGDI if needed. + _LIT( KImage2, "alfphotos_small2.jpg"); + _LIT( KImage3, "alfphotos_small3.jpg"); + _LIT( KImage4, "alfphotos_small4.jpg"); + KImage = _L("alfphotos_small1.jpg"); + + static_cast( iLayout )->SetColumns( KNumberOfImages ); + iViewport->SetVirtualSize( TAlfRealSize( KNumberOfImages, 1.0 ), 0 ); + + CAlfTexture& texture2 = aEnv.TextureManager().LoadTextureL( + KImage2, + TAlfTextureFlags( textureFlag ), + KAlfAutoGeneratedTextureId ); + + CAlfTexture& texture3 = aEnv.TextureManager().LoadTextureL( + KImage3, + TAlfTextureFlags( textureFlag ), + KAlfAutoGeneratedTextureId ); + + CAlfTexture& texture4 = aEnv.TextureManager().LoadTextureL( + KImage4, + TAlfTextureFlags( textureFlag ), + KAlfAutoGeneratedTextureId ); + + CAlfGridLayout* visual2 = AddItemL( aEnv, *this, *iLayout, texture2 ); + visual2->EnableTransformationL(); + AddFrameL( aEnv, *visual2 ); + + CAlfGridLayout* visual3 = AddItemL( aEnv, *this, *iLayout, texture3 ); + visual3->EnableTransformationL(); + AddFrameL( aEnv, *visual3 ); + + CAlfGridLayout* visual4 = AddItemL( aEnv, *this, *iLayout, texture4 ); + visual4->EnableTransformationL(); + AddFrameL( aEnv, *visual4 ); + + CAlfGridLayout* text2 = AddItemTextL( + *this, *visual2, _L( "Gwen Stefani" ), _L("Hollaback Girl") ); + + CAlfGridLayout* text3 = AddItemTextL( + *this, *visual3, _L( "No Doubt" ), _L("Don't Speak") ); + + CAlfGridLayout* text4 = AddItemTextL( + *this, *visual4, _L( "Jenni Vartiainen" ), _L("Ihmisten edessä") ); + + DownScaleImageL( *visual2, 0 ); + DownScaleImageL( *visual3, 0 ); + DownScaleImageL( *visual4, 0 ); + break; + } + case EAlfPerfAppCoverRotate: + { + KImage = _L("alfphotos_small1.jpg"); + break; + } + case EAlfPerfAppCoverClipZoomLargeImage: + { + KImage = _L("alfphotos_5mpx.jpg"); + iLayout->SetClipping( ETrue ); + iViewport->SetClipping( ETrue ); + top->SetClipping( ETrue ); + break; + } + case EAlfPerfAppCoverClipZoomBigImage: + { + KImage = _L("alfphotos_2mpx.jpg"); + iLayout->SetClipping( ETrue ); + iViewport->SetClipping( ETrue ); + top->SetClipping( ETrue ); + break; + } + case EAlfPerfAppCoverClipZoomVga: + { + KImage = _L("alfphotos_vga.jpg"); + iLayout->SetClipping( ETrue ); + iViewport->SetClipping( ETrue ); + top->SetClipping( ETrue ); + break; + } + case EAlfPerfAppCoverClipZoomAutoSize: + { + KImage = _L("alfphotos_small9.jpg"); + iLayout->SetClipping( ETrue ); + iViewport->SetClipping( ETrue ); + top->SetClipping( ETrue ); + textureFlag |= EAlfTextureFlagAutoSize; + break; + } + } + CAlfTexture& texture1 = aEnv.TextureManager().LoadTextureL( + KImage, + TAlfTextureFlags( textureFlag ), + KAlfAutoGeneratedTextureId ); + CAlfGridLayout* visual1 = AddItemL( aEnv, *this, *iLayout, texture1 ); + CAlfGridLayout* text1 = AddItemTextL( + *this, *visual1, _L( "TikTak" ), _L("Sinkut 99 - 07 Disc 1") ); + visual1->EnableTransformationL(); + visual1->Visual( 0 ).SetClipping( EFalse ); + if ( CaseId() == EAlfPerfAppCover || + CaseId() == EAlfPerfAppCoverLandscape ) + { + AddFrameL( aEnv, *visual1 ); + DownScaleImageL( *visual1, 0 ); + } + } + +void CAlfPerfAppCoverTestCaseControl::StartExecuteL( TRequestStatus& aStatus ) + { + iCycleCount = 0; + iViewportPosition = 0; + iPreviousViewportPosition = -1; // no previous position + + iStatus = &aStatus; + *iStatus = KRequestPending; + + TRAPD( err, DoStartExecuteL() ); + if ( err != KErrNone ) + { + iStatus = NULL; + User::Leave( err ); + } + } + +void CAlfPerfAppCoverTestCaseControl::CancelExecution() + { + CompleteNow( KErrCancel ); + } + +void CAlfPerfAppCoverTestCaseControl::DoStartExecuteL() + { + NextCycleL(); + CompleteAfterL( KTransitionWaitTime ); + } + +void CAlfPerfAppCoverTestCaseControl::SetVisibleArea( + const TRect& /*aVisibleArea*/ ) + { + } + +TBool CAlfPerfAppCoverTestCaseControl::OfferEventL( const TAlfEvent& aEvent ) + { + if ( aEvent.IsCustomEvent() && + aEvent.CustomParameter() == KAlfPerfAppCoverCmdCompleteNow ) + { + const TInt KNumberOfExecutedMovements = 15; + if ( iCycleCount < KNumberOfExecutedMovements ) + { + NextCycleL(); + CompleteAfterL( KTransitionWaitTime ); + } + else + { + CompleteNow( KErrNone ); + } + + return ETrue; + } + + return CAlfControl::OfferEventL( aEvent ); + } + +void CAlfPerfAppCoverTestCaseControl::NextCycleL() + { + static const TReal32 movements[] = { -1, -1, -1, 1, 1, 1 }; + const TInt size = 6; //sizeof movements; + const TInt index = iCycleCount % size; + + + switch(CaseId()) + { + case EAlfPerfAppCoverRotate: + RotateImage( ); + break; + case EAlfPerfAppCover: + case EAlfPerfAppCoverLandscape: + MoveImages( movements[ index ] ); + UpdateScaling(); + break; + case EAlfPerfAppCoverClipZoomLargeImage: + case EAlfPerfAppCoverClipZoomBigImage: + case EAlfPerfAppCoverClipZoomVga: + case EAlfPerfAppCoverClipZoomAutoSize: + ClipandZoom(); + break; + } + ++iCycleCount; + } + +void CAlfPerfAppCoverTestCaseControl::MoveImages( + TReal32 aAmount, + TReal32 aTransitionTime ) + { + iPreviousViewportPosition = iViewportPosition; + iViewportPosition -= aAmount; + + if ( iViewportPosition < 0 ) + { + iViewportPosition = 0; + } + else if ( iViewportPosition > ( KNumberOfImages - 1.0 ) ) + { + iViewportPosition = KNumberOfImages - 1.0; + } + + iViewport->SetViewportPos( + TAlfRealPoint( iViewportPosition + KViewportOffset, KViewportOffsetY ), + aTransitionTime ); + } + +void CAlfPerfAppCoverTestCaseControl::UpdateScaling( + TReal32 aTransitionTime ) + { + const TInt current = RoundFloatToInt( iViewportPosition ); + const TInt previous = RoundFloatToInt( iPreviousViewportPosition ); + + if ( previous >= 0 ) + { + CAlfVisual& currentVisual = iLayout->Visual( current ); + CAlfVisual& previousVisual = iLayout->Visual( previous ); + + TAlfTimedValue puller; + puller.SetValueNow( KSmallImageScale ); + puller.SetTarget( KFocusedImageScale, aTransitionTime ); + CAlfTransformation& enlarging = currentVisual.Transformation(); + enlarging.LoadIdentity(); + enlarging.Scale( puller, puller ); + + TRAP_IGNORE(DownScaleImageL( previousVisual, aTransitionTime )); + } + } + +void CAlfPerfAppCoverTestCaseControl::RotateImage( ) + { + TInt angle = KRotationAngle; + if ( iCycleCount%2 ) + { + angle = -KRotationAngle; + } + + CAlfVisual& currentVisual = iLayout->Visual( 0 ); + TAlfTimedValue rotator; + rotator.SetValueNow( 0 ); + rotator.SetTarget( angle, KTransitionTime ); + CAlfTransformation& rotation = currentVisual.Transformation(); + rotation.LoadIdentity(); + rotation.Rotate( rotator ); + } + +void CAlfPerfAppCoverTestCaseControl::ClipandZoom( ) + { + CAlfLayout& layout = static_cast< CAlfLayout& >( iLayout->Visual( 0 ) ); + CAlfVisual& imgVisual = layout.Visual( 0 ); + imgVisual.Move( TAlfRealPoint( -5, -5 ), KTransitionTime); + + TAlfTimedValue scaler; + scaler.SetValueNow( KFocusedImageScale * ( iCycleCount + 1 ) ); + scaler.SetTarget( KFocusedImageScale * ( iCycleCount + 2 ) , KTransitionTime ); + CAlfTransformation& enlarging = layout.Transformation(); + enlarging.LoadIdentity(); + enlarging.Scale( scaler, scaler ); + } + +TInt CAlfPerfAppCoverTestCaseControl::RoundFloatToInt( TReal32 aVal ) + { + return aVal < 0 ? (TInt)( aVal - 0.5f ) : (TInt)( aVal + 0.5f ); + } + +void CAlfPerfAppCoverTestCaseControl::CompleteAfterL( TInt aDuration ) + { + // In order to use this service, base class StartExecuteL must + // have been called. + __ASSERT_ALWAYS( iStatus, User::Invariant() ); + + TAlfCustomEventCommand command( KAlfPerfAppCoverCmdCompleteNow, this ); + User::LeaveIfError( Env().Send( command, aDuration ) ); + } + +void CAlfPerfAppCoverTestCaseControl::CompleteNow( TInt aErrorCode ) + { + if ( iStatus ) + { + User::RequestComplete( iStatus, aErrorCode ); + iStatus = NULL; + } + } + +inline TInt CAlfPerfAppCoverTestCaseControl::CaseId() const + { + return iCaseId; + } + +inline TBool CAlfPerfAppCoverTestCaseControl::IsExecutionOngoing() const + { + return ( iStatus != NULL ); + } + + +