/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  CAlfPerfAppImageTestCase implementation.

*

*/

#include "alfperfappbasetestcasecontrol.h"

#include "alfperfappimagetestcase.h"

#include "alfperfapp.hrh"

#include "alfperfappconfigconstants.h"

#include <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>

#ifdef __NVG

    #include <alf/alfbitmapprovider.h>

#endif

#include <e32math.h>

#include <alfperfapp_imagetest.mbg>

/*

 * Square root of sequence length for the image sequence cases

 */

const TInt SEQUENCE_LENGTH_SQRT = 7;

/**

 * Control group for image test cases.

 */

const TInt KAlfPerfAppImageControlGroup = 1;

/**

 * Start next 'cycle' command.

 */

const TInt KAlfPerfAppImageCmdNext = 0x5001;

/**

 * Amount of image visuals.

 */

const TInt KAlfPerfAppImageTestCaseBasicImageCount = 16;

/**

 * Image data for test cases.

 */

_LIT( KAlfPerfAppImageTestCaseData, "\\resource\\apps\\alfperfapp_imagetest.mif" );

_LIT( KAlfPerfAppImageTestCaseNvgCSData, "\\resource\\apps\\alfperfapp_imagetest_NVGCS.mif" );

// NVG TLV Files have to be loaded from a certain place defined by icontype.cfg (in c:\ root)

_LIT( KAlfPerfAppImageTestCaseNvgTLVData, "\\data\\nvg_mif\\3musk.mif" );

#ifdef __NVG

// Enum that defines what icon (normal or NVG) is being used

// with the basic scale & movement test

enum TMoveScaleIcon

    {

    EMoveScaleIconMif = 0,

    EMoveScaleIconCS,

    EMoveScaleIconTLV

    };

#endif

/**

 * Basic image scale & movement test case.

 */

class CAlfPerfAppImageTestCaseBasic : public CAlfPerfAppBaseTestCaseControl

#ifdef __NVG

                                    , public MAlfBitmapProvider

#endif

    {

public:

    CAlfPerfAppImageTestCaseBasic();

    ~CAlfPerfAppImageTestCaseBasic();

    virtual void ConstructL( 

        CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea );      

    virtual void DoStartExecuteL();

    virtual TBool OfferEventL( const TAlfEvent& aEvent );

    virtual void SetVisibleArea( const TRect& aVisibleArea );    

#ifdef __NVG

    void SetIconType( TMoveScaleIcon aIconType );

#endif

private:

    /**

     * Next cycle.

     */

    void NextCycleL();

    /**

     * Returns opacity for index.

     */

    TReal32 OpacityForIndex( TInt aIndex );

    /**

     * Returns size for index.

     */

    TAlfRealSize SizeForIndex( TInt aIndex );

    /**

     * Returns position for index.

     */

    TAlfRealPoint PositionForIndex( TInt aIndex, const TAlfRealSize& aSize );

#ifdef __NVG

    void ProvideBitmapL(TInt aId, CFbsBitmap*& aBitmap, CFbsBitmap*& aMaskBitmap);

    CFbsBitmap* iBitmapToBeProvided;

    TMoveScaleIcon iIconType;

#endif

private:

    /**

     * Image visuals.

     */

    RPointerArray< CAlfImageVisual > iImages;

    /**

     * Cycle counter.

     */        

    TInt iCycleCounter;

    /**

     * Image loader utility.

     * Owned.

     */

    CAlfImageLoaderUtil* iLoader;

    };

/**

 * Many images at the same time

 */

#ifdef __NVG

class CAlfPerfAppImageTestCaseManyImages : public CAlfPerfAppBaseTestCaseControl, public MAlfBitmapProvider

#else

class CAlfPerfAppImageTestCaseManyImages : public CAlfPerfAppBaseTestCaseControl

