/*

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