/*

* Copyright (c) 2003 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:  SVG Engine source file

 *

*/

#include "SVGTimer.h"

#include "SVGEngineImpl.h"

#include "GfxAffineTransform.h"

#include "GfxPoint2D.h"

#include "SVGTimeContainer.h"

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

// Two phase constructor

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

CSvgTimer* CSvgTimer::NewLC( CSvgTimeContainer* aTimeContainer )

    {

    CSvgTimer* self = new ( ELeave ) CSvgTimer( aTimeContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

//

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

// Two phase constructor

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

CSvgTimer* CSvgTimer::NewL( CSvgTimeContainer* aTimeContainer )

    {

    CSvgTimer* self = NewLC( aTimeContainer );

    CleanupStack::Pop();

    return self;

    }

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

// Private method that builds the heap objects or performs leavable actions

// during object construction

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

void CSvgTimer::ConstructL()

    {

    // Call the base class ConstructL

    CTimer::ConstructL();

    // Add to active scheduler

    CActiveScheduler::Add( this );

    }

//

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

// Constructor

// Initialized with a pointer to the time container

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

CSvgTimer::CSvgTimer( CSvgTimeContainer* aTimeContainer ) : 

    CTimer( CActive::EPriorityStandard ),

    iTimeContainer( aTimeContainer )

    {

    ChangeFrameDuration( KMinFrameDelay );

    SetStrictFrameDuration( EFalse );

    ResetTime();

    }

//

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

// Destructor

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

CSvgTimer::~CSvgTimer()

    {

    Cancel();

    }

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

// Reset the time

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

void CSvgTimer::ResetTime()

    {

    iTime = 0;

    iFrames = 0;

    iFirstFrameDrawn = EFalse;

    }

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

// Change the duration of the timer in milliseconds

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

void CSvgTimer::ChangeFrameDuration( TUint32 aFrameDuration )

    {

    // If delay duration is less then minimum-delay, set to minimum-delay

    if ( aFrameDuration < KMinFrameDelay )

        {

        aFrameDuration =  KMinFrameDelay;

        }

    iFrameDuration = aFrameDuration;

    }

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

// Return the frames per 10-seconds

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

TUint CSvgTimer::Fps()

    {

	if ( iTime == 0 )

		{

		return 0;

		}

	// iTime is in milliseconds

	return ( 10000 * iFrames ) / iTime ;

    }

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

// Standard Active Object DoCancel

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

void CSvgTimer::DoCancel()

    {

    CTimer::DoCancel();

    }

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

// Standard Active Object RunL

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

void CSvgTimer::RunL()

    {

    // Check if timed entity not null

    if ( !iTimeContainer )

        {

        return;

        }

#if 0    

    // Check engine and document

    if ( !iSvgEngine || !iSvgEngine->Document() )

        {

        return;

        }

	// wait for images to finish decoding

    if ( !iSvgEngine->ReadyToRender() )

    	{

        CActive::Deque();

        CActiveScheduler::Add( this );

        CTimer::After( 10 * 1000 );

        return;

		}

#endif

    /********************** Generate first frame ********************/

    if ( !iFirstFrameDrawn )

    	{

        iFirstFrameDrawn = ETrue;

    	}

	else

		{

		/********************** After first frame ********************/

		TTime currentTime;

		currentTime.HomeTime();

		TUint32 elapsedTime = GetElapsedMilliseconds( iPreviousFrameTime, currentTime );

		// Cap elapsed time, if needed

		if ( iIsStrictFrameDuration &&

			 elapsedTime > iFrameDuration )

			{

			elapsedTime = iFrameDuration;

			}

		// Generate frame

		iTime += elapsedTime;

		}

    // Mark time of new frame

    iPreviousFrameTime.HomeTime();

    // Generate new frame

    TUint32 sleepTime = GenerateFrameL( iTime );

		// Sleep to next frame

	if ( 

	( iTimeContainer->Document()->Engine()->SVGEngineState() == ESVGEngineRunning ) 

	&& ( iTimeContainer->GetCurTick().iParentTcTick < iTimeContainer->Document()->AnimationDuration() ) 

	)

		{

        // Dequeue to move this ActiveObject to the end of the list

        // to share processor with other AOs.

		CActive::Deque();

		CActiveScheduler::Add( this );

		CTimer::After( 1000 * sleepTime );

		}

    }

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

// void CSvgTimer::SVGStop()

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

void CSvgTimer::SVGStop()

    {

    if ( IsActive() )

        {

        Cancel(); // stop current timer

        }

    iFirstFrameDrawn = EFalse;

    }

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

// void CSvgTimer::SVGResume()

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

void CSvgTimer::SVGResume( TInt32 aTime )

    {

    if ( !IsActive() )

        {

        if ( aTime < 0 )

            {

            // Error, ( negative time ) set to default

            aTime = 1000;

            }

        CTimer::After( aTime ); // invoke initial timer event

        }

    }

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

// void CSvgTimer::SetStartTime()

// Reset animation time to zero

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

void CSvgTimer::SetStartTime()

    {

    SetSeekTime( 0 );

    }

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

// void CSvgTimer::SetSeekTime( TUint32 aTime )

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

void CSvgTimer::SetSeekTime( TUint32 aTime )

    {

    // update the current time.

    iFirstFrameDrawn = EFalse;

#if 0

    // the current home time needs to be updated.

    if ( iSvgEngine && iSvgEngine->Document() && aTime != iTime )

        {

        TSvgTimerEvent timeEvent( aTime );

        iSvgEngine->Document()->Reset( &timeEvent );

        }

#endif

    iTime = aTime;

     if ( !IsActive() )

        {

        CTimer::After( 1000 );

        }

    }

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

// void CSvgTimer::SetStrictFrameDuration( TBool aKeepStrictFrameDuration )

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

void CSvgTimer::SetStrictFrameDuration( TBool aKeepStrictFrameDuration )

    {

    iIsStrictFrameDuration = aKeepStrictFrameDuration;

    }

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

// TUint32 CSvgTimer::GenerateFrameL( TUint32 aTime )

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

TUint32 CSvgTimer::GenerateFrameL( TUint32 aTime )

    {

    TTime startTime;

    startTime.HomeTime();

    TSvgTick lTick;

    lTick.iRealTimeTick = aTime;

    lTick.iParentTcTick = 0;

    iTimeContainer->ParentTimeContainerTick( lTick );

#if 0

    // Request to drawn frame at given time

    TSvgTimerEvent timeEvent( aTime );

    iSvgEngine->ProcessEventL( iSvgEngine->Document(), &timeEvent );

#endif

    TTime endTime;

    endTime.HomeTime();

    TUint32 elapsedTime = GetElapsedMilliseconds( startTime, endTime );

    // Calculate sleep time to next frame

    TUint32 sleepTime = KMinSleepDuration;

    if ( elapsedTime < iFrameDuration )

        {

        sleepTime = iFrameDuration - elapsedTime;

        if ( sleepTime < KMinSleepDuration )

            {

            sleepTime = KMinSleepDuration;

            }

        }

	iFrames++;

    return sleepTime;

    }

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

// TUint32 CSvgTimer::GetElapsedMilliseconds( TTime& aStart, TTime& aEnd )

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

TUint32 CSvgTimer::GetElapsedMilliseconds( TTime& aStart, TTime& aEnd )

    {

    TTimeIntervalMicroSeconds interval64 = aEnd.MicroSecondsFrom( aStart );

    // in milliseconds

    return I64INT( interval64.Int64() ) / 1000;

    }