/*

* 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 Implementation source file

 *

*/

#include "SVGAnimTimeController.h"

#include "SVGAnimationBase.h"

#include "GfxGeneralPath.h"

#include "GfxFlatteningPathIterator.h"

	#ifdef SVG_FLOAT_BUILD

#define MULT255(x) (255*(x))

	#else

#define MULT255(x) (((x)<<8) - (x))

	#endif

_LIT( KEmptyString,"" );

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

// Two phase construction

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

CSvgAnimTimeController* CSvgAnimTimeController::NewL()

    {

    CSvgAnimTimeController* self = new ( ELeave ) CSvgAnimTimeController();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgAnimTimeController::~CSvgAnimTimeController()

    {

	if ( iKeyTime )

		{

		iKeyTime->Close();

		delete iKeyTime;

		iKeyTime = NULL;

		}

    if ( iAnimTime )

		{

		iAnimTime->Close();

		delete iAnimTime;

		iAnimTime = NULL;

		}

    if ( iBeginTimeList )

        {

        iBeginTimeList->Close();

        delete iBeginTimeList;

		iBeginTimeList = NULL;

        }

    if ( iInitialBeginTimeList )

        {

        iInitialBeginTimeList->Close();

        delete iInitialBeginTimeList;

		iInitialBeginTimeList = NULL;

        }

    if ( iEndTimeList )

        {

        iEndTimeList->Close();

        delete iEndTimeList;

		iEndTimeList = NULL;

        }

    if ( iInitialEndTimeList )

        {

        iInitialEndTimeList->Close();

        delete iInitialEndTimeList;

		iInitialEndTimeList = NULL;

        }

    delete iSplines;

    }

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

//

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

CSvgAnimTimeController::CSvgAnimTimeController() : iCalcMode( KAnimCalcModeLinear ),

                                                   iBeginTime( 0 ),

                                                   iInitialBeginTime(0),

                                                   iDurationTime( KTimeIndefinite ),

                                                   iEndTime( KTimeIndefinite ),

                                                   iInitialEndTime(KTimeIndefinite),

                                                   iRepeatDurationTime( KTimeIndefinite ),

                                                   iNewActiveDurationTime( 0 ),

                                                   iSplineIndex( 0 ),

												   iModifiedEndTime( 0 ),

                                                   iIsSplineCalcMode( EFalse )

    {

    }

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

//

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

void CSvgAnimTimeController::ConstructL()

    {

    iKeyTime = new ( ELeave ) RArray<TKeyTime>( 1 );

    iAnimTime = new ( ELeave ) RArray<TUint32>( 1 );

    for ( TInt32 i = 0; i < KTimeMax + 1; i++ )

        {

        iAnimTime->AppendL(0);

        }

    iBeginTimeList = new ( ELeave ) RArray<TInt32>( 1 );

    iInitialBeginTimeList = new ( ELeave ) RArray<TInt32>( 1 );

    iEndTimeList = new (ELeave) RArray<TInt32>(1);

    iInitialEndTimeList = new (ELeave) RArray<TInt32>(1);

    }

// *******************************************************

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

//

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

void CSvgAnimTimeController::SetBeginTime( TInt32 aBeginTime )

    {

    iBeginTime = aBeginTime; // msec

    }

void CSvgAnimTimeController::SetOrgDurationTime(TInt32 aValue)

{

	iOrgDurationTime = aValue;

}

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

//

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

void CSvgAnimTimeController::AddBeginTime( TInt32 aBeginTime )

    {

       if ( aBeginTime < 0 )

        {

            aBeginTime = 0;     //Himanshu: to check the negative begin value

        }   

     iBeginTimeList->Append( aBeginTime );

     iBeginTimeList->SortSigned();

    }

void CSvgAnimTimeController::AddEndTime( TInt32 aEndTime )

    {

     iEndTimeList->Append( aEndTime );

     iEndTimeList->SortSigned();

     iEndTime = iEndTimeList->operator[](0);

    }

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

//

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

TUint32 CSvgAnimTimeController::GetBeginTime( TInt32 aIndex )

    {

    if(aIndex >= 0 && aIndex < iBeginTimeList->Count())

	    {

		return (TUint32) (iBeginTimeList->operator[](aIndex));

    	}

	else

		{

		return 0;

	    }

    }

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

//

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

void CSvgAnimTimeController::ResetBeginTime( TInt32 aBeginTime )

    {

    iBeginTime = aBeginTime; // msec

    }

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

//

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

void CSvgAnimTimeController::SetDurationTime( TInt32 aDurationTime )

    {

    iDurationTime = aDurationTime; // msec

    }

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

//

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

TInt32 CSvgAnimTimeController::GetDurationTime()

    {

    return iDurationTime; // msec

    }

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

//

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

void CSvgAnimTimeController::SetEndTime( TInt32 aEndTime )

    {

    iEndTime = aEndTime; // msec

	if (aEndTime != (TInt32)KTimeIndefinite)

		iModifiedEndTime= aEndTime;

    }

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

//

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

TInt32 CSvgAnimTimeController::GetEndTime()

    {

    return iEndTime; // msec

    }

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

//

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

void CSvgAnimTimeController::SetRepeatDurationTime( TUint32 aRepeatDurationTime )

    {

    iRepeatDurationTime = aRepeatDurationTime;

   }

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

//

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

void CSvgAnimTimeController::GetAnimTime( TInt32 aTimerTime,

                                          TInt32& aAnimTime,

                                          TInt32& aValueIndex,

                                          TInt32& aSubAnimTime )

    {

    if(iDurationTime == KTimeIndefinite || iDurationTime == 0)

        {

        aValueIndex = 0;

        aSubAnimTime= 0;

        aAnimTime=0;

        return;

        }

    TInt32 x = 0;

    if( iNewActiveDurationTime > 0 )//"repeatDur" <= "Dur"

		{

       	x = MULT255( aTimerTime - iBeginTime ) / iNewActiveDurationTime;

		}

    else

		{

		x = MULT255( aTimerTime - iBeginTime ) / iDurationTime;

		}

    if ( x > KTimeMax )

		{

        x = KTimeMax;

		}

	else

		{

		if ( x < 0 )

			{

			x = 0;

			}

		}

    TInt32 kcount = iKeyTime->Count();

    if ( kcount == 0 )// || iCalcMode == KAnimCalcModePaced)

	    {

        aValueIndex = 0;

        aSubAnimTime = 0;

        aAnimTime = x; //

        // No keytimes or paced animation

        if ( iCalcMode == KAnimCalcModeDiscrete )

            {

         // From SMIL 2.1 Animation Modules

         // Normative: Normative: A from-to animation with a from value vf

         // and a to value vt is equivalent to the same animation with a 

         // values list with 2 values, vf and vt. 

            if ( x < KTimeMax / 2 )

				{

                aAnimTime = 0;

				}

            else

				{

                aAnimTime = KTimeMax;

				}

            }

        }

    else if ( iCalcMode == KAnimCalcModePaced )

        {

        aAnimTime = x;

        TInt32 i = 0;

        while ( i < kcount && ( *iKeyTime )[i].iY < aAnimTime )

            i++;

        if ( i > 0 )

            i--;

        aValueIndex = i;

        // to avoid crashing for the array index aValueIndex + 1

		TBool IndexWasDecremented = EFalse;

        if(aValueIndex + 1 == kcount)

           	{

           	 aValueIndex--;

           	 IndexWasDecremented = ETrue;

           	}

        TInt32 dy = ( TInt32 )

                    ( ( *iKeyTime )[aValueIndex + 1].iY -

                      ( *iKeyTime )[aValueIndex].iY );

        if ( dy != 0 )

            aSubAnimTime = MULT255( aAnimTime - ( *iKeyTime )[aValueIndex].iY ) / dy;

        else

            aSubAnimTime = 0;

		if(IndexWasDecremented)

           	{

           	aValueIndex++;

           	}

        }

    else

        {

        // find corresponding keytime index

        TInt32 i = 0;

        while ( i < kcount && ( *iKeyTime )[i].iX < x )

            i++;

        if ( i > 0 )

            i--;

        ///// EXPLICITLY INCREMENT THE aValueIndex TO THE LAST OF THE LIST.

        if(x == 255)

	        {

	        aValueIndex = kcount-1;

	        }

	    else

	    	{

         	aValueIndex = i;

	    	}

        ////////////// END OF ADDITION ///////////////

        if ( iCalcMode == KAnimCalcModeDiscrete )

            {

            if ( x == KTimeMax )

                aValueIndex = iKeyTime->Count() - 1;

            aAnimTime = ( *iKeyTime )[aValueIndex].iY;

            aSubAnimTime = 0;

            }

        else

            {

            if ( iCalcMode == KAnimCalcModeLinear )

                {

                // calcMode:Linear

				if(( *iKeyTime )[i].iX == ( *iKeyTime )[i+1].iX)

					{

					while((i<(kcount-1)) && ( *iKeyTime )[i + 1].iX == ( *iKeyTime )[i].iX )

						{

						// this will increment the index so that

						// the interpolation would be done between the last

						// values.

						i++;

						// count should be less than the total number of elements.

						}

					}

				TInt32 alpha = MULT255( ( TInt32 )

                                        ( x - ( *iKeyTime )[i].iX ) ) /

                               ( TInt32 )

                               ( ( *iKeyTime )[i + 1].iX -

                                 ( *iKeyTime )[i].iX ) ;

                if(x == 255)

                	{

	             	aAnimTime = 255; // THIS SPECIFIES THAT THE DUR IS COMPLETE.

	               	}

				else

					{

					aAnimTime = CSvgAnimationBase::BlendInt( alpha,

	                                                         ( *iKeyTime )[i].iY,

	                                                         ( *iKeyTime )[i + 1].iY );

	                 }

                aSubAnimTime = alpha;

                }

            else

                {

                // calcMode:Spline

                TBool IndexWasDecremented = EFalse;

				if(aValueIndex + 1 == kcount)

					 {

					 aValueIndex--;

					 IndexWasDecremented = ETrue;

					 }

				aAnimTime = ( *iAnimTime )[x];

                TInt32 ydiff = ( TInt32 )

                               ( ( *iKeyTime )[aValueIndex + 1].iY -

                                 ( *iKeyTime )[aValueIndex].iY );

                if ( ydiff != 0 )

					{

                    aSubAnimTime = MULT255( aAnimTime -

                                            ( *iKeyTime )[aValueIndex].iY ) / ydiff;

					}

                else

					 {

                    aSubAnimTime = 0;

                }

				// oops increment again if it was decremented.

				if(IndexWasDecremented)

					 {

					 aValueIndex++;

					 }

                }

            if ( aAnimTime > KTimeMax )

				{

                aAnimTime = KTimeMax;

				}

			else

				{

				if ( aAnimTime < 0 )

					{

					aAnimTime = 0;

					}

				}

            }

        }

    }

// *******************************************************

// Create keytimes

// default is equally deived time

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

//

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

void CSvgAnimTimeController::CreateKeyTime( TInt32 aKeyTimeCount )

    {

    // Create keyTime array if not available

	TInt lDivider = aKeyTimeCount;

	if ( iCalcMode != KAnimCalcModeDiscrete )

		{

		lDivider--;

		}

    if ( iKeyTime->Count() == 0 && aKeyTimeCount > 0 && lDivider != 0 ) // check to avoid division by zero.

        {

        for ( TInt32 i = 0; i < aKeyTimeCount; i++ )

            {

			AddKeyTime( TFloatFixPt( i ) / TFloatFixPt( lDivider ) );

            }

        }

    }

void CSvgAnimTimeController::CreateKeyTimeForEnumeration( TInt32 aKeyTimeCount )

    {

    // Create keyTime array if not available

	// ignore the calc mode specification.

	TInt lDivider = aKeyTimeCount - 1;

    if ( iKeyTime->Count() == 0 && aKeyTimeCount > 0 && lDivider != 0 ) // check to avoid division by zero.

        {

        for ( TInt32 i = 0; i < aKeyTimeCount; i++ )

            {

			AddKeyTime( TFloatFixPt( i ) / TFloatFixPt( lDivider ) );

            }

        }

    }

// Preparing animation time

// this should be called just before animation start

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

//

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

void CSvgAnimTimeController::PrepareTimeL( const RArray<TFloatFixPt>* aValues )

    {

    TInt32 i;

    // set y for each keytime

    TInt32 count = iKeyTime->Count();

	// THIS IS MODIFIED FOR THE BUG FIX.

    if ( count <= 1)

		{

        return;

		}

    if ( iCalcMode == KAnimCalcModePaced )

        {

        if ( aValues == NULL )

			{

            return;

			}

        TInt32 valCount = aValues->Count();

        if ( valCount != count )

			{

            return; // No animation if values and keytimes has different number of items

			}

        // 'Paced' animation needs unique animation time from

        //  value difference

        RArray<TFloatFixPt>* yary = new ( ELeave ) RArray<TFloatFixPt>( 1 ); // SSB was 10

        CleanupStack::PushL( yary );