/*

* 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:  CAlfPerfApptextTestCase implementation.

 *

*/

#include "alfperfappbasetestcasecontrol.h"

#include "alfperfapptexttestcase.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/alftextvisual.h>

#include <alf/alfimageloaderutil.h>

#include <alf/alfutil.h>

#include <e32math.h>

//#include <alfperfapp_texttest.mbg>

/**

 * Control group for Text test cases.

 */

const TInt KAlfPerfAppTextControlGroup = 1;

/*

 * Square root of sequence length for the image sequence cases

 */

const TInt SEQUENCE_LENGTH_SQRT = 7;

/**

 * Start next 'cycle' command.

 */

const TInt KAlfPerfAppTextCmdNext = 0x5001;

/**

 * Amount of text visuals.

 */

const TInt KAlfPerfAppTextTestCaseBasicTextCount = 16;

/**

 * Basic Text scale & movement test case.

 */

class CAlfPerfAppTextTestCaseBasic : public CAlfPerfAppBaseTestCaseControl

    {

public:

    CAlfPerfAppTextTestCaseBasic();

    ~CAlfPerfAppTextTestCaseBasic();

    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 );    

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 );

private:

    /**

     * Test case of which execution this instance was created.

     */ 

    TInt iCaseId;

    /**

     * Text visuals.

     */

    RPointerArray< CAlfTextVisual > iTexts;

    /**

     * Cycle counter.

     */        

    TInt iCycleCounter;

    };

/**

 * Many texts at the same time

 */

class CAlfPerfAppTextTestCaseManyTexts : public CAlfPerfAppBaseTestCaseControl

    {

public:

    CAlfPerfAppTextTestCaseManyTexts();

    ~CAlfPerfAppTextTestCaseManyTexts();

    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 );    

    TTestCaseSpecificResultText getResultL();

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.

     */

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

private:

    /**

     * Text visuals.

     */

    RPointerArray< CAlfTextVisual > iTexts;

    /**

     * Cycle counter.

     */        

    TInt iCycleCounter;

    /**

     * 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 text file	

    TInt iTextCount;				// Number of different texts

    //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

    TUint32 iPointerEventTime;      //Time to handle pointer event 

    TBool iInactiveVisual;

    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 CAlfPerfAppTextTestCase::IsSupported( TInt aCaseId )

    {

    return aCaseId > EAlfPerfAppTextMin && 

    aCaseId < EAlfPerfAppTextMax;

    }

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

    {

    if ( !IsSupported( aCaseId ) )

        {

        User::Leave( KErrNotSupported );

        }

    CAlfPerfAppTextTestCase* self = 

    new (ELeave) CAlfPerfAppTextTestCase( aCaseId, aSequenceIndex );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfPerfAppTextTestCase::~CAlfPerfAppTextTestCase()

    {

    if ( iEnv && iControl )

        {

        iControl->CancelExecution();

        iEnv->DeleteControlGroup( KAlfPerfAppTextControlGroup );

        }

    }

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

// Starts setup phase.

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

//

void CAlfPerfAppTextTestCase::SetupL( 

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

    {

    iEnv = &aEnv;

    // Init display, fullscreen if in sequence case mode

    CAlfDisplay* display = 0;

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

    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) CAlfPerfAppTextTestCaseManyTexts();

          CleanupStack::PushL( control );

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

          }

    else

        {

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

        display->SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground );

        switch ( iCaseId )

            {

            case EAlfPerfAppTextBasicMoveScale:

                control = new (ELeave) CAlfPerfAppTextTestCaseBasic;

                CleanupStack::PushL( control );

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

                break;

            case EAlfPerfAppTextManyTexts:

            case EAlfPerfAppTextManyTextsWithPointerEvent:

            case EAlfPerfAppTextManyTextsWithAutoSize:

            case EAlfPerfAppTextInactiveVisuals:

                control = new (ELeave) CAlfPerfAppTextTestCaseManyTexts;

                CleanupStack::PushL( control );

                ((CAlfPerfAppTextTestCaseManyTexts*)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 CAlfPerfAppTextTestCase::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 CAlfPerfAppTextTestCase::TearDown()

    {

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

    // related to this.

    iEnv = NULL;

    iControl = NULL;

    }

void CAlfPerfAppTextTestCase::HandleVisibleAreaChange( const TRect& aRect )

    {

    if ( iEnv && iControl )

        {

        if ( iEnv->DisplayCount() > 0 )

            {

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

            }

        iControl->SetVisibleArea( aRect );

        }

    }

TInt CAlfPerfAppTextTestCase::CaseID()

    {

    return iCaseId;

    }

CAlfPerfAppTextTestCase::CAlfPerfAppTextTestCase( TInt aCaseId, TInt aSequenceIndex )

: CAlfPerfAppTestCase(aSequenceIndex), iCaseId ( aCaseId )

        {

        }

void CAlfPerfAppTextTestCase::ConstructL()

    {

    }

// Implementation of CAlfPerfAppTextTestCaseBasic:

CAlfPerfAppTextTestCaseBasic::CAlfPerfAppTextTestCaseBasic()

    {

    }

CAlfPerfAppTextTestCaseBasic::~CAlfPerfAppTextTestCaseBasic()

    {

    iTexts.Close();

    }

void CAlfPerfAppTextTestCaseBasic::ConstructL( 

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

    {

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

    for ( TInt ii = 0; ii < KAlfPerfAppTextTestCaseBasicTextCount; ii++ )

        {

        CAlfTextVisual* visual = CAlfTextVisual::AddNewL( *this );

        visual->SetFlag( EAlfVisualFlagManualLayout );

        visual->SetOpacity( 1.0f );

        visual->SetOpacity( OpacityForIndex( ii ) );

        TAlfRealSize sz = SizeForIndex( ii );

        visual->SetSize( sz );

        visual->SetPos( PositionForIndex( ii, sz ) );

        visual->SetTextL(_L("Text"));

        iTexts.AppendL( visual );

        }

    }

void CAlfPerfAppTextTestCaseBasic::DoStartExecuteL()

    {

    NextCycleL();

    CompleteAfterL( 5000 );

    }

void CAlfPerfAppTextTestCaseBasic::SetVisibleArea( 

        const TRect& /*aVisibleArea*/ )

    {

    if ( IsExecutionOngoing() )

        {

        Env().CancelCustomCommands( this, KAlfPerfAppTextCmdNext );

        TRAPD( err, NextCycleL() );

        if ( err != KErrNone )

            {

            CompleteNow( err );

            }

        }

    }

