diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfapptexttestcase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfapptexttestcase.cpp	Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,802 @@
+/*
+* 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;
+    iInactiveVisual         = EFalse;   
+    iVisualColums           = 0;
+    iVisualRows             = 0;
+
+    if(aSequenceIndex != 0)
+        {
+        TInt caseNum = SEQUENCE_LENGTH_SQRT - (iSequenceIndex-1) / SEQUENCE_LENGTH_SQRT - 1;
+        TReal trg = 0.0;
+        Math::Pow(trg, 2.0, caseNum);
+        TInt pow = trg+0.5;
+        TReal animatedAreaRelativeSize = 1.f/pow;
+
+        iLastIndexInAnimatedArea = iVisualCount*animatedAreaRelativeSize+0.5;
+        iLastIndexInAnimatedArea = (iLastIndexInAnimatedArea < 1) ? 1 : iLastIndexInAnimatedArea;
+
+        trg = 0.0;
+        Math::Sqrt(trg,TReal(iVisualCount));
+        iVisualColums = (trg + 0.5);
+        iVisualRows = ((TReal)iVisualCount/iVisualColums) + 0.5;
+
+        TSize displaySize(Env().PrimaryDisplay().VisibleArea().Size());
+        iVisualSize = TAlfRealSize((TReal32)displaySize.iWidth/iVisualColums, (TReal32)displaySize.iHeight/iVisualRows);
+        }
+    else
+        {
+        switch(CaseId())
+            {
+            case EAlfPerfAppTextManyTexts:
+                break;
+
+            case EAlfPerfAppTextManyTextsWithPointerEvent:
+                iSimulatedPointerEventCount = 10;
+                break;
+
+            case EAlfPerfAppTextManyTextsWithAutoSize:
+                iVisualSizeVel = TAlfRealPoint(10,10);
+                break;
+                //To set all but 2 visuals Inactive, 
+                //i.e. those will not participate in any of roster operations
+            case EAlfPerfAppTextInactiveVisuals:
+                iInactiveVisual = ETrue;
+                iSimulatedPointerEventCount = 100;
+                break;
+            default:
+                User::Leave( KErrNotSupported );
+                break;
+            };
+        }
+
+    for ( TInt ii = 0; ii < iVisualCount; ii++ )
+        {
+        CAlfTextVisual* visual = CAlfTextVisual::AddNewL( *this );
+        iTexts.AppendL( visual );        
+
+        visual->SetFlag( EAlfVisualFlagManualLayout );
+        visual->SetOpacity( 1.0f );
+
+        visual->SetOpacity( OpacityForIndex( ii ) );
+        visual->SetSize( iVisualSize );
+
+        TAlfRealPoint pos(0,0);
+        if (PositionForIndex( ii, pos, iVisualSize ))
+            {
+            visual->SetPos( pos );                                    
+            }
+
+        visual->SetTextL( _L("TEXT"));
+#ifdef ALFPERFAPP_ENABLE_INACTIVE_FLAG_CASES
+        if ( iInactiveVisual && ii < iVisualCount-2 )
+            {
+            visual->SetFlag( EAlfVisualFlagInactive );
+            }
+#endif
+        }
+    }
+
+void CAlfPerfAppTextTestCaseManyTexts::DoStartExecuteL()
+    {
+    NextCycleL();
+
+    CompleteAfterL( 5000 );
+    }
+
+void CAlfPerfAppTextTestCaseManyTexts::SetVisibleArea( 
+        const TRect& /*aVisibleArea*/ )
+    {
+    if ( IsExecutionOngoing() )
+        {
+        Env().CancelCustomCommands( this, KAlfPerfAppTextCmdNext );
+        TRAPD( err, NextCycleL() );
+        if ( err != KErrNone )
+            {
+            CompleteNow( err );
+            }
+        }
+    }
+
+TBool CAlfPerfAppTextTestCaseManyTexts::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 CAlfPerfAppTextTestCaseManyTexts::NextCycleL()
+    {
+    TAlfCustomEventCommand command( KAlfPerfAppTextCmdNext, this );
+    User::LeaveIfError( Env().Send( command, 500 ) );
+
+    iCycleCounter++;
+
+    // Update cycle state
+    for ( TInt ii = 0; ii < iTexts.Count(); ii++ )
+        {
+        CAlfTextVisual* visual = iTexts[ ii ];
+
+        TInt speed = KVisualAnimSpeed;
+
+        visual->SetOpacity( TAlfTimedValue( OpacityForIndex( ii ), speed ) );
+        TAlfRealSize sz = SizeForIndex( ii );
+        visual->SetSize( sz, speed );
+        
+        TAlfRealPoint pos(0,0);
+        if (PositionForIndex( ii, pos, iVisualSize ))
+            {
+            visual->SetPos( pos,speed );                                    
+            }
+        }
+    if ( iSimulatedPointerEventCount )
+        {
+        TInt tickPeriod1;    
+        tickPeriod1 = User::TickCount();
+        while( (User::TickCount() - tickPeriod1) ==0 ) ; // wait for a tick rollover
+
+        // Send pointer events    
+        for (TInt i=0; i <iSimulatedPointerEventCount; i++)
+            {
+            const TSize KSize( Env().PrimaryDisplay().VisibleArea().Size() );
+
+            TPoint pos(AlfUtil::RandomInt(0, KSize.iWidth-1), AlfUtil::RandomInt(0, KSize.iWidth-1));
+
+            // down
+            TPointerEvent eventDown(TPointerEvent::EButton1Down, 0, pos, TPoint(0,0));
+            Env().PrimaryDisplay().HandlePointerEventL( eventDown );
+
+            //up
+            TPointerEvent eventUp(TPointerEvent::EButton1Up, 0, pos, TPoint(0,0));
+            Env().PrimaryDisplay().HandlePointerEventL( eventUp );
+            }          
+        TInt tickPeriod2 = User::TickCount();
+        iPointerEventTime = iPointerEventTime + ( tickPeriod2 - tickPeriod1 );
+        }        
+    }
+
+TReal32 CAlfPerfAppTextTestCaseManyTexts::OpacityForIndex( TInt aIndex )
+    {
+    
+    if (iSequenceIndex != 0 && aIndex <= iLastIndexInAnimatedArea)
+        {
+        if (iCycleCounter&0x01)
+            {
+            return 0.7f;
+            }
+        else
+            {
+            return 0.9f;
+            }
+        }
+    return 0.5f;
+    }
+
+TAlfRealSize CAlfPerfAppTextTestCaseManyTexts::SizeForIndex( TInt aIndex )
+    {
+    TAlfRealSize size = iTexts[ aIndex ]->Size().Target();
+    return TAlfRealSize( size.iWidth + iVisualSizeVel.iX, size.iHeight + iVisualSizeVel.iY );
+    }
+
+TBool CAlfPerfAppTextTestCaseManyTexts::PositionForIndex( 
+        TInt aIndex, TAlfRealPoint& aPos, const TAlfRealSize& /*aSize*/ )
+    {
+    
+    if (iSequenceIndex != 0)       
+        {
+        if(iCycleCounter == 0 || aIndex <= iLastIndexInAnimatedArea)
+            {
+            TInt gridIndex = aIndex + iCycleCounter;
+            TInt columnPos = gridIndex % iVisualColums;
+            TInt rowPos = gridIndex / iVisualColums;
+            rowPos = rowPos % iVisualRows; 
+            //TAlfRealSize visualSize = iImages[ aIndex ]->Size().Target();
+            aPos = TAlfRealPoint( columnPos*iVisualSize.iWidth, rowPos*iVisualSize.iHeight );           
+            return ETrue;
+            }
+        else
+            {
+            return EFalse;
+            }
+        }
+    
+
+
+    TInt KItemStep = 20;
+    const TSize KSize( Env().PrimaryDisplay().VisibleArea().Size() );
+    const TSize KSize2( KSize.iWidth/KItemStep, KSize.iHeight/KItemStep);
+
+    TInt pos = aIndex + iCycleCounter * iVisualSpeed.iX;
+    TInt ypos = pos / KSize2.iWidth; 
+    ypos = ypos % KSize2.iHeight; 
+    TInt xpos = pos % KSize2.iWidth; 
+    aPos =  TAlfRealPoint( xpos*KItemStep, ypos*KItemStep );
+    return ETrue;
+    }
+//Write pointer event lag result 
+TTestCaseSpecificResultText CAlfPerfAppTextTestCase::getCaseSpecificResultL()
+    {
+    if(SequenceIndex() != 0 && CaseID() == EAlfPerfAppTextManyTexts)
+        {
+        TTestCaseSpecificResultText result = HBufC::NewL(KAlfPerfAppMaxCharsInSpecificResultText);
+        result->Des().Append(_L("Total Visual Count: "));
+        result->Des().AppendNum(iTotalVisualCount);
+        result->Des().Append(_L(" Animated: 1/"));
+        result->Des().AppendNum(iAnimationDivider);
+        return result;
+        }
+    
+    if(iCaseId == EAlfPerfAppTextManyTextsWithPointerEvent ||
+            iCaseId == EAlfPerfAppTextInactiveVisuals)
+        {
+        if ( iControl)
+            {
+            return static_cast<CAlfPerfAppTextTestCaseManyTexts*>(iControl)->getResultL();
+            }
+        }
+    // If nothing was done before this, return empty result
+    TTestCaseSpecificResultText emptyResult = 0;
+    return emptyResult;
+    }
+
+TTestCaseSpecificResultText CAlfPerfAppTextTestCaseManyTexts::getResultL()
+    {
+    TTestCaseSpecificResultText result = 0; 
+    if ( iSimulatedPointerEventCount )
+        { 
+        //Assuming tic period to be 1 ms 
+        if(iPointerEventTime && iCycleCounter)
+            {
+            iPointerEventTime = ((iPointerEventTime/iCycleCounter)*1000)/(iSimulatedPointerEventCount*2);
+            }
+        if(iPointerEventTime)
+            {
+            result = HBufC::NewL(KAlfPerfAppMaxCharsInSpecificResultText);
+            if ( iInactiveVisual )
+                {
+                result->Des().Append(_L("Inactive Visual "));      		
+                }
+            result->Des().Append(_L("Avg Pointer event lag: "));
+            result->Des().AppendNum( iPointerEventTime );
+            result->Des().Append(_L("ms"));
+            } 
+        }
+    return result;
+    }
+
+