diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfappgallerytestcase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfappgallerytestcase.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,874 @@ +/* +* 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: CAlfPerfAppGalleryTestCase implementation. +* +*/ + + +#include "alfperfappgallerytestcase.h" +#include "alfperfappappui.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 + +/** + * Control group for image test cases. + */ +const TInt KAlfPerfAppGalleryControlGroup = 3; + +/** + * Complete now command. + */ +const TInt KAlfPerfAppGalleryCmdCompleteNow = 0x7000; + +/** + * Abstract gallery test case control. + */ +class CAlfPerfAppGalleryTestCaseControl : public CAlfControl, + public MAlfTextureLoadingCompletedObserver + { +public: + + // Common constants + static const TInt KTransitionTime; + static const TInt KTransitionWaitTime; + + /** + * Constructor. + */ + CAlfPerfAppGalleryTestCaseControl(); + + /** + * Destructor. + */ + ~CAlfPerfAppGalleryTestCaseControl(); + + static CAlfPerfAppGalleryTestCaseControl* NewL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& /*aVisibleArea*/); + + /** + * 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 ); + + /** + * 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(); + + /** + * Sets observer for texture loading. + * @param aObserver Observer class. + */ + void SetImagesLoadedObserver( MImagesLoadedObserver* aObserver ); + + /** + * Sets focused image. + * @param aImageTag Tag for the image to be focused. + */ + void SetImageFocusL( const TDesC8& aImageTag ); + + /** + * 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 ); + + // From base class MAlfTextureLoadingCompletedObserver + void TextureLoadingCompleted( CAlfTexture& aTexture, TInt aTextureId, + TInt aErrorCode ); + + +protected: + void MoveImages( + TReal32 aAmount, + TReal32 aTransitionTime = KTransitionTime ); + + /** + * Next cycle for scrolling the Grid layout. + */ + void NextScrollCycleL(); + + /** + * Next cycle for focusing image. + */ + void NextFocusCycleL(); + + /** + * Sets image focus based on event cycle. + */ + void UpdateImageFocus( TInt aCycle ); + + /** + * 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: + /** + * Pointer to request status. + * Not owned. + */ + TRequestStatus* iStatus; + + CAlfLayout* iGridLayout; + TReal32 iViewportPosition; + TReal32 iPreviousViewportPosition; + CAlfViewportLayout* iViewport; + CAlfLayout* iImageInfoLayout; + + TInt iCycleCount; + TInt iFocusChangedCount; + TInt iGridScrolledCount; + TInt iLoadedImages; + + CAlfImageVisual* iFocusedVisual; + + MImagesLoadedObserver* iObserver; + + RPointerArray iImageCaptions; + + RPointerArray iImagesToBeFocused; + }; + +// ============================ MEMBER FUNCTIONS =============================== +const TInt CAlfPerfAppGalleryTestCaseControl::KTransitionTime = 1000; +const TInt CAlfPerfAppGalleryTestCaseControl::KTransitionWaitTime = 1000; +// ----------------------------------------------------------------------------- +// Checks if specified case is supported by this class. +// ----------------------------------------------------------------------------- +// +TBool CAlfPerfAppGalleryTestCase::IsSupported( TInt aCaseId ) + { + return aCaseId > EAlfPerfAppGalleryMin && + aCaseId < EAlfPerfAppGalleryMax; + } + +CAlfPerfAppGalleryTestCase* CAlfPerfAppGalleryTestCase::NewL( TInt aCaseId, TInt aSequenceIndex ) + { + if ( !IsSupported( aCaseId ) ) + { + User::Leave( KErrNotSupported ); + } + + CAlfPerfAppGalleryTestCase* self = + new (ELeave) CAlfPerfAppGalleryTestCase( aCaseId, aSequenceIndex ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +CAlfPerfAppGalleryTestCase::~CAlfPerfAppGalleryTestCase() + { + if ( iEnv && iControl ) + { + iEnv->TextureManager().RemoveLoadObserver( iControl ); + iControl->CancelExecution(); + iEnv->DeleteControlGroup( KAlfPerfAppGalleryControlGroup ); + } + iImages.Close(); + delete iLoader; + } + +void CAlfPerfAppGalleryTestCase::ImagesLoaded( TInt aErrorCode ) + { + if( iStatus ) + { + CAlfPerfAppTestCase::CompleteNow( *iStatus, aErrorCode ); + iStatus = 0; + } + } + +// ----------------------------------------------------------------------------- +// Starts setup phase. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppGalleryTestCase::SetupL( + CAlfEnv& aEnv, const TRect& /*aVisibleArea*/, TRequestStatus& aStatus ) + { + iEnv = &aEnv; + + iStatus = &aStatus; + + CAlfPerfAppAppUi* appUi = (CAlfPerfAppAppUi*) EikonEnv()->AppUi(); + + iOrientation = appUi->Orientation(); + + switch ( iCaseId ) + { + case EAlfPerfAppGallery: + { + appUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); + break; + } + case EAlfPerfAppGalleryLandscape: + { + appUi->SetOrientationL( CAknAppUiBase::EAppUiOrientationLandscape ); + break; + } + default: + User::Leave( KErrNotSupported ); + break; + } + + TRect rect; + AknLayoutUtils::LayoutMetricsRect( + AknLayoutUtils::EApplicationWindow, + rect ); + + iEnv->SetFullScreenDrawing( ETrue ); + CAlfDisplay& display = + iEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayFullScreen ); + display.SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground ); + + CAlfControlGroup& group = + iEnv->NewControlGroupL( KAlfPerfAppGalleryControlGroup ); + + iControl = CAlfPerfAppGalleryTestCaseControl::NewL(*iEnv, iCaseId, rect ); + + group.AppendL( iControl ); // ownership passed to control group. + iControl->SetImagesLoadedObserver( this ); + + display.Roster().ShowL( group ); + } + +// ----------------------------------------------------------------------------- +// Starts execution phase. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppGalleryTestCase::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 CAlfPerfAppGalleryTestCase::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 CAlfPerfAppGalleryTestCase::HandleVisibleAreaChange( const TRect& aRect ) + { + if ( iEnv && iControl ) + { + if ( iEnv->DisplayCount() > 0 ) + { + iEnv->PrimaryDisplay().SetVisibleArea( aRect ); + } + iControl->SetVisibleArea( aRect ); + } + } + +TInt CAlfPerfAppGalleryTestCase::CaseID() + { + return iCaseId; + } + +CAlfPerfAppGalleryTestCase::CAlfPerfAppGalleryTestCase( TInt aCaseId, TInt aSequenceIndex ) + : CAlfPerfAppTestCase(aSequenceIndex), iCaseId ( aCaseId ) + { + } + +void CAlfPerfAppGalleryTestCase::ConstructL() + { + } + +// Implementation of CAlfPerfAppGalleryTestCaseControl: + +static void GetImageTestCasePrivatePath( TFileName& aPath ) + { + CEikonEnv::Static()->FsSession().PrivatePath( aPath ); + ::CompleteWithAppPath( aPath ); + } + +CAlfPerfAppGalleryTestCaseControl::CAlfPerfAppGalleryTestCaseControl() + { + } + +CAlfPerfAppGalleryTestCaseControl* CAlfPerfAppGalleryTestCaseControl::NewL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ) + { + CAlfPerfAppGalleryTestCaseControl* self = new (ELeave) CAlfPerfAppGalleryTestCaseControl(); + CleanupStack::PushL( self ); + self->ConstructL( aEnv, aCaseId, aVisibleArea ); + CleanupStack::Pop( self ); + return self; + } + +const TInt KNumberOfImages = 10; +const TInt KImagePadding = 5; +const TReal32 KNumberOfLinesInView = 3.5; +//const TReal32 KNumberOfColumnsInView = 4.0; +const TReal32 KNumberOfLinesInGrid = 5.0; +const TReal32 KNumberOfColumnsInGrid = 4.0; + +void CAlfPerfAppGalleryTestCaseControl::ConstructL( + CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea ) + { + iCaseId = aCaseId; + CAlfControl::ConstructL( aEnv ); + + TFileName privatePath; + GetImageTestCasePrivatePath( privatePath ); + aEnv.TextureManager().SetImagePathL( privatePath ); + + iLoadedImages = 0; + + // Viewport for grid + iViewport = CAlfViewportLayout::AddNewL( *this, 0 ); + iViewport->SetClipping( EFalse ); + iViewport->SetVirtualSize( TAlfRealSize( 1.0, KNumberOfLinesInGrid ), 0 ); + iViewport->SetViewportSize( TAlfRealSize( 1.0, KNumberOfLinesInView ), 0 ); + iViewport->SetViewportPos( TAlfRealPoint( iViewportPosition, 0 ), 0 ); + + // Background for viewport + CAlfGradientBrush* brush = CAlfGradientBrush::NewLC( aEnv ); + brush->SetDirection( CAlfGradientBrush::EDirectionDown ); + brush->SetLayer( EAlfBrushLayerBackground ); + brush->SetColor( KRgbBlack ); + brush->AppendColorL( 1.0f, KRgbGray ); + iViewport->EnableBrushesL( ETrue ); + iViewport->Brushes()->AppendL( brush, EAlfHasOwnership ); + CleanupStack::Pop( brush ); + + // Grid for images + iGridLayout = CAlfGridLayout::AddNewL( + *this, + KNumberOfColumnsInGrid, + KNumberOfLinesInGrid, // lines of images + iViewport ); + + // Images + // NOTE: Now using small images for OpenVG, because of memory issues. + // These files may be replaced for BitGDI if needed. + _LIT( KImage1, "alfphotos_small1.jpg" ); + _LIT( KImage2, "alfphotos_small2.jpg" ); + _LIT( KImage3, "alfphotos_small3.jpg" ); + _LIT( KImage4, "alfphotos_small4.jpg" ); + _LIT( KImage5, "alfphotos_small5.jpg" ); + _LIT( KImage6, "alfphotos_small6.jpg" ); + _LIT( KImage7, "alfphotos_small7.jpg" ); + _LIT( KImage8, "alfphotos_small8.jpg" ); + _LIT( KImage9, "alfphotos_small9.jpg" ); + _LIT( KImage10, "jpg_sun_small.jpg" ); + + // Visual tags + _LIT8( KVisual1, "visual1" ); + _LIT8( KVisual2, "visual2" ); + _LIT8( KVisual3, "visual3" ); + _LIT8( KVisual4, "visual4" ); + _LIT8( KVisual5, "visual5" ); + _LIT8( KVisual6, "visual6" ); + _LIT8( KVisual7, "visual7" ); + _LIT8( KVisual8, "visual8" ); + _LIT8( KVisual9, "visual9" ); + _LIT8( KVisual10, "visual10" ); + _LIT8( KVisual11, "visual11" ); + _LIT8( KVisual12, "visual12" ); + _LIT8( KVisual13, "visual13" ); + _LIT8( KVisual14, "visual14" ); + _LIT8( KVisual15, "visual15" ); + _LIT8( KVisual16, "visual16" ); + _LIT8( KVisual17, "visual17" ); + _LIT8( KVisual18, "visual18" ); + _LIT8( KVisual19, "visual19" ); + _LIT8( KVisual20, "visual20" ); + + // Captions for image metadata text field + _LIT( KImageCaption1, "alfphotos1" ); + _LIT( KImageCaption5, "alfphotos5" ); + _LIT( KImageCaption8, "alfphotos8" ); + + // The order of the visuals in image focusing + iImagesToBeFocused.Append( &KVisual17 ); + iImagesToBeFocused.Append( &KVisual5 ); + iImagesToBeFocused.Append( &KVisual1 ); + + // The corresponding image captions in image focusing + iImageCaptions.Append( &KImageCaption8 ); + iImageCaptions.Append( &KImageCaption5 ); + iImageCaptions.Append( &KImageCaption1 ); + + aEnv.TextureManager().AddLoadObserverL( this ); + + // Load textures for images + CAlfTexture& texture1 = aEnv.TextureManager().LoadTextureL( + KImage1, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture2 = aEnv.TextureManager().LoadTextureL( + KImage2, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture3 = aEnv.TextureManager().LoadTextureL( + KImage3, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture4 = aEnv.TextureManager().LoadTextureL( + KImage4, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture5 = aEnv.TextureManager().LoadTextureL( + KImage5, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture6 = aEnv.TextureManager().LoadTextureL( + KImage6, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture7 = aEnv.TextureManager().LoadTextureL( + KImage7, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture8 = aEnv.TextureManager().LoadTextureL( + KImage8, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture9 = aEnv.TextureManager().LoadTextureL( + KImage9, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + CAlfTexture& texture10 = aEnv.TextureManager().LoadTextureL( + KImage10, + EAlfTextureFlagRetainResolution, + KAlfAutoGeneratedTextureId ); + + // Add visuals to image grid + CAlfImageVisual* visual1 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual1->SetImage( TAlfImage( texture1 ) ); + visual1->SetPadding( KImagePadding ); + visual1->SetTagL( KVisual1 ); + CAlfImageVisual* visual2 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual2->SetImage( TAlfImage( texture2 ) ); + visual2->SetPadding( KImagePadding ); + visual2->SetTagL( KVisual2 ); + CAlfImageVisual* visual3 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual3->SetImage( TAlfImage( texture3 ) ); + visual3->SetPadding( KImagePadding ); + visual3->SetTagL( KVisual3 ); + CAlfImageVisual* visual4 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual4->SetImage( TAlfImage( texture4 ) ); + visual4->SetPadding( KImagePadding ); + visual4->SetTagL( KVisual4 ); + CAlfImageVisual* visual5 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual5->SetImage( TAlfImage( texture5 ) ); + visual5->SetPadding( KImagePadding ); + visual5->SetTagL( KVisual5 ); + CAlfImageVisual* visual6 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual6->SetImage( TAlfImage( texture6 ) ); + visual6->SetPadding( KImagePadding ); + visual6->SetTagL( KVisual6 ); + CAlfImageVisual* visual7 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual7->SetImage( TAlfImage( texture7 ) ); + visual7->SetPadding( KImagePadding ); + visual7->SetTagL( KVisual7 ); + CAlfImageVisual* visual8 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual8->SetImage( TAlfImage( texture8 ) ); + visual8->SetPadding( KImagePadding ); + visual8->SetTagL( KVisual8 ); + CAlfImageVisual* visual9 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual9->SetImage( TAlfImage( texture9 ) ); + visual9->SetPadding( KImagePadding ); + visual9->SetTagL( KVisual9 ); + CAlfImageVisual* visual10 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual10->SetImage( TAlfImage( texture10 ) ); + visual10->SetPadding( KImagePadding ); + visual10->SetTagL( KVisual10 ); + CAlfImageVisual* visual11 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual11->SetImage( TAlfImage( texture2 ) ); + visual11->SetPadding( KImagePadding ); + visual11->SetTagL( KVisual11 ); + CAlfImageVisual* visual12 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual12->SetImage( TAlfImage( texture3 ) ); + visual12->SetPadding( KImagePadding ); + visual12->SetTagL( KVisual12 ); + CAlfImageVisual* visual13 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual13->SetImage( TAlfImage( texture4 ) ); + visual13->SetPadding( KImagePadding ); + visual13->SetTagL( KVisual13 ); + CAlfImageVisual* visual14 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual14->SetImage( TAlfImage( texture5 ) ); + visual14->SetPadding( KImagePadding ); + visual14->SetTagL( KVisual14 ); + CAlfImageVisual* visual15 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual15->SetImage( TAlfImage( texture6 ) ); + visual15->SetPadding( KImagePadding ); + visual15->SetTagL( KVisual15 ); + CAlfImageVisual* visual16 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual16->SetImage( TAlfImage( texture7 ) ); + visual16->SetPadding( KImagePadding ); + visual16->SetTagL( KVisual16 ); + CAlfImageVisual* visual17 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual17->SetImage( TAlfImage( texture8 ) ); + visual17->SetPadding( KImagePadding ); + visual17->SetTagL( KVisual17 ); + CAlfImageVisual* visual18 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual18->SetImage( TAlfImage( texture9 ) ); + visual18->SetPadding( KImagePadding ); + visual18->SetTagL( KVisual18 ); + CAlfImageVisual* visual19 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual19->SetImage( TAlfImage( texture1 ) ); + visual19->SetPadding( KImagePadding ); + visual19->SetTagL( KVisual19 ); + CAlfImageVisual* visual20 = CAlfImageVisual::AddNewL( *this, iGridLayout ); + visual20->SetImage( TAlfImage( texture2 ) ); + visual20->SetPadding( KImagePadding ); + visual20->SetTagL( KVisual20 ); + + // Focus on visual 1 + CAlfBorderBrush* actualBorder = CAlfBorderBrush::NewLC( Env(), 4, 4, 0, 0 ); + actualBorder->SetColor( KRgbBlue ); + visual1->EnableBrushesL( ETrue ); + visual1->Brushes()->AppendL( actualBorder, EAlfHasOwnership ); + CleanupStack::Pop( actualBorder ); + + // Area for image metadata + TRect textFieldArea; + textFieldArea.SetWidth( aVisibleArea.Width() ); + textFieldArea.SetHeight( aVisibleArea.Height() / 7 ); + + // Layout for image metadata + CAlfGridLayout* iImageInfoLayout = CAlfGridLayout::AddNewL( *this, 1, 1, 0 ); + iImageInfoLayout->EnableBrushesL( ETrue ); + iImageInfoLayout->SetFlag( EAlfVisualFlagManualSize ); + iImageInfoLayout->SetFlag( EAlfVisualFlagManualPosition ); + iImageInfoLayout->SetRect( textFieldArea, 0 ); + iImageInfoLayout->SetPos( TAlfRealPoint( 0 , aVisibleArea.Height() - textFieldArea.Height() ) , 0 ); + + // Text for image metadata + CAlfTextVisual* text = CAlfTextVisual::AddNewL( *this, iImageInfoLayout ); + text->SetTextL( KImageCaption1 ); + text->EnableBrushesL( ETrue ); + text->SetColor( KRgbWhite ); + text->SetTagL( _L8( "text1" ) ); + + // Background for image metadata + CAlfGradientBrush* textBackgroundBrush = CAlfGradientBrush::NewLC( aEnv ); + textBackgroundBrush->SetColor( KRgbGray ); + textBackgroundBrush->SetOpacity( 0.5f ); + textBackgroundBrush->SetLayer( EAlfBrushLayerBackground ); + iImageInfoLayout->Brushes()->AppendL( textBackgroundBrush, EAlfHasOwnership ); + CleanupStack::Pop( textBackgroundBrush ); + + // Border for image metadata + CAlfBorderBrush* border = CAlfBorderBrush::NewLC( aEnv, 2, 2, 5, 5 ); + border->SetOpacity( 0.5f ); + iImageInfoLayout->Brushes()->AppendL( border, EAlfHasOwnership ); + CleanupStack::Pop( border ); + } + +CAlfPerfAppGalleryTestCaseControl::~CAlfPerfAppGalleryTestCaseControl() + { + CompleteNow( KErrCancel ); + iImageCaptions.Reset(); + iImagesToBeFocused.Reset(); + } + +void CAlfPerfAppGalleryTestCaseControl::SetImagesLoadedObserver( MImagesLoadedObserver* aObserver ) + { + iObserver = aObserver; + } + +// ----------------------------------------------------------------------------- +// Notify observers that all images have been loaded. +// ----------------------------------------------------------------------------- +// +void CAlfPerfAppGalleryTestCaseControl::TextureLoadingCompleted( + CAlfTexture& /*aTexture*/, TInt /*aTextureId*/, TInt aErrorCode) + { + // inform if there is any error + if( aErrorCode != KErrNone ) + { + iObserver->ImagesLoaded( aErrorCode ); + } + + iLoadedImages++; + if (iLoadedImages == KNumberOfImages) + { + iObserver->ImagesLoaded( KErrNone ); + } + } + +void CAlfPerfAppGalleryTestCaseControl::StartExecuteL( TRequestStatus& aStatus ) + { + iCycleCount = 0; + iFocusChangedCount = 0; + iGridScrolledCount = 0; + iViewportPosition = 0; + iPreviousViewportPosition = -1; // no previous position + iStatus = &aStatus; + *iStatus = KRequestPending; + + TRAPD( err, DoStartExecuteL() ); + if ( err != KErrNone ) + { + iStatus = NULL; + User::Leave( err ); + } + } + +void CAlfPerfAppGalleryTestCaseControl::CancelExecution() + { + CompleteNow( KErrCancel ); + } + +void CAlfPerfAppGalleryTestCaseControl::DoStartExecuteL() + { + NextScrollCycleL(); + CompleteAfterL( KTransitionWaitTime ); + } + +void CAlfPerfAppGalleryTestCaseControl::SetVisibleArea( + const TRect& /*aVisibleArea*/ ) + { + } + +TBool CAlfPerfAppGalleryTestCaseControl::OfferEventL( const TAlfEvent& aEvent ) + { + if ( aEvent.IsCustomEvent() && + aEvent.CustomParameter() == KAlfPerfAppGalleryCmdCompleteNow ) + { + const TInt KNumberOfExecutedMovements = 15; + if ( iCycleCount < KNumberOfExecutedMovements ) + { +// Disabling the image focusing between scroll cycles +#if 0 + TInt odd = iCycleCount % 2; + if( odd == 0 ) + { +#endif + NextScrollCycleL(); + CompleteAfterL( KTransitionWaitTime ); +#if 0 + } + else + { + NextFocusCycleL(); + CompleteAfterL( 0 ); + } +#endif + } + else + { + CompleteNow( KErrNone ); + } + + return ETrue; + } + + return CAlfControl::OfferEventL( aEvent ); + } + +void CAlfPerfAppGalleryTestCaseControl::NextScrollCycleL() + { + static const TReal32 movements[] = { -2, 1, 1 }; + + const TInt size = 3; //sizeof movements; + const TInt index = iGridScrolledCount % size; + + MoveImages(movements[ index ]); + + ++iCycleCount; + ++iGridScrolledCount; + } + + +void CAlfPerfAppGalleryTestCaseControl::NextFocusCycleL() + { + const TInt size = 3; + const TInt index = iFocusChangedCount % size; + + UpdateImageFocus( index ); + + ++iCycleCount; + ++iFocusChangedCount; + } + + + +void CAlfPerfAppGalleryTestCaseControl::UpdateImageFocus( TInt aIndex ) + { + // TODO: Checking if textVisual can be found + CAlfTextVisual* textVisual = static_cast( FindTag( _L8( "text1" ) ) ); + TRAP_IGNORE(textVisual->SetTextL( *iImageCaptions.operator[]( aIndex ) )); + TRAP_IGNORE(SetImageFocusL( *iImagesToBeFocused.operator[]( aIndex ) )); + } + + +void CAlfPerfAppGalleryTestCaseControl::MoveImages( + TReal32 aAmount, + TReal32 aTransitionTime ) + { + iPreviousViewportPosition = iViewportPosition; + iViewportPosition -= aAmount; + + if ( iViewportPosition < 0 ) + { + iViewportPosition = 0; + } + else if ( iViewportPosition > ( KNumberOfLinesInView - 1.0 ) ) + { + iViewportPosition = KNumberOfLinesInView - 1.0; + } + + iViewport->SetViewportPos( + TAlfRealPoint( 0, iViewportPosition ), + aTransitionTime ); + } + + +void CAlfPerfAppGalleryTestCaseControl::SetImageFocusL( const TDesC8& aImageTag ) + { + + //TODO: No checking if FindTag finds anything + CAlfImageVisual* visual = + static_cast( FindTag( aImageTag ) ); + + if( iFocusedVisual && iFocusedVisual->Brushes() ) + { + // TODO: At the moment, no checking of the brush type + CAlfBorderBrush* brush = + static_cast( &iFocusedVisual->Brushes()->At( 0 ) ); + iFocusedVisual->Brushes()->Remove( 0 ); + } + + if( visual ) + { + CAlfBorderBrush* actualBorder = CAlfBorderBrush::NewLC( Env(), 4, 4, 0, 0 ); + if(actualBorder) + { + actualBorder->SetColor( KRgbBlue ); + } + visual->EnableBrushesL( ETrue ); + visual->Brushes()->AppendL( actualBorder, EAlfHasOwnership ); + CleanupStack::Pop( actualBorder ); + } + + iFocusedVisual = visual; + } + +void CAlfPerfAppGalleryTestCaseControl::CompleteAfterL( TInt aDuration ) + { + // In order to use this service, base class StartExecuteL must + // have been called. + __ASSERT_ALWAYS( iStatus, User::Invariant() ); + + TAlfCustomEventCommand command( KAlfPerfAppGalleryCmdCompleteNow, this ); + User::LeaveIfError( Env().Send( command, aDuration ) ); + } + +void CAlfPerfAppGalleryTestCaseControl::CompleteNow( TInt aErrorCode ) + { + if ( iStatus ) + { + User::RequestComplete( iStatus, aErrorCode ); + iStatus = NULL; + } + } + +inline TInt CAlfPerfAppGalleryTestCaseControl::CaseId() const + { + return iCaseId; + } + +inline TBool CAlfPerfAppGalleryTestCaseControl::IsExecutionOngoing() const + { + return ( iStatus != NULL ); + } +