/*

* 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

 *

*/

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#include "SVGAnimationBase.h"

#include "SVGElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGStringTokenizer.h"

#include "SVGPointLexer.h"

#include "SVGPathDataParser.h"

#include "SVGAnimTimingParser.h"

#include "SVGPaintCssValueImpl.h"

#include "SVGIntCssValueImpl.h"

//CONSTANTS

_LIT(KSEMICOLON, ";");

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

// No NewL or NewLC because this is abstract class

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

void CSvgAnimationBase::ConstructL(  const TUint8 aElemID )

    {

    CSvgElementImpl::InitializeL( aElemID );

    iAnimTime = CSvgAnimTimeController::NewL();

    iValuesFloat = new ( ELeave ) RArray<TFloatFixPt>( 1 );

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

    iValuesPath = new ( ELeave ) RPointerArray<CGfxGeneralPath>( 1 );

	// viewBox

	iValuesViewBox = new ( ELeave ) RArray<TGfxRectangle2D>( 1 );

    iEventList = new ( ELeave )CArrayFixFlat<TEventListItem>( 1 );

    iEndTimeList = new ( ELeave )CArrayFixFlat<TEventListItem>( 1 );

	/*Added to Support forward referencing*/

	iSvgUriReferenceImpl = CSvgUriReferenceImpl::NewL();

    ((CSvgDocumentImpl*)iOwnerDocument)->AddToEventReceiverListL(

                                                    this, KSvgEventMaskTimer );

    }

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

//

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

CSvgAnimationBase::CSvgAnimationBase( CSvgDocumentImpl* aDoc ) :

                                                                 iAnimStatus( KAnimNotActive ),

                                                                 iTargetElement( NULL ),

                                                                 iEndOffset( 0 ),

                                                                 iRepeatCount( 1 ),

                                                                 iRepeatEndValue ( 0 ) ,

                                                                 iAbsoluteBeginTime ( 0 ),

                                                                 iBeginTimeIndex( 0 ) ,

                                                              //   iEndAccessKeyCode( 0 ),

                                                                 iCurrentRepeatCount( 0 ),

                                                                 iAttrId( 0xffff ),

                                                                 iInitDone( EFalse ),

                                                                 iTargetSet( EFalse ),

                                                                 iNoFrom( ETrue ),

                                                                 iHaveTo( EFalse ),

                                                                 iHaveBy( EFalse ),

                                                                 iHaveValues (EFalse),

                                                                 iFill( KAnimFillRemove ),

                                                                 iHadBegun( EFalse ),

                                                                 iAnimRestart( KRestartAlways ),

                                                                 iAccumulate( KAccumNone ),

                                                                 iAdditive( KAdditivePass ),

                                                                 iAdditiveOrg( KAdditiveReplace ),

                                                                 iOverrideTime ( EFalse ),

                                                                 iRepeatCountSet ( EFalse ),

																 iKeyTimesPresent(EFalse),

																// iEndReferenceElemeId(NULL),

																 iIsUserSeek(EFalse),

																 iEndTimeIndex(0)

    {

    SetOwnerDocument(aDoc);

    }

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

//

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

CSvgAnimationBase::~CSvgAnimationBase()

    {

    if ( iAnimTime )

        {

        delete iAnimTime;

        iAnimTime = NULL;

        }

	if (iRepeatId)

	{

		delete iRepeatId;

		iRepeatId = NULL;

	}

    if ( iValuesInt )

        {

        iValuesInt->Close();

        delete iValuesInt;

        iValuesInt = NULL;

        }

    if ( iValuesViewBox )

        {

        iValuesViewBox->Close();

        delete iValuesViewBox;

        iValuesViewBox = NULL;

        }

    if ( iValuesFloat )

        {

        iValuesFloat->Close();

        delete iValuesFloat;

        iValuesFloat = NULL;

        }

    if ( iOrgPath )

        {

        delete iOrgPath;

        iOrgPath = NULL;

        }

    if ( iEndPath )

        {

        delete iEndPath;

        iEndPath = NULL;

        }

    if ( iOrgFromPath )

        {

        delete iOrgFromPath;

        iOrgFromPath = NULL;

        }

    if ( iFromPath )

        {

        delete iFromPath;

        iFromPath = NULL;

        }

    if ( iToPath )

        {

        delete iToPath;

        iToPath = NULL;

        }

    if ( iValuesPath )

        {

        iValuesPath->ResetAndDestroy();

        iValuesPath->Close();

        delete iValuesPath;

        iValuesPath = NULL;

        }

	if ( iSvgUriReferenceImpl )

		{

		delete iSvgUriReferenceImpl;

		iSvgUriReferenceImpl = NULL;

		}

    if ( iEventList )

        {

		TInt lCount = iEventList->Count();

	    for(TInt i= 0; i< lCount; i++)

	    {

	    if(iEventList->operator[](i).iReferenceElemeId)

	    	{

	    	delete iEventList->operator[](i).iReferenceElemeId;

	    	iEventList->operator[](i).iReferenceElemeId = NULL;

	    	}

	 	}

        delete iEventList;

        iEventList = NULL;

        }

     if ( iEndTimeList )

        {

        TInt lCount2 = iEndTimeList->Count();

	    for(TInt i= 0; i< lCount2; i++)

	    {

	    if(iEndTimeList->operator[](i).iReferenceElemeId)

	    	{

	    	delete iEndTimeList->operator[](i).iReferenceElemeId;

	    	iEndTimeList->operator[](i).iReferenceElemeId = NULL;

	    	}

	 	}

        delete iEndTimeList;

        iEndTimeList = NULL;

        }

    //remove this from the animation list

    CSvgDocumentImpl* lOwnerDocument = (CSvgDocumentImpl*)iOwnerDocument;

    if (lOwnerDocument)

    {

    	TInt index = lOwnerDocument->iSvgAnimations.Find(this);

    	if (index != KErrNotFound)

    	{

    		lOwnerDocument->iSvgAnimations.Remove( index );

    	}

    }

    }

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