TBool CAlfPerfAppTextTestCaseBasic::OfferEventL( const TAlfEvent& aEvent )

    {

    if ( aEvent.IsCustomEvent() && 

            aEvent.CustomParameter() == KAlfPerfAppTextCmdNext )

        {

        TRAPD( err, NextCycleL() );

        if ( err != KErrNone )

            {

            CompleteNow( err );

            }

        return ETrue;

        }

    return CAlfPerfAppBaseTestCaseControl::OfferEventL( aEvent );

    }

void CAlfPerfAppTextTestCaseBasic::NextCycleL()

    {

    TAlfCustomEventCommand command( KAlfPerfAppTextCmdNext, this );

    User::LeaveIfError( Env().Send( command, 500 ) );

    iCycleCounter++;

    for ( TInt ii = 0; ii < iTexts.Count(); ii++ )

        {

        CAlfTextVisual* visual = iTexts[ ii ];

        TInt speed = KVisualAnimSpeed;

        if ( ii & 1 )

            {

            speed /= 2;

            }

        visual->SetOpacity( TAlfTimedValue( OpacityForIndex( ii ), speed ) );

        TAlfRealSize sz = SizeForIndex( ii );

        visual->SetSize( sz, speed );

        visual->SetPos( PositionForIndex( ii, sz ), speed );                                    

        }

    }

TReal32 CAlfPerfAppTextTestCaseBasic::OpacityForIndex( TInt aIndex )

    {

    switch ( ( iCycleCounter + aIndex ) % 3 ) 

        {

        case 0:

            return 1.0f;

        case 1:

            return 0.5f;

        case 2:

        default:

            return 0.25f;

        }

    }

TAlfRealSize CAlfPerfAppTextTestCaseBasic::SizeForIndex( TInt aIndex )

    {

    switch ( ( iCycleCounter + aIndex ) % 3 ) 

        {

        case 0:

            return TAlfRealSize( 25.f, 25.f );

        case 1:

            return TAlfRealSize( 50.f, 50.f );

        case 2:

        default:

            return TAlfRealSize( 100.f, 100.f );

        }

    }

TAlfRealPoint CAlfPerfAppTextTestCaseBasic::PositionForIndex( 

        TInt aIndex, const TAlfRealSize& aSize )

    {

    const TSize KSize( Env().PrimaryDisplay().VisibleArea().Size() );

    switch ( ( iCycleCounter + aIndex ) & 3 )

        {

        case 0:

            return TAlfRealPoint( 0.0f, 0.0f ); 

        case 1:

            return TAlfRealPoint( KSize.iWidth - aSize.iWidth, KSize.iHeight - aSize.iHeight ); 

        case 2:

            return TAlfRealPoint( KSize.iWidth - aSize.iWidth, 0.0f ); 

        case 3:

        default:

            return TAlfRealPoint( 0.0f, KSize.iHeight - aSize.iHeight ); 

        }

    }

// Implementation of CAlfPerfAppTextTestCaseManyTexts:

CAlfPerfAppTextTestCaseManyTexts::CAlfPerfAppTextTestCaseManyTexts()

    {

    }

CAlfPerfAppTextTestCaseManyTexts::~CAlfPerfAppTextTestCaseManyTexts()

    {

    iTexts.Close();

    //delete iLoader;

    }

void CAlfPerfAppTextTestCaseManyTexts::ConstructL( 

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

    {

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

    CAlfTextureManager& textureManager = aEnv.TextureManager();

    // Parameters for test cases

    iVisualSpeed 			= TAlfRealPoint(1,0); 	

    iTextCount 			= 4;

    iVisualCount            = (aVisualCount != -1) ? aVisualCount : KVisualCout;    

    iVisualSize				= TAlfRealSize( 25.f, 25.f );

    iVisualSizeVel			= TAlfRealPoint();	

    iSimulatedPointerEventCount = 0;

    iLastIndexInAnimatedArea    = 0;

    iSequenceIndex = aSequenceIndex;

    iPointerEventTime           = 0;