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


#include "alfperfappbasetestcasecontrol.h"
#include "alfperfapplayouttestcase.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/alfgridlayout.h>
#include <alf/alfcurvepathlayout.h>
#include <alf/alfdecklayout.h>
#include <alf/alfflowlayout.h>
#include <alf/alfanchorlayout.h>
#include <alf/alfviewportlayout.h>

#include <alfperfapp_imagetest.mbg>

/**
 * Control group for test cases.
 */
const TInt KAlfPerfAppLayoutControlGroup = 1;

/**
 * Start next 'cycle' command.
 */
const TInt KAlfPerfAppLayoutCmdNext = 0x5001;

/**
 * Testing layouts
 */
class CAlfPerfAppLayoutTestCaseControl : public CAlfPerfAppBaseTestCaseControl
    {
public:
    CAlfPerfAppLayoutTestCaseControl();
    ~CAlfPerfAppLayoutTestCaseControl();
    
    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();
         
private:
    /**
     * Test case of which execution this instance was created.
     */ 
    TInt iCaseId;
    
    /**
     * Image visuals.
     */
    RPointerArray< CAlfImageVisual > iImages;
        
    /**
     * Cycle counter.
     */        
    TInt iCycleCounter;
    
    /**
     * Image loader utility.
     * Owned.
     */
    CAlfImageLoaderUtil* iLoader;
    
    
    /**
     * Main layout
     * Owned.
     */
    CAlfLayout* iLayout;
    
    /**
     * Test case parameters
     */
    TInt iVisualCount; 				// Number of visual to be created
    TFileName iImageFileName;		// File name of the texture image file	
	TInt iImageCount;				// Number of different images
    TAlfTextureFlags iTextureFlags;	// Texture flags	
    TAlfRealSize iVisualSize;		// Initial size of the visual
    };
        
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// Checks if specified case is supported by this class.
// -----------------------------------------------------------------------------
//
TBool CAlfPerfAppLayoutTestCase::IsSupported( TInt aCaseId )
    {
    return aCaseId > EAlfPerfAppLayoutMin && 
           aCaseId < EAlfPerfAppLayoutMax;
    }