#endif

    {

public:

    CAlfPerfAppImageTestCaseManyImages();

    ~CAlfPerfAppImageTestCaseManyImages();

    virtual void ConstructL( 

        CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea, TInt aSequenceIndex, TInt aVisualCount );      

    virtual void DoStartExecuteL();

    virtual TBool OfferEventL( const TAlfEvent& aEvent );

    virtual void SetVisibleArea( const TRect& aVisibleArea ); 

#ifdef __NVG

    void ProvideBitmapL(TInt /*aId*/, CFbsBitmap*& aBitmap, CFbsBitmap*& /*aMaskBitmap*/);

#endif

private:

    /**

     * Next cycle.

     */

    void NextCycleL();

    /**

     * Returns opacity for index.

     */

	TBool OpacityForIndex( TInt aIndex, TReal32& aOpacity );

    /**

     * Returns size for index.

     */

    TBool SizeForIndex( TInt aIndex, TAlfRealSize& aSize );

    /**

     * Returns position for index.

     */

    TBool PositionForIndex( TInt aIndex, TAlfRealPoint& aPos );

private:

#ifdef __NVG

    CFbsBitmap* iBitmapToBeProvided;

#endif

    /**

     * Image visuals.

     */

    RPointerArray< CAlfImageVisual > iImages;

    /**

     * Cycle counter.

     */        

    TInt iCycleCounter;

    /**

     * Image loader utility.

     * Owned.

     */

    CAlfImageLoaderUtil* iLoader;

    /**

     * Test case parameters

     */

    TInt iVisualCount; 				// Number of visual to be created

    TInt iVisualColums;

    TInt iVisualRows;

    TAlfRealPoint iVisualSpeed;    	// Pixels to move between cycles

    TFileName iImageFileName;		// File name of the texture image file	

	TInt iImageCount;				// Number of different images

	TSize iImageSize;				// Image size

    TAlfTextureFlags iTextureFlags;	// Texture flags	

    TAlfRealSize iVisualSize;		// Initial size of the visual

    TAlfRealPoint iVisualSizeVel; 	// Velocity of visual size change per cycle	

    TInt iSimulatedPointerEventCount; // Number of pointer events sent to visula in one cycle

    //TSize iAnimatedAreaSize;

    TInt iLastIndexInAnimatedArea;	// the index of the last visual that is animated, all before this are also animated

    TInt iSequenceIndex;

    };

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// Checks if specified case is supported by this class.

// -----------------------------------------------------------------------------

//

TBool CAlfPerfAppImageTestCase::IsSupported( TInt aCaseId )

    {

    return aCaseId > EAlfPerfAppImageMin && 

           aCaseId < EAlfPerfAppImageMax;

    }

