/*

* 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 <aknutils.h>

#include <alf/alfenv.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/alfimageloaderutil.h>

#include <alf/alfutil.h>

#include <alf/alflayout.h>

#include <alf/alfviewportlayout.h>

#include <alf/alfgridlayout.h>

#include <alf/alftransformation.h>

#include <alf/alfgradientbrush.h>

#include <alf/alfimagebrush.h>

#include <alf/alftextvisual.h>

#include <alf/alfbrusharray.h>

#include <alf/alfshadowborderbrush.h>

#include <alf/alfdecklayout.h>

#include <alf/alflayout.h>

#include <alf/alfborderbrush.h>

#include <alfperfapp_imagetest.mbg>

/**

 * 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<TDesC> iImageCaptions;

	RPointerArray<TDesC8> 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,