--- /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 <aknutils.h>
+#include <gdi.h>
+#include <alf/alfenv.h>
+#include <alf/alfdisplay.h>
+#include <alf/alfgc.h>
+#include <alf/alfdisplay.h>
+#include <alf/alfcontrol.h>
+#include <alf/alfcontrolgroup.h>
+#include <alf/alfroster.h>
+#include <alf/alfcommand.h>
+#include <alf/alfevent.h>
+#include <alf/alftexturemanager.h>
+#include <alf/alfimagevisual.h>
+#include <alf/alftextvisual.h>
+#include <alf/alfimageloaderutil.h>
+#include <alf/alfutil.h>
+#include <alf/alflayout.h>
+#include <alf/alfviewportlayout.h>
+#include <alf/alfgridlayout.h>
+#include <alf/alfflowlayout.h>
+#include <alf/alfdecklayout.h>
+#include <alf/alftransformation.h>
+#include <alf/alfgradientbrush.h>
+#include <alf/alfborderbrush.h>
+#include <alf/alfbrusharray.h>
+
+#include <alfperfapp_imagetest.mbg>
+
+#include <alfperfappappui.h>
+
+
+/**
+ * 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<TInt> 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<TInt> 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<CAlfGridLayout* >( 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 );
+ }
+
+
+