CAlfPerfAppImageTestCase* CAlfPerfAppImageTestCase::NewL( TInt aCaseId, TInt aSequenceIndex )

    {

    if ( !IsSupported( aCaseId ) )

        {

        User::Leave( KErrNotSupported );

        }

    CAlfPerfAppImageTestCase* self = 

        new (ELeave) CAlfPerfAppImageTestCase( aCaseId, aSequenceIndex );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfPerfAppImageTestCase::~CAlfPerfAppImageTestCase()

    {

    if ( iEnv && iControl )

        {

        iControl->CancelExecution();

        iEnv->DeleteControlGroup( KAlfPerfAppImageControlGroup );

        }

    }

// -----------------------------------------------------------------------------

// Starts setup phase.

// -----------------------------------------------------------------------------

//

void CAlfPerfAppImageTestCase::SetupL( 

        CAlfEnv& aEnv, const TRect& aVisibleArea, TRequestStatus& aStatus )

    {

    iEnv = &aEnv;

    CAlfDisplay* display = 0;

    CAlfControlGroup& group = iEnv->NewControlGroupL( KAlfPerfAppImageControlGroup );

    CAlfPerfAppBaseTestCaseControl* control = 0;

    iTotalVisualCount = -1;

    iAnimationDivider = 0;

    if(SequenceIndex() != 0)

        {

        // Calculate 

        TInt caseNum = SEQUENCE_LENGTH_SQRT - (SequenceIndex()-1) / SEQUENCE_LENGTH_SQRT - 1;

        TReal trg = 0.0;

        Math::Pow(trg, 2.0, caseNum);

        iAnimationDivider = trg+0.5;

        TRect rect;

        AknLayoutUtils::LayoutMetricsRect( 

                AknLayoutUtils::EApplicationWindow, 

                rect );

        iEnv->SetFullScreenDrawing( ETrue );

        TInt counter = 10 - ((SequenceIndex()-1)%SEQUENCE_LENGTH_SQRT) - 1; // 2^3...2^9 always choose the 

        trg = 0.0;

        Math::Pow(trg, 2.0, counter);

        iTotalVisualCount = trg+0.5;

        display = &iEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayFullScreen );

        display->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground );

        control = new (ELeave) CAlfPerfAppImageTestCaseManyImages();

        CleanupStack::PushL( control );

        ((CAlfPerfAppImageTestCaseManyImages*)control)->ConstructL( *iEnv, iCaseId, aVisibleArea,SequenceIndex(),iTotalVisualCount );

        }

    else

        {

        display = &iEnv->NewDisplayL( aVisibleArea, CAlfEnv::ENewDisplayAsCoeControl);

        display->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground );

        switch ( iCaseId )

            {

            case EAlfPerfAppImageBasicMoveScale:

                control = new (ELeave) CAlfPerfAppImageTestCaseBasic;

                CleanupStack::PushL( control );

                control->ConstructL( *iEnv, iCaseId, aVisibleArea );

                break;

#ifdef __NVG

            case EAlfPerfAppImageBasicMoveScaleNvgCS:

                CAlfPerfAppImageTestCaseBasic* temp = new (ELeave) CAlfPerfAppImageTestCaseBasic;

                temp->SetIconType(EMoveScaleIconCS);

                control = temp;

                CleanupStack::PushL( control );

                control->ConstructL( *iEnv, iCaseId, aVisibleArea);

                break;

            case EAlfPerfAppImageBasicMoveScaleNvgTLV:

                CAlfPerfAppImageTestCaseBasic* temp2 = new (ELeave) CAlfPerfAppImageTestCaseBasic;

                temp2->SetIconType(EMoveScaleIconTLV); 

                control = temp2;

                CleanupStack::PushL( control );

                control->ConstructL( *iEnv, iCaseId, aVisibleArea);

                break;

            case EAlfPerfAppImageManyNvgCSImages:

            case EAlfPerfAppImageManyNvgTLVImages:

#endif

            case EAlfPerfAppImageManyImages:

            case EAlfPerfAppImageManyGifImages:

            case EAlfPerfAppImageManyPngImages:

            case EAlfPerfAppImageManySvgImages:

            case EAlfPerfAppImageManyImagesWithPointerEvent:

            case EAlfPerfAppImageManyImagesWithAutoSize:

            case EAlfPerfAppImageAnimateFull:

            case EAlfPerfAppImageAnimate1of2:

            case EAlfPerfAppImageAnimate1of4:

            case EAlfPerfAppImageAnimate1of8:

                control = new (ELeave) CAlfPerfAppImageTestCaseManyImages;

    			CleanupStack::PushL( control );

    			((CAlfPerfAppImageTestCaseManyImages*)control)->ConstructL( *iEnv, iCaseId, aVisibleArea,SequenceIndex(),iTotalVisualCount );

                break;

            default:

                User::Leave( KErrNotSupported );

                break;

            }

        }

    group.AppendL( control ); // ownership passed to control group.

    iControl = control;

    CleanupStack::Pop( control );    

    display->Roster().ShowL( group );

    // This must be last statement.

    CAlfPerfAppTestCase::CompleteNow( aStatus, KErrNone );

    }

// -----------------------------------------------------------------------------

// Starts execution phase.

// -----------------------------------------------------------------------------

//

void CAlfPerfAppImageTestCase::ExecuteL( TRequestStatus& aStatus )

    {

    // SetupL must have been called first.

    __ASSERT_ALWAYS( iEnv, User::Invariant() );

    __ASSERT_ALWAYS( iControl, User::Invariant() );

    iControl->StartExecuteL( aStatus );

    }

// -----------------------------------------------------------------------------

// Tears down.

// -----------------------------------------------------------------------------

//

void CAlfPerfAppImageTestCase::TearDown()

    {

    // Execution side will delete CAlfEnv, so it will delete everything

    // related to this.

    iEnv = NULL;

    iControl = NULL;

    }