CAlfPerfAppLayoutTestCase* CAlfPerfAppLayoutTestCase::NewL( TInt aCaseId, TInt aSequenceIndex )
    {
    if ( !IsSupported( aCaseId ) )
        {
        User::Leave( KErrNotSupported );
        }

    CAlfPerfAppLayoutTestCase* self = 
        new (ELeave) CAlfPerfAppLayoutTestCase( aCaseId, aSequenceIndex);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

CAlfPerfAppLayoutTestCase::~CAlfPerfAppLayoutTestCase()
    {
    if ( iEnv && iControl )
        {
        iControl->CancelExecution();
        iEnv->DeleteControlGroup( KAlfPerfAppLayoutControlGroup );
        }
    }

// -----------------------------------------------------------------------------
// Starts setup phase.
// -----------------------------------------------------------------------------
//
void CAlfPerfAppLayoutTestCase::SetupL( 
        CAlfEnv& aEnv, const TRect& aVisibleArea, TRequestStatus& aStatus )
    {
    iEnv = &aEnv;
    
    CAlfDisplay& display = 
        iEnv->NewDisplayL( aVisibleArea, CAlfEnv::ENewDisplayAsCoeControl );
    display.SetClearBackgroundL( CAlfDisplay::EClearWithSkinBackground );

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

    CAlfPerfAppBaseTestCaseControl* control = NULL;
    
    switch ( iCaseId )
        {
        case EAlfPerfAppLayoutGrid:
        case EAlfPerfAppLayoutDeck:
        case EAlfPerfAppLayoutAnchor:
        case EAlfPerfAppLayoutCurvePath:
        case EAlfPerfAppLayoutFlow:
        case EAlfPerfAppLayoutViewport:
            control = new (ELeave) CAlfPerfAppLayoutTestCaseControl;
            break;
                        
        default:
            User::Leave( KErrNotSupported );
            break;
        }
        
    CleanupStack::PushL( control );
    control->ConstructL( *iEnv, iCaseId, aVisibleArea );
    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 CAlfPerfAppLayoutTestCase::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 CAlfPerfAppLayoutTestCase::TearDown()
    {
    // Execution side will delete CAlfEnv, so it will delete everything
    // related to this.
    iEnv = NULL;
    iControl = NULL;
    }

void CAlfPerfAppLayoutTestCase::HandleVisibleAreaChange( const TRect& aRect )
    {
    if ( iEnv && iControl )
        {
        if ( iEnv->DisplayCount() > 0 )
            {
            iEnv->PrimaryDisplay().SetVisibleArea( aRect );
            }
        iControl->SetVisibleArea( aRect );
        }
    }
 
TInt CAlfPerfAppLayoutTestCase::CaseID()
    {
    return iCaseId;
    }

CAlfPerfAppLayoutTestCase::CAlfPerfAppLayoutTestCase( TInt aCaseId, TInt aSequenceIndex )
    : CAlfPerfAppTestCase(aSequenceIndex), iCaseId ( aCaseId )
    {
    }

void CAlfPerfAppLayoutTestCase::ConstructL()
    {
    }


// Implementation of CAlfPerfAppLayoutTestCaseControl:

CAlfPerfAppLayoutTestCaseControl::CAlfPerfAppLayoutTestCaseControl()
    {
    }

CAlfPerfAppLayoutTestCaseControl::~CAlfPerfAppLayoutTestCaseControl()
    {
    iImages.Close();
    
    delete iLoader;
    }
    
void CAlfPerfAppLayoutTestCaseControl::ConstructL( 
        CAlfEnv& aEnv, TInt aCaseId, const TRect& aVisibleArea )
    {
    CAlfPerfAppBaseTestCaseControl::ConstructL( aEnv, aCaseId, aVisibleArea );
    
    // Parameters for test cases
    TSize gridSize 			= TSize(10,10); // Total count should be equal to iVisualCount
    iImageFileName 			= _L("c:\\data\\others\\alfperfapp_imagetest.png");	
	iImageCount 			= 4;
    iVisualCount 			= 100;	
    iTextureFlags 			= EAlfTextureFlagDefault;	
	iVisualSize				= TAlfRealSize( 25.f, 25.f );

    switch(CaseId())
    	{
        case EAlfPerfAppLayoutGrid:
    		iLayout = CAlfGridLayout::AddNewL(*this, gridSize.iWidth, gridSize.iHeight);
        	break;
       
        case EAlfPerfAppLayoutDeck:
    		iLayout = CAlfDeckLayout::AddNewL(*this);
        	break;
       
        case EAlfPerfAppLayoutAnchor:
            iLayout = CAlfAnchorLayout::AddNewL(*this);  
        	break;
       
        case EAlfPerfAppLayoutCurvePath:
        	iLayout = CAlfCurvePathLayout::AddNewL(*this);
        	break;
       
        case EAlfPerfAppLayoutFlow:
        	iLayout = CAlfFlowLayout::AddNewL(*this);
        	break;
       
        case EAlfPerfAppLayoutViewport:
        	iLayout = CAlfViewportLayout::AddNewL(*this);
        	break;
       	
    	default:
            User::Leave( KErrNotSupported );
            break;
 		};
    


	// Create grid layout
	
    CAlfTextureManager& textureManager = aEnv.TextureManager();
    
	   
    TParsePtr parse(iImageFileName);
    	
    for ( TInt count = 0;  count < iImageCount; count++ )
        {        
        CAlfTexture& texture = textureManager.LoadTextureL(iImageFileName, iTextureFlags, count+1);
        }   
       	
 	for ( TInt ii = 0; ii < iVisualCount; ii++ )
        {
        CAlfImageVisual* visual = CAlfImageVisual::AddNewL( *this,  iLayout);
        iImages.AppendL( visual );        
        visual->SetSize( iVisualSize );
        }
    
   	iLayout->UpdateChildrenLayout();
    }
    
void CAlfPerfAppLayoutTestCaseControl::DoStartExecuteL()
    {
    NextCycleL();
    // Complete after one cycle
    CompleteNow( KErrNone );
    }

void CAlfPerfAppLayoutTestCaseControl::SetVisibleArea( 
        const TRect& /*aVisibleArea*/ )
    {
    if ( IsExecutionOngoing() )
        {
        Env().CancelCustomCommands( this, KAlfPerfAppLayoutCmdNext );
        TRAPD( err, NextCycleL() );
        if ( err != KErrNone )
            {
            CompleteNow( err );
            }
        }
    }

TBool CAlfPerfAppLayoutTestCaseControl::OfferEventL( const TAlfEvent& aEvent )
    {
    if ( aEvent.IsCustomEvent() && 
         aEvent.CustomParameter() == KAlfPerfAppLayoutCmdNext )
        {
        TRAPD( err, NextCycleL() );
        if ( err != KErrNone )
            {
            CompleteNow( err );
            }
        return ETrue;
        }
    
    return CAlfPerfAppBaseTestCaseControl::OfferEventL( aEvent );
    }

void CAlfPerfAppLayoutTestCaseControl::NextCycleL()
    {
    TAlfCustomEventCommand command( KAlfPerfAppLayoutCmdNext, this );
    User::LeaveIfError( Env().Send( command, 500 ) );
    
    iCycleCounter++;
    
    for(TInt i=0; i<10; i++)
    	{
   		iLayout->UpdateChildrenLayout();
   		}
    }