/*

 * ============================================================================

 *  Name        : hgteleportphysics.cpp

 *  Part of     : Hg Teleport

 *  Description : Application class

 *  Version     : %version:  4 %

 *

 *  Copyright © 2009 Nokia.  All rights reserved.

 *  This material, including documentation and any related computer

 *  programs, is protected by copyright controlled by Nokia.  All

 *  rights are reserved.  Copying, including reproducing, storing,

 *  adapting or translating, any or all of this material requires the

 *  prior written consent of Nokia.  This material also contains

 *  confidential information which may not be disclosed to others

 *  without the prior written consent of Nokia.

 * ============================================================================

 * 

 */

#include <aknphysicsobserveriface.h>

#include "hgteleportphysics.h"

const TInt KSingleItemChangeAnimTime = 1000000; // 1 second

const TInt KAnimationFrameCount = 15; // 15 frames per second

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

// CHgTeleportPhysics::CHgTeleportPhysics

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

//

CHgTeleportPhysics::CHgTeleportPhysics( MAknPhysicsObserver& aObserver ) :

    CActive( EPriorityStandard ), iObserver( aObserver )

    {

    }

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

// CHgTeleportPhysics::NewLC

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

//

CHgTeleportPhysics* CHgTeleportPhysics::NewLC( MAknPhysicsObserver& aObserver )

    {

    CHgTeleportPhysics* self = new ( ELeave ) CHgTeleportPhysics( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CHgTeleportPhysics::NewL

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

//

CHgTeleportPhysics* CHgTeleportPhysics::NewL( MAknPhysicsObserver& aObserver )

    {

    CHgTeleportPhysics* self = CHgTeleportPhysics::NewLC( aObserver );

    CleanupStack::Pop();

    return self;

    }

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

// CHgTeleportPhysics::ConstructL

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

//

void CHgTeleportPhysics::ConstructL()

    {

    User::LeaveIfError( iTimer.CreateLocal() );

    CActiveScheduler::Add( this );

    // Animation parameters

    const TInt KInitValue = 0;

    iAnimationTickTime = KSingleItemChangeAnimTime / KSingleItemChangeAnimTime;

    iPhysicsState = EStopped;

    iAnimationTicks = KInitValue;

    }

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

// CHgTeleportPhysics::~CHgTeleportPhysics

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

//

CHgTeleportPhysics::~CHgTeleportPhysics()

    {

    Cancel();

    iTimer.Close();

    iAnimationSteps.Close();

    }

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

// CHgTeleportPhysics::DoCancel

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

//

void CHgTeleportPhysics::DoCancel()

    {

    iTimer.Cancel();

    }

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

// CHgTeleportPhysics::StartPhysics

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

//

void CHgTeleportPhysics::StartPhysics( const TPoint& aTarget )

    {

    Cancel();

    // Setup animation

    TPoint currentPoint = iObserver.ViewPosition();

    if ( currentPoint.iX != aTarget.iX )

        {

        iAnimationTicks = 0;

        if ( CalculateAnimationSteps( aTarget ) == KErrNone )

            {

            // Request

            iTimer.After( iStatus, 0 );

            SetActive();

            }

        else

            {

            // If calculation failes (no memory) or there is

            // only a small step, set view to target

            iObserver.ViewPositionChanged( aTarget, ETrue, 0);

            iObserver.PhysicEmulationEnded();

            }

        }

    }

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

// CHgTeleportPhysics::StopPhysics

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

//

void CHgTeleportPhysics::StopPhysics()

    {

    Cancel();

    if ( iPhysicsState == ERunning || iPhysicsState == EFinished )

        {

        iObserver.PhysicEmulationEnded();

        }

    iPhysicsState = EStopped;

    iAnimationTicks = 0;

    }

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

// CHgTeleportPhysics::RunL

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

//

void CHgTeleportPhysics::RunL()

    {

    if ( iPhysicsState == EStopped )

        {

        // Start animation

        iPhysicsState = ERunning;

        iTimer.After( iStatus, iAnimationTickTime );

        SetActive();

        }

    else if ( iPhysicsState == ERunning )

        {

        // Ongoing animation

        if ( iAnimationTicks >= 0 && iAnimationTicks < KAnimationFrameCount )

            {

            iObserver.ViewPositionChanged( iObserver.ViewPosition()+iAnimationSteps[iAnimationTicks], ETrue, 0 );

            }

        iAnimationTicks++;

        if ( iAnimationTicks >= KAnimationFrameCount )

            {

            iPhysicsState = EFinished;

            }

        iTimer.After( iStatus, iAnimationTickTime );

        SetActive();

        }

    else if ( iPhysicsState == EFinished )

        {

        iAnimationTicks = 0;

        iPhysicsState = EStopped;

        iObserver.PhysicEmulationEnded();

        }

    }

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

// CHgTeleportPhysics::RunError

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

//

TInt CHgTeleportPhysics::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

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

// CHgTeleportPhysics::CalculateAnimationSteps

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

//

TInt CHgTeleportPhysics::CalculateAnimationSteps( const TPoint& aTarget )

    {

    TInt retVal( KErrNone );

    iAnimationSteps.Reset();

    retVal = iAnimationSteps.Reserve( KAnimationFrameCount );

    if ( retVal == KErrNone )

        {

        TInt yValue = aTarget.iY;

        TPoint currentPos = iObserver.ViewPosition();

        TInt moveLen = aTarget.iX - currentPos.iX;

        if ( moveLen > KAnimationFrameCount || moveLen < -KAnimationFrameCount )

            {

            TInt singleStep = moveLen / KAnimationFrameCount;

            for ( TInt i = 0; i < KAnimationFrameCount - 1; i++ )

                {

                iAnimationSteps.Append( TPoint( singleStep, yValue ) );

                }

            TInt lastStep = moveLen - ( ( KAnimationFrameCount - 1 ) * singleStep );

            iAnimationSteps.Append( TPoint( lastStep, yValue ) );

            }

        else

            {

            retVal = KErrArgument;

            }

        }

    return retVal;

    }