/*

* 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 <e32math.h>

#include "SVGAnimateMotionElementImpl.h"

#include "SVGElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

#include "GfxGeneralPath.h"

#include "GfxFlatteningPathIterator.h"

#include "SVGPathDataParser.h"

#include "SVGPointLexer.h"

#include "SVGStringTokenizer.h"

_LIT( AUTO, "auto" );

_LIT( AUTOREVERSE, "auto-reverse" );

_LIT( SEMICOLON, ";" );

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

// Constructor/deconstructor

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

//

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

CSvgAnimateMotionElementImpl* CSvgAnimateMotionElementImpl::NewL(  const TUint8 aElemID,

																  CSvgDocumentImpl* aDoc )

	{

	CSvgAnimateMotionElementImpl*   self    = new ( ELeave )

											  CSvgAnimateMotionElementImpl( aDoc );

	CleanupStack::PushL( self );

	self->ConstructL(  aElemID );

	CleanupStack::Pop();

	return self;

	}

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

//

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

CSvgAnimateMotionElementImpl* CSvgAnimateMotionElementImpl::NewLC(  const TUint8 aElemID,

																   CSvgDocumentImpl* aDoc )

	{

	CSvgAnimateMotionElementImpl* self = new ( ELeave )

											  CSvgAnimateMotionElementImpl( aDoc );

	CleanupStack::PushL( self );

	self->ConstructL(  aElemID );

	return self;

	}

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

//

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

void CSvgAnimateMotionElementImpl::ConstructL(  const TUint8 aElemID )

	{

	CSvgAnimationBase::ConstructL( aElemID );

	iMotionPath = CGfxGeneralPath::NewL();

	iAnimTime->SetCalMode( KAnimCalcModePaced ); // animateMotion has differenr default

	iReqAttrFlag=KSVG_AMINATEMO_ELEMFLAG;

	}

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

//

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

CSvgAnimateMotionElementImpl::~CSvgAnimateMotionElementImpl()

    {

	if ( iMotionPath )

		{

		delete iMotionPath;

		iMotionPath = NULL;

		}

	if ( iPathIterator )

		{

		delete iPathIterator;

		iPathIterator = NULL;

		}

    }

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

// Private

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

//

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

CSvgAnimateMotionElementImpl::CSvgAnimateMotionElementImpl( CSvgDocumentImpl* aDoc ) : CSvgAnimationBase( aDoc ),

                                                                                       iCurrentSeg( 0,

                                                                                                    0,

                                                                                                    0,

                                                                                                    0 ),

                                                                                       //iIsValues( EFalse ),

                                                                                       iPrevRotate(0)

    {

    iAttrId = KAtrTransform;

    }

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

// From SVG DOM

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

// SVG Implementation

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

// From MSvgEventReceiver

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

//

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

void CSvgAnimateMotionElementImpl::ResetReferenceElementL()

    {

    if(iTargetElement != NULL )

    	{

    	if( ((iTargetElement->iAnimateAttrSet == NULL) ||

    	    (iTargetElement->iAnimateAttrSet->Find(iAttrId) == KErrNotFound) ) )

    		{

    		if ( iInitDone )

    			{

    			iCheckFirstAnim= ETrue;

    			SetToOriginalL();

    			if( !(iTargetElement->iAnimateAttrSet) )

    				{

                    iTargetElement->iAnimateAttrSet = new (ELeave) RArray<TUint32>(1);

                    }

                iTargetElement->iAnimateAttrSet->AppendL((TUint32)iAttrId);

    			}

    		}

        }

    }

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

// From MXmlElement

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

//

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

TInt CSvgAnimateMotionElementImpl::SetAttributeL( const TDesC& aName,

                                                  const TDesC& aValue )

    {

    _LIT( KTmpAttrName, "attributeName" );

    _LIT( KTmpPath, "path" );

    _LIT( KTmpRotate, "rotate" );

    _LIT( KTmpFrom, "from" );

    _LIT( KTmpTo, "to" );

    _LIT( KTmpValues, "values" );

    _LIT( KTmpBy, "by" );

    if ( aName == KTmpAttrName )

        {

        // Ignore 'attributeName' attribute

        }

    else if ( aName == KTmpPath )

        {

        iMotionPath->Reset();

		TSvgPathDataParser::ParsePathData( aValue, iMotionPath );

        CGfxPathIterator*   itr;

        TFloatFixPt              tmpcoords[6];

        iMotionPath->GetPathIteratorL( &iIdentTransform, itr );

        CleanupStack::PushL( itr );

        while ( !itr->IsDone() )

            {

            switch ( itr->CurrentSegment( tmpcoords ) )

                {

                case EGfxSegMoveTo:

                iToFloatX = tmpcoords[0];

                iToFloatY = tmpcoords[1];

                break;

                case EGfxSegLineTo:

                iToFloatX = tmpcoords[0];

                iToFloatY = tmpcoords[1];

                break;

                case EGfxSegQuadTo:

                iToFloatX = tmpcoords[2];

                iToFloatY = tmpcoords[3];

                break;

                case EGfxSegCubicTo:

                iToFloatX = tmpcoords[4];

                iToFloatY = tmpcoords[5];

                break;

                case EGfxSegClose:

                iToFloatX = tmpcoords[0]; //.

                iToFloatY = tmpcoords[1];

                }

            itr->NextL();

            }

        iPathSeen = ETrue;

        CleanupStack::PopAndDestroy();

		if(iReqAttrFlag == KAtrSVGAmo && (iMotionPath->PointTypeArray())->Count() != 0 )

			{

			iReqAttrFlag = 0;

			}

        }

	else if ( aName == KTmpRotate )

		{

		if ( aValue == AUTO )

			{

			iAnimMotionRotate = KAnimMotionRotateAuto;

			}

		else if ( aValue == AUTOREVERSE )

			{

			iAnimMotionRotate = KAnimMotionRotateAutoReverse;

			}

		else

			{

			TLex    lString ( aValue );

			if (lString.Val( iAnimMotionRotate )!= KErrNone)

				{

				iAnimMotionRotate= 0;

				}

			if ( iAnimMotionRotate < 0 )

				{

					// Note: A problem may occur if the value is less than -3600

	        iAnimMotionRotate += 3600;

				}

			iAnimMotionRotate %= 360;

			}

		}

    else if ( aName == KTmpFrom )

	    {

		if ( ! iHaveValues )

			{

			iNoFrom = EFalse;

			iMotionPath->Reset();

			TSvgPointLexer  svgplex ( aValue );

			TChar           com;

			TFloatFixPt          x, y;

            svgplex.GetNextPoint( com, x, y );

            svgplex.Cleanup();

			iOrgFromFloatX = iFromFloatX = x;

			iOrgFromFloatY = iFromFloatY = y;

			iMotionPath->MoveToL( x, y, ETrue );  // 'from' -> MoveTo

			}

		if(iReqAttrFlag == KAtrSVGAmo)

			{

			iReqAttrFlag = KAtrToBy;

			}

		else

			{

			iReqAttrFlag = 0;

			}

		}

    else if ( aName == KTmpBy )

	    {

		if ( !iHaveTo )

			{

			iHaveBy = ETrue;

			if(iReqAttrFlag == KAtrSVGAmo || iReqAttrFlag == KAtrToBy)

				{

				iReqAttrFlag = 0;

				}

		    if ( !iHaveValues )

			    {

	               TSvgPointLexer  svgplex ( aValue );

	            TChar           com;

		        TFloatFixPt          x, y;

                svgplex.GetNextPoint( com, x, y );

                svgplex.Cleanup();

                if ( iNoFrom )

	                {

		            iToFloatX = x;

			        iToFloatY = y;

				    iNoFrom = EFalse;

				    // this is taken from animate transforms.

				   iAdditive = KAdditiveSum;

				   iAdditiveOrg = KAdditiveSum;

					}

                else

	                {

		            iToFloatX = iFromFloatX + x;

			        iToFloatY = iFromFloatY + y;

				    }

	            CGfxPathIterator*   itr;

		        iMotionPath->GetPathIteratorL( &iIdentTransform, itr );

			    CleanupStack::PushL( itr );

				if ( itr->IsDone() )

					{

					TFloatFixPt lZero;

					// If the animation path is empty, fill with default value.

					iMotionPath->MoveToL( lZero, lZero, ETrue );

					}

				CleanupStack::PopAndDestroy( 1 ); // itr

				iMotionPath->LineToL( x, y, ETrue );  // 'by' -> LineTo

				}

			}

		if(iReqAttrFlag == KAtrSVGAmo && (iMotionPath->PointTypeArray())->Count() != 0 )

			{

			iReqAttrFlag = 0;

			}

	    }

	else if ( aName == KTmpTo )

		{

		if ( !iHaveValues )

			{

			// this is taken from animate transforms.

			if ( iNoFrom )

               {

	           iAdditive = KAdditiveSum;

			   iAdditiveOrg = KAdditiveSum;

			   }

			TSvgPointLexer  svgplex ( aValue );

			TChar           com;

			TFloatFixPt          x, y;

			iHaveTo = ETrue;

            svgplex.GetNextPoint( com, x, y );

            svgplex.Cleanup();

            iToFloatX = x;

			iToFloatY = y;

			CGfxPathIterator*   itr;

			iMotionPath->GetPathIteratorL( &iIdentTransform, itr );

			CleanupStack::PushL( itr );

			if ( itr->IsDone() )

				{

				TFloatFixPt lZero;

				// If the animation path is empty, fill with default value.

				// should this default be zero or object position

				iMotionPath->MoveToL( lZero, lZero, ETrue );

				}

			CleanupStack::PopAndDestroy( 1 ); // itr

			iMotionPath->LineToL( x, y, ETrue );  // 'to' -> LineTo

			}

		if(iReqAttrFlag == KAtrSVGAmo || iReqAttrFlag == KAtrToBy)

			{

			iReqAttrFlag = 0;

			}

		}

	else if ( aName == KTmpValues )

		{

		// Process only if Path values have not been seen

		if ( !iPathSeen )

		    {

    		TStringTokenizer    tkn     ( aValue, SEMICOLON );

    		TBool               first   = ETrue;

    		iHaveValues = ETrue;

    		iNoFrom = EFalse; //.

    		iMotionPath->Reset();

    		while ( tkn.HasMoreTokens() ) // 'values' is a set of coordinates

    			{

    			TSvgPointLexer  svgplex ( tkn.NextToken() );

    			TChar           com;

    			TFloatFixPt          x, y;

                svgplex.GetNextPoint( com, x, y );

                svgplex.Cleanup();

    			if ( first )

    				{

    				iMotionPath->MoveToL( x, y, ETrue );

    				iOrgFromFloatX = iFromFloatX = x; //.

    				iOrgFromFloatY = iFromFloatY = y;

    				first = EFalse;

    				}

    			else

    				{

    				iMotionPath->LineToL( x, y, ETrue );

    				}

    			iToFloatX = x; //.

    			iToFloatY = y;

    			}

    		if(iReqAttrFlag == KAtrSVGAmo || iReqAttrFlag == KAtrToBy)

    			{

    			iReqAttrFlag = 0;

    			}

		    }

		}

    else

	    {

		return CSvgAnimationBase::SetAttributeL( aName, aValue );

		}

	return KErrNone;

    }

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

// From MSvgEventReceiver

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

TBool CSvgAnimateMotionElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

    return CSvgAnimationBase::ReceiveEventProcL( aEvent, this );

    }

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

// From CSvgAnimationBase

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

//

TBool CSvgAnimateMotionElementImpl::AnimProcL( MSvgTimerEvent* aEvent )

    {

  if((iAnimStatus != KAnimActive) || iDoFreeze)

	   {

	   if(iFill== KAnimFillFreeze && !iDoFreeze && iAnimStatus == KAnimFinished)

	   		{

	   		// calculate the freeze value.

	   		}

	   else

		   {

		   CSvgAnimationBase::CheckForEndTimesAndFreezeL(this);

		   return EFalse;

		   }

	   }

    if ( ( iPathIterator == NULL ) || ( iPathIterator->IsDone() ) )

		{

        return EFalse;  // Already end of path. Nothing to do any more.

		}

    TFloatFixPt  nextPos, diff;

    TFloatFixPt  zero    ( 0 );

    // Get next position in [0..255] range

    TInt32  animatetime; // Not used...

    TInt32  valix, subanimtime;

    iAnimTime->GetAnimTime( (aEvent->Time()-iNegativeBeginTime), animatetime, valix, subanimtime );

    // Get next position in actual length

    TFloatFixPt  v2;

    if ( valix >= iValuesFloat->Count() - 1 )

		{

		valix= iValuesFloat->Count() - 1;

        v2 = ( *iValuesFloat )[valix];

		}

    else

		{

        v2 = ( *iValuesFloat )[valix + 1];

		}

    nextPos = CSvgAnimationBase::BlendFloat( subanimtime,

                                             ( *iValuesFloat )[valix],

                                             v2 );

    diff = nextPos - iCurrentPos;

    TGfxSegType SegType;

    while ( iSubPos + diff > iSubLength && !iPathIterator->IsDone() )

        {

        if ( iSubLength < zero )

			{

            iSubLength = zero;

			}

        TFloatFixPt  tmpcoords[6];

        diff -= iSubLength - iSubPos;

        iPathIterator->NextL();

        SegType = iPathIterator->CurrentSegment( tmpcoords );

        iCurrentSeg.iX1 = iCurrentSeg.iX2;

        iCurrentSeg.iY1 = iCurrentSeg.iY2;

        iCurrentSeg.iX2 = tmpcoords[0];

        iCurrentSeg.iY2 = tmpcoords[1];

        if ( SegType == EGfxSegMoveTo )

			{

            iSubLength = zero;

			}

        else

			{

            iSubLength = iCurrentSeg.Length();

			}

        iSubPos = zero;

        }

    iSubPos += diff;

    // Calcualate or set rotation

    TReal32 rot = 0.0f;

    if ( iAnimMotionRotate < 0 )

        {

        TFloatFixPt  dx  = iCurrentSeg.iX1 - iCurrentSeg.iX2;

        if ( dx == zero )

        {

			if( iAnimMotionRotate == KAnimMotionRotateAuto )

			{

				if(iPrevRotate == 0 || iPrevRotate >= 3.1415926f)

					rot = 3.1415926f + 1.5707963f;

				else

					rot = 1.5707963f; // pi/2

			}

			else // AutoReverse

			{

				if(iPrevRotate >= 0 )

					rot = 1.5707963f;

				else

					rot = -1.5707963f;

            }

		}

        else

            {

            TReal   atan;

            Math::ATan( atan, ( TReal32 )( iCurrentSeg.iY1 - iCurrentSeg.iY2 ), ( TReal32 )dx );

            rot = ( TReal32 ) atan;

			if ( iAnimMotionRotate == KAnimMotionRotateAuto )