//

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

TUint32 CSvgAnimationBase::SimpleDuration()

    {

	TUint32 lEndTime= KTimeIndefinite;

	TUint32 lDur= KTimeIndefinite;

	if(iAbsoluteBeginTime == (TInt32)KTimeIndefinite)

		{

		return KTimeIndefinite;

		}

	if ( iAnimTime->DurationTime() == 0 )

        { 

        // If the animation's dur is specified as 0, then the Simple duration

        // of this animation is 0. This is done so that the animation should not happen

        return 0;

        }

	lEndTime = iAnimTime->EndTime();

	if ( lEndTime <= iAnimTime->BeginTime() )

	   {

	    lEndTime= KTimeIndefinite;

	   } 

    if ( iRepeatCount == KRepeatCountMax )

        {

        if ( iAnimTime->RepeatDurationTime() == KTimeIndefinite )

            {

            lDur=  KTimeIndefinite;   // Neither are specified

            }

        else    // RepeatDur was specified.

            {

            lDur= iAbsoluteBeginTime + iAnimTime->RepeatDurationTime();

            }

        }

    else if( (iAnimTime->DurationTime() == KTimeIndefinite || iAnimTime->DurationTime() == KIndefiniteAnimationDuration)

     			&& ( this->ElemID() != KSvgSetElement ) )

    	{

         lDur= KTimeIndefinite;

    	 return lDur;

    	}

    else        // RepeatCount was specified.

        {

        if ( iAnimTime->RepeatDurationTime() == KTimeIndefinite )

            {

            lDur= (TUint32) (iAbsoluteBeginTime + iAnimTime->DurationTime() * iRepeatCount);

            }

        else    // Both are specified.  Return the minimum time.

            {

            if ( iAnimTime->RepeatDurationTime() < ( iAnimTime->DurationTime() * iRepeatCount ) )

                {

                lDur= iAbsoluteBeginTime + iAnimTime->RepeatDurationTime();

                }

            else

                {

                lDur= (TUint32) (iAbsoluteBeginTime + iAnimTime->DurationTime() * iRepeatCount);

                }

            }

        }

	// should return the Minimum of end time and calculated duration

	if(lDur <= lEndTime)

		return lDur;

	else

		return lEndTime;

    }

TUint32 CSvgAnimationBase::CompleteDuration()

    {

	TUint32 lDur= KTimeIndefinite;

    TUint32 lEndTime = iAnimTime->LastEndTime();

	TUint32 lBeginTime = iAnimTime->LastBeginTime();

	if(lBeginTime == (TInt32)KTimeIndefinite)

		{

		return KTimeIndefinite;

		}

	if ( iAnimTime->DurationTime() == 0 )

        { 

        // If the animation's dur is specified as 0, then the Simple duration

        // of this animation is 0. This is done so that the animation should not happen

        return 0;

        }

	if ( lEndTime <= lBeginTime)

	   {

	    // When animation's end time is <= its begin time, it means that the 

	    // animation should be treated as an indefinite animation and animation

	    // never becomes active

		lEndTime = KTimeIndefinite; 

	   } 

    if ( iRepeatCount == KRepeatCountMax )

        {

        if ( iAnimTime->RepeatDurationTime() == KTimeIndefinite )

            {

            lDur=  KTimeIndefinite;   // Neither are specified

            }

        else    // RepeatDur was specified.

            {

            lDur= lBeginTime + iAnimTime->RepeatDurationTime();

            }

        }

    else if( (iAnimTime->DurationTime() == KTimeIndefinite || iAnimTime->DurationTime() == KIndefiniteAnimationDuration)

     			&& ( this->ElemID() != KSvgSetElement ) )

    	{

         lDur= KTimeIndefinite;

    	 return lDur;

    	}

    else        // RepeatCount was specified.

        {

        if ( iAnimTime->RepeatDurationTime() == KTimeIndefinite )

            {

            lDur= (TUint32) (lBeginTime + iAnimTime->DurationTime() * iRepeatCount);

            }

        else    // Both are specified.  Return the minimum time.

            {

            if ( iAnimTime->RepeatDurationTime() < ( iAnimTime->DurationTime() * iRepeatCount ) )

                {

                lDur= lBeginTime + iAnimTime->RepeatDurationTime();

                }

            else

                {

                lDur= (TUint32) (lBeginTime + iAnimTime->DurationTime() * iRepeatCount);

                }

            }

        }

	// should return the Minimum of end time and calculated duration

	if(lDur <= lEndTime)

		return lDur;

	else

		return lEndTime;

    }