void CAlfPerfAppImageTestCase::HandleVisibleAreaChange( const TRect& aRect )

    {

    if ( iEnv && iControl )

        {

        if ( iEnv->DisplayCount() > 0 )

            {

            iEnv->PrimaryDisplay().SetVisibleArea( aRect );

            }

        iControl->SetVisibleArea( aRect );

        }

    }

TInt CAlfPerfAppImageTestCase::CaseID()

    {

    return iCaseId;

    }

CAlfPerfAppImageTestCase::CAlfPerfAppImageTestCase( TInt aCaseId, TInt aSequenceIndex )

    : CAlfPerfAppTestCase(aSequenceIndex), iCaseId ( aCaseId )

    {

    }

void CAlfPerfAppImageTestCase::ConstructL()

    {

    }

// Implementation of CAlfPerfAppImageTestCaseBasic:

#ifdef __NVG

CAlfPerfAppImageTestCaseBasic::CAlfPerfAppImageTestCaseBasic(): iIconType(EMoveScaleIconMif)

#else

CAlfPerfAppImageTestCaseBasic::CAlfPerfAppImageTestCaseBasic()

#endif

    {

    }

CAlfPerfAppImageTestCaseBasic::~CAlfPerfAppImageTestCaseBasic()

    {

    iImages.Close();

    delete iLoader;

    }

void CAlfPerfAppImageTestCaseBasic::ConstructL( 

        CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea )

    {

    CAlfPerfAppBaseTestCaseControl::ConstructL( aEnv, aCaseId, aVisibleArea );

    CAlfTextureManager& textureManager = aEnv.TextureManager();

    iLoader = new (ELeave) CAlfImageLoaderUtil;

    iLoader->SetSize( TSize( 64, 64 ) );

    const TInt max = 4;

    TInt count = 0;

    TInt baseId = 16384;

    TFileName imageFile;

#ifdef __NVG

    TBool isNvg = EFalse;

    if (iIconType == EMoveScaleIconCS)

        {

        imageFile.Append( KAlfPerfAppImageTestCaseNvgCSData );

        isNvg = ETrue;

        }

    else if (iIconType == EMoveScaleIconTLV)

        {

        imageFile.Append( KAlfPerfAppImageTestCaseNvgTLVData );

        isNvg = ETrue;

        }

    else if (iIconType == EMoveScaleIconMif)

        {

        imageFile.Append( KAlfPerfAppImageTestCaseData );

        }

    else

        {

        // Error! Leave

        User::Leave(KErrArgument);

        }

    // Add the drive letter to the imageFile path

    ::CompleteWithAppPath( imageFile );

#else

    imageFile.Append( KAlfPerfAppImageTestCaseData );

    ::CompleteWithAppPath( imageFile );

#endif

    while ( count < max && baseId < EMbmAlfperfapp_imagetestLastElement )

        {

#ifdef __NVG

        if (isNvg)

            {

            TAlfTextureFlags flags = EAlfTextureFlagDefault;

            // Use the modified AknIconUtils to create the extended bitmap

            CFbsBitmap* extendedBitmap;

            CFbsBitmap* extendedMask;

            if(iIconType == EMoveScaleIconTLV)

                {

                // The TLV icon file has only one icon

                AknIconUtils::CreateIconL(extendedBitmap, extendedMask, imageFile, 16384, 16385);

                }

            else

                {

                AknIconUtils::CreateIconL(extendedBitmap, extendedMask, imageFile, baseId, baseId + 1);

                }

            AknIconUtils::ExcludeFromCache(extendedBitmap);

            AknIconUtils::SetSize( extendedBitmap, TSize(64,64) );

            // This will be returned, when ProvideBitmapL is called for creating the texture

            //delete iBitmapToBeProvided;

            iBitmapToBeProvided = extendedBitmap;

            delete extendedMask;

            count++;

            textureManager.CreateTextureL(count, this, flags);

            }

        else

            {

            // Else load the icons normally from the mif file

            count++;

            textureManager.CreateTextureL(

                count,

                iLoader->CreateImageLoaderL(

                    KAknsIIDNone,