/*

* 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 "SVGAnimateTransformElementImpl.h"

#include "SVGElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

#include "SVGPointLexer.h"

#include "SVGStringTokenizer.h"

#include "GfxAffineTransform.h"

_LIT( SEMICOLON, ";" );

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

//

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

CSvgAnimateTransformElementImpl* CSvgAnimateTransformElementImpl::NewL(  const TUint8 aElemID,

																		CSvgDocumentImpl* aDoc )

	{

	CSvgAnimateTransformElementImpl*self    = new ( ELeave )

											  CSvgAnimateTransformElementImpl( aDoc );

	CleanupStack::PushL( self );

	self->ConstructL(  aElemID );

	CleanupStack::Pop();

	return self;

	}

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

//

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

CSvgAnimateTransformElementImpl* CSvgAnimateTransformElementImpl::NewLC(  const TUint8 aElemID,

																		 CSvgDocumentImpl* aDoc )

	{

	CSvgAnimateTransformElementImpl*self    = new ( ELeave )

											  CSvgAnimateTransformElementImpl( aDoc );

	CleanupStack::PushL( self );

	self->ConstructL(  aElemID );

	return self;

	}

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

//

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

void CSvgAnimateTransformElementImpl::ConstructL(  const TUint8 aElemID)

	{

	CSvgAnimationBase::ConstructL( aElemID );

	// Initial length of values is 2 (from and to)

	iTransformValues = new ( ELeave ) RArray<TMatrixData>( 2 );

    TMatrixData mtrx;

    iTransformValues->AppendL( mtrx );

    iTransformValues->AppendL( mtrx );

    iOrgTransformValues = new ( ELeave ) RArray<TMatrixData>( 2 );

    iOrgTransformValues->AppendL( mtrx );

    iOrgTransformValues->AppendL( mtrx );

	iAccumMatrixData.iData[0] = 0;

	iAccumMatrixData.iData[1] = 0;

	iAccumMatrixData.iData[2] = 0;

	iReqAttrFlag=KSVG_ANIMATETRANSFORM_ELEMFLAG;

	}

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

//

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

CSvgAnimateTransformElementImpl::~CSvgAnimateTransformElementImpl()

    {

    if ( iTransformValues )

		{

        iTransformValues->Close();

	    delete iTransformValues;

	    iTransformValues = NULL;

		}

	if ( iOrgTransformValues )

		{

        iOrgTransformValues->Close();

	    delete iOrgTransformValues;

	    iOrgTransformValues = NULL;

		}

    }

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

// Private

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

//

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

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

                                                                                             iMatrixDataSize( 2 ),

																							 iMultipleRendering (EFalse)

    {

    iDataType = KSvgTypeTranslate;

    }

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

// From MSvgEventReceiver

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

void CSvgAnimateTransformElementImpl::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 CSvgAnimateTransformElementImpl::SetAttributeL( const TDesC& aName,

                                                     const TDesC& aValue )

    {

    _LIT( KTmpAttrName, "attributeName" );

    _LIT( KTmpTransform, "transform" );

    _LIT( KTmpFrom, "from" );

    _LIT( KTmpTo, "to" );

    _LIT( KTmpBy, "by" );

    _LIT( KTmpType, "type" );

    _LIT( KTmpScale, "scale" );

    _LIT( KTmpRotate, "rotate" );

    _LIT( KTmpSkewX, "skewX" );

    _LIT( KTmpSkewY, "skewY" );

    _LIT( KTmpValues, "values" );

    _LIT( KTmpGradientTransform, "gradientTransform");

    	if ( !iTargetSet )

			{

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

			iTargetSet = ETrue;

			}

		   	TUint16 lElementId = 0;

		if (iTargetElement)

		    lElementId = iTargetElement->ElemID();

       if ( aName == KTmpAttrName )

	        {

			if(iReqAttrFlag == KAtrSVGTrf)

				{

				iReqAttrFlag = KAtrType;

				}

			else

				{

				iReqAttrFlag = 0;

				}

	    	if( aValue == KTmpTransform &&

				!(lElementId == KSvgRadialGradientElement || lElementId

				 == KSvgLinearGradientElement)

				 )

				{

				iAttrId = KAtrAnimateTransformAttrId;

	       		return KErrNone;

				}

			else if (aValue == KTmpGradientTransform &&

				(lElementId == KSvgRadialGradientElement || lElementId

				 == KSvgLinearGradientElement))

				{

				 iAttrId = KAtrAnimateTransformAttrId;

	       		 return KErrNone;

				}

			else if(aValue == KTmpGradientTransform) // Specifically for Xlink:href case

				{

				 iAttrId = KAtrGradientTransform;

				 return KErrNone;

				}

			else

	            {

	            // value must be not be 'transform'

	            iAttrId = 0xffff;

	            return KErrNone;

	            }

	        }

    else if ( aName == KTmpType )

        {

		if(iReqAttrFlag == KAtrSVGTrf)

			{

			iReqAttrFlag = KAtrAttributeName;

			}

		else

			{

			iReqAttrFlag = 0;

			}

        // Use iDataType to keep transformation type

        if ( aValue == KTmpScale )

            {

            iDataType = KSvgTypeScale;

            iMatrixDataSize = 2;

            }

        else if ( aValue == KTmpRotate )

            {

            iDataType = KSvgTypeRotate;

            iMatrixDataSize = 3;

            }

        else if ( aValue == KTmpSkewX )

            {

            iDataType = KSvgTypeSkewX;

            iMatrixDataSize = 1;

            }

        else if ( aValue == KTmpSkewY )

            {

            iDataType = KSvgTypeSkewY;

            iMatrixDataSize = 1;

            }

        else

            {

            iDataType = KSvgTypeTranslate;  // default transformation

            iMatrixDataSize = 2;

            }

        return KErrNone;

        }

    else if ( aName == KTmpFrom )

        {

        iNoFrom = EFalse;

        // Processing for semi-colon separated data is needed

        DesToMatrixData( aValue, ( *iTransformValues )[0] );

        return KErrNone;

        }

    else if ( aName == KTmpTo )

        {

        iHaveTo = ETrue;

        if ( iNoFrom )

            {

            iAdditive = KAdditiveSum;

            iAdditiveOrg = KAdditiveSum;

            }

        // Processing for semi-colon separated data is needed

        DesToMatrixData( aValue, ( *iTransformValues )[1] );

		iAccumMatrixData.iData[0] = (*iTransformValues)[1].iData[0];

		iAccumMatrixData.iData[1] = (*iTransformValues)[1].iData[1];

		iAccumMatrixData.iData[2] = (*iTransformValues)[1].iData[2];

        return KErrNone;

        }

    else if ( aName == KTmpBy )

        {

        if ( !iHaveTo )

            {

            TInt32  i;

            DesToMatrixData( aValue, ( *iTransformValues )[1] );

            iHaveBy = ETrue;

            if(iNoFrom)

                {

                iAdditive = KAdditiveSum;

                iAdditiveOrg = KAdditiveSum;

                }

            for ( i = 0; i < 3; i++ )

                {

                ( *iTransformValues )[1].iData[i] = ( *iTransformValues )[1].iData[i] +

                                                    ( *iTransformValues )[0].iData[i];

                }

            }

        return KErrNone;

        }

    else if ( aName == KTmpValues )

        {

        TStringTokenizer    tkn ( aValue, SEMICOLON );

        iTransformValues->Reset();

   		iHaveValues = ETrue;

        iNoFrom = EFalse;

        while ( tkn.HasMoreTokens() )

            {

            TMatrixData mtrx;

            DesToMatrixData( tkn.NextToken(), mtrx );

            iTransformValues->AppendL( mtrx );

            }

        TInt lTransformValuesCount = iTransformValues->Count();

		if(lTransformValuesCount > 0)

			{

			iAccumMatrixData.iData[0] = (*iTransformValues)[lTransformValuesCount - 1].iData[0];

			iAccumMatrixData.iData[1] = (*iTransformValues)[lTransformValuesCount - 1].iData[1];

			iAccumMatrixData.iData[2] = (*iTransformValues)[lTransformValuesCount - 1].iData[2];

			}

        return KErrNone;

        }

    return CSvgAnimationBase::SetAttributeL( aName, aValue );

    }

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

// From MSvgEventReceiver

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

TBool CSvgAnimateTransformElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

    return CSvgAnimationBase::ReceiveEventProcL( aEvent, this );

    }

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

// From CSvgAnimationBase

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

TBool CSvgAnimateTransformElementImpl::AnimProcL( MSvgTimerEvent* aEvent )

    {

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

	   {

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

	   		{

	   		}

	   else

		   {

		   CSvgAnimationBase::CheckForEndTimesAndFreezeL(this );

		   return EFalse;

		   }

	   }

    // No animation if 'from' or 'to' is not available

    if ( iTransformValues->Count() < 2 )

		{

        return EFalse;

		}

    // Calc alpha from time [0-255]

    TInt32  alpha;

    TInt32  valix1, valix2, subanimtime;

    TMatrixData mdata;

    iAnimTime->GetAnimTime((aEvent->Time()-iNegativeBeginTime), alpha, valix1, subanimtime );

 // check for the range of valix

	if ( valix1 >= iTransformValues->Count() )

		{

        valix1 = iTransformValues->Count() - 1;

		}

    if ( iNoFrom && !iHaveBy ) //. This is to emulate Adobe.

        {

        if ( alpha > ( KTimeMax >> 1 ) )

            {

            subanimtime = KTimeMax;

            }

        else

            {

            subanimtime = 0;

            return ETrue;

            }

        }

    if ( valix1 >= iTransformValues->Count() - 1 )

		{

        valix2 = valix1;

		}

    else

		{

        valix2 = valix1 + 1;

		}

	mdata.iData[0] = BlendFloat( subanimtime,

							   ( *iTransformValues )[valix1].iData[0],

							   ( *iTransformValues )[valix2].iData[0] );

	mdata.iData[1] = BlendFloat( subanimtime,

							   ( *iTransformValues )[valix1].iData[1],

							   ( *iTransformValues )[valix2].iData[1] );

	mdata.iData[2] = BlendFloat( subanimtime,

							   ( *iTransformValues )[valix1].iData[2],

							   ( *iTransformValues )[valix2].iData[2] );

    // Additive

    /*

     * !!!! Additive="replace" is not supported

     * !!!! Additional implementation needed in MSvgTransformList

     */

    // Set value

    TGfxAffineTransform deltaTr;

    switch ( iDataType )

        {

        case KSvgTypeTranslate:

        deltaTr = TGfxAffineTransform::GetTranslateInstance( mdata.iData[0],

                                                             mdata.iData[1] );

        break;

        case KSvgTypeScale:

        deltaTr = TGfxAffineTransform::GetScaleInstance( mdata.iData[0],

                                                         mdata.iData[1] );

        break;

        case KSvgTypeRotate:

        deltaTr = TGfxAffineTransform::GetRotateInstance( ( TReal32 )

                                                          mdata.iData[0] * 3.1415926f /

                                                          180.0f,

                                                          mdata.iData[1],

                                                          mdata.iData[2] );

        break;

        case KSvgTypeSkewX:

        deltaTr = TGfxAffineTransform::GetShearInstance( ( TReal32 )

                                                         mdata.iData[0]* 3.1415926f /

                                                         180.0f,

                                                         0.0f );

        break;

        case KSvgTypeSkewY:

        deltaTr = TGfxAffineTransform::GetShearInstance( 0.0f,

                                                         ( TReal32 )

                                                         mdata.iData[0]* 3.1415926f /

                                                         180.0f );

        break;

        }

    MSvgTransformList*  trList;

    ( ( CSvgElementImpl * ) iTargetElement )->GetTransform( trList );

    TInt32 matrixIndex;

    ( ( CSvgElementImpl * ) iTargetElement )->GetAttributeIntL( KAtrAnimTransformMatrixIndex, matrixIndex );

   if ( iAdditive == KAdditiveSum ) //.

        {

        if(iNoFrom && subanimtime == KTimeMax && !iHaveBy)

	        {

	        iTargetElement->SetOverwriteTransforms( ETrue );

	        }

		/*else

	        {

	        //if additive = sum and there is a from or a by then dont overwrite the transform

	        iTargetElement->iOverwriteTransforms = EFalse;

	        }*/

	    if(iHaveTo && iNoFrom)

	    {

	    	iTargetElement->SetOverwriteTransforms(ETrue);

	    	trList->ReplaceItem(deltaTr, matrixIndex);

	    }

	    else 

	    {

        TGfxAffineTransform curMatrix = trList->GetItem( matrixIndex );

        curMatrix.Concatenate( deltaTr );

        trList->ReplaceItem( curMatrix, matrixIndex );

	    }

        }

    else

        {

        iTargetElement->SetOverwriteTransforms( ETrue );

        trList->ReplaceItem( deltaTr, matrixIndex );

        }

    if(iFill == KAnimFillFreeze)

	    {

	    iEndMatrix = deltaTr;

	    }

	CSvgAnimationBase::CheckForEndTimesAndFreezeL(this );

    return ETrue;

    }

//

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

//

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

void CSvgAnimateTransformElementImpl::SetFillValueL()

    {

    MSvgTransformList*  trList;

    ( ( CSvgElementImpl * ) iTargetElement )->GetTransform( trList );

     TInt32              matrixIndex;

     iTargetElement->GetAttributeIntL( KAtrAnimTransformMatrixIndex, matrixIndex );

    iFillMatrix = trList->GetItem(matrixIndex);

    }

//

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

//

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

void CSvgAnimateTransformElementImpl::SetToOriginalL()

    {

    MSvgTransformList*  trList;

	TInt32 matrixIndex;

	iTargetElement->GetAttributeIntL( KAtrAnimTransformMatrixIndex, matrixIndex );

    ( ( CSvgElementImpl * ) iTargetElement )->GetTransform( trList );

    trList->ReplaceItem( iFillMatrix /*TGfxAffineTransform()*/,

                             matrixIndex );

    iTargetElement->SetOverwriteTransforms( EFalse );

    }