// From SVG DOM / MElementTimeControl

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

//

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

TBool CSvgAnimationBase::BeginElementL()

    {

    SetBeginByEventL( this, ((CSvgDocumentImpl*)iOwnerDocument)->Engine()->CurrentTIme() );

    return EFalse;

    }

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

//

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

TBool CSvgAnimationBase::BeginElementAtL( TFloatFixPt aOffset )

    {

    TInt32  offset  = aOffset.RawData() / KBeginElementOffsetRatio /* *1000/65536 */;

    SetBeginByEventL( this, ((CSvgDocumentImpl*)iOwnerDocument)->Engine()->CurrentTIme() + offset );

    return EFalse;

    }

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

//

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

TBool CSvgAnimationBase::EndElement()

    {

    SetEndByEvent( this, ((CSvgDocumentImpl*)iOwnerDocument)->Engine()->CurrentTIme() );

    return EFalse;

    }

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

//

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

TBool CSvgAnimationBase::EndElementAt( TFloatFixPt aOffset )

    {

    TInt32  offset  = aOffset.RawData() / 66 /* *1000/65536 */;

    SetEndByEvent( this, ((CSvgDocumentImpl*)iOwnerDocument)->Engine()->CurrentTIme() + offset );

    return EFalse;

    }

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

// SVG Implementation

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

// From MXmlElement

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

//

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

TInt CSvgAnimationBase::SetAttributeL( const TDesC& aName, const TDesC& aValue )

    {

    // Before anything else set the target to parent

    if ( !iTargetSet )

        {

        iTargetElement = ( CSvgElementImpl * ) ParentNode();// default is parent element

			if (iTargetElement)

			{

        iTargetSet = ETrue;

			}

        }

    _LIT( KTmpAttrName, "attributeName" );

    _LIT( KTmpXlinkHref, "xlink:href" );

    _LIT( KTmpBegin, "begin" );

    _LIT( KTmpDur, "dur" );

    _LIT( KTmpRepeatDur, "repeatDur" );

    _LIT( KTmpEnd, "end" );

    _LIT( KTmpFrom, "from" );

    _LIT( KTmpTo, "to" );

    _LIT( KTmpBy, "by" );

    _LIT( KTmpFill, "fill" );

    _LIT( KTmpRestart, "restart" );

    _LIT( KTmpRepeatCount, "repeatCount" );

    _LIT( KTmpAccumulate, "accumulate" );

    _LIT( KTmpAdditive, "additive" );

    _LIT( KTmpValues, "values" );

    _LIT( KTmpCalcMode, "calcMode" );

    _LIT( KTmpKeyTimes, "keyTimes" );

    _LIT( KTmpKeySplines, "keySplines" );

    _LIT( KTmpIndefinite, "indefinite" );

    if ( SetIdandXmlbaseL( aName, aValue ) )

        {

        return KErrNone;

        }

     if ( aName == KTmpXlinkHref )

        {

		// STEP 1 - Get the reference element

		// If the first char is '#' then remove it

		// This is possible if coming from cXML parser and not CVG Decoder

		TInt pos = aValue.Locate( '#' );

		if ( pos != KErrNotFound && pos == 0 )

			{

			HBufC*  tBufC   = HBufC::NewLC( aValue.Length() );

			TPtr    tPtr    = tBufC->Des();

			tPtr.Copy( aValue );

			tPtr.Delete( pos, 1 );

			CSvgElementImpl *lElement = ( CSvgElementImpl * )

			((CSvgDocumentImpl*)iOwnerDocument)->GetElementById( tPtr );

			if(this->SetXlinkAttributeL( aName, tPtr ))

				{

				if(lElement)

					{

					SetTarget(lElement);

					}

				else

					{

					CleanupStack::PopAndDestroy( 1 );

					return KErrAnimateReferenceElementNotFound;

					}

				}

			CleanupStack::PopAndDestroy( 1 );

			}

        if ( !iTargetElement )

            {

            iAttrId = 0xffff;

            return KErrNoAttribute;

            }

       else if((    iTargetElement->ElemID() == KSvgRadialGradientElement

                    || iTargetElement->ElemID() == KSvgLinearGradientElement)

                     && (iAttrId == KAtrGradientTransform))

            {

            iAttrId = KAtrTransform;

            }

        GetAttrValueL();

        return KErrNone;

        }

    if ( aName == KTmpAttrName )

        {

        iReqAttrFlag = 0;

        iAnimStatus = KAnimNotActive;

        if (iTargetElement)

            {

          	iTargetElement->iHasAnimationBase = (TInt)this;

        	iTargetElement->SetIsAnimating( EFalse );

        	SetIsAnimating( EFalse );