/*

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

#include "SVGElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

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

// Two phase construction

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

CSvgAnimateElementImpl* CSvgAnimateElementImpl::NewL(  const TUint8 aElemID,

                                                      CSvgDocumentImpl* aDoc )

    {

    CSvgAnimateElementImpl* self    = new ( ELeave )

                                      CSvgAnimateElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL( aElemID );

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgAnimateElementImpl* CSvgAnimateElementImpl::NewLC(  const TUint8 aElemID,

                                                       CSvgDocumentImpl* aDoc )

    {

    CSvgAnimateElementImpl* self    = new ( ELeave )

                                      CSvgAnimateElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID );

    return self;

    }

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

// Protected

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

//

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

void CSvgAnimateElementImpl::ConstructL(  const TUint8 aElemID )

    {

    CSvgAnimationBase::ConstructL( aElemID );

    iReqAttrFlag=KSVG_ANIMATE_ELEMFLAG;

	iIsInheritedAttribute = EFalse;

    }

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

//

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

CSvgAnimateElementImpl::~CSvgAnimateElementImpl()

    {

    }

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

// Protected

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

//

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

CSvgAnimateElementImpl::CSvgAnimateElementImpl( CSvgDocumentImpl* aDoc ) : CSvgAnimationBase( aDoc )

    {

    }

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

// From SVG DOM

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

// From MSvgEventReceiver

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

//

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

void CSvgAnimateElementImpl::ResetReferenceElementL()

    {

    if(iTargetElement != NULL )

        {

        if( ((iTargetElement->iAnimateAttrSet == NULL) || (iTargetElement->iAnimateAttrSet->Find(iAttrId) == KErrNotFound) ) )

            {

            if  ( iInitDone && iAnimStatus != KAnimNotActive)

                {

				iCheckFirstAnim= ETrue;

                SetToOriginalL();

                if( !(iTargetElement->iAnimateAttrSet) )

                    {

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

                    }

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

                }

            }

        }

    }

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

// From MSvgEventReceiver

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

//

TBool CSvgAnimateElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

    return CSvgAnimationBase::ReceiveEventProcL( aEvent, this );

    }

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

// From CSvgAnimationBase

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

//

TBool CSvgAnimateElementImpl::AnimProcL( MSvgTimerEvent* aEvent )

    {

    if(iAnimStatus == KAnimActive && !iHadBegun)

		{

		SetFromValuesL();

		iHadBegun = ETrue;

		}

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

	   {

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

	   		{

	   		}

	   else

		   {

		   CSvgAnimationBase::CheckForEndTimesAndFreezeL(this);

		   return EFalse;

		   }

	   }

    // Calc alpha from time [0-255]

    TInt32  alpha;

    TInt32  valix, subanimtime;

    switch ( iDataType )

        {

        // x, y, width, height,

        // rx, ry, cx, cy, radius

        // x1, y1, x2, y2

        case KSvgTypeOpacity:

        case KSvgTypeLength:

            {

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

            TFloatFixPt  v1  = iFromFloat;

            TFloatFixPt  v2  = iToFloat;

            TFloatFixPt  lCurValue;

            if(iHaveBy &&  iCurrentRepeatCount > 0 && iAccumulate == KAccumSum )

                {

                v1= KFloatFixZero;

                v2 = iToFloat - iFromFloat;

                }

            if ( iValuesFloat->Count() > 0 )

                {

                // check for the range of valix

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

					{

					valix = iValuesFloat->Count() - 1;

					}

                v1 = ( *iValuesFloat )[valix];

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

                    {

                    v2 = ( *iValuesFloat )[valix];

                    }

                else

                    {

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

                    }

                alpha = subanimtime;

                }

            lCurValue = BlendFloat( alpha, v1, v2 );

            if( iAccumulate == KAccumSum && !iNoFrom )

                {

                TFloatFixPt lRepeatCount((TInt) iCurrentRepeatCount) ;

                if(iValuesFloat->Count() > 0)

                    {

                    lCurValue += ((*iValuesFloat) [iValuesFloat->Count() -1]) * lRepeatCount ;

                    }

                else

                    {

                    TFloatFixPt lRepeatCount((TInt) iCurrentRepeatCount) ;

                    lCurValue += lRepeatCount * (v2);

                    if(iHaveBy &&  iCurrentRepeatCount > 0)

                        {

                        lCurValue += iFromFloat;

                        }

                    }

                }

            if ( ( iFill == KAnimFillFreeze ) )

                {

                iEndFloat = lCurValue;

                }

            if ( ( iAdditive == KAdditiveSum ) && !iNoFrom ) //.

                {

                TFloatFixPt  lOrig;

                iTargetElement->GetAttributeFloat( iAttrId, lOrig );

                lCurValue += lOrig;

                }

            iTargetElement->SetAttributeFloatL( iAttrId, lCurValue );

            }

            break;

        case KSvgTypeList:

        case KSvgTypePath:

            {

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

            CGfxGeneralPath*v1  = iFromPath;

            CGfxGeneralPath*v2  = iToPath;

            if ( iValuesPath->Count() > 0 )

                {

				// check for the range of valix

				if(valix >= iValuesPath->Count() )

					{

					valix = iValuesPath->Count() - 1;

					}

                v1 = iValuesPath->operator[]( valix );

                if ( valix + 1 >= iValuesPath->Count() )

                    {

                    v2 = iValuesPath->operator[]( valix );

                    }

                else

                    {

                    v2 = iValuesPath->operator[]( valix + 1 );

                    }

                alpha = subanimtime;

                }

            CGfxGeneralPath*lCurPath    = CGfxGeneralPath::NewLC();

            BlendPathL( alpha, v1, v2, lCurPath );

            if ( iAdditive == KAdditiveSum )

                {

                AddPathsL( lCurPath, iOrgPath );

                }

            else

                {

                // User current blended value

                }

            if ( ( iFill == KAnimFillFreeze ) )

                {

                CopyPathsL( iEndPath, lCurPath );

                }

            iTargetElement->SetAttributePathL( iAttrId, lCurPath );

            CleanupStack::PopAndDestroy( 1 ); // lCurPath

            }

            break;

        case KSvgTypeTransform:

        break;

        case KSvgTypeColor:

            {

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

            TInt32  v1  = iFromInt;

            TInt32  v2  = iToInt;

            TInt32  lCurValue;

            if(iHaveBy &&  iCurrentRepeatCount > 0 && iAccumulate == KAccumSum )

                {

                v1= 0;

                v2 = SubtractColor(iToInt,iFromInt);

                }

            if ( iValuesInt->Count() > 0 )

                {

                // check for the range of valix

				if(valix >= iValuesInt->Count() )

					{

					valix = iValuesInt->Count() - 1;

					}

                v1 = ( *iValuesInt )[valix];

                if ( valix + 1 >= iValuesInt->Count() )

                    {

                    v2 = ( *iValuesInt )[valix];

                    }

                else

                    {

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

                    }

                alpha = subanimtime;

                }

                if ( iNoFrom ) //. This is to emulate Adobe.

                    {

                    if ( alpha > ( KTimeMax >> 1 ) )

                        {

                        alpha = KTimeMax;

                        }

                    else

                        {

                        alpha = 0;

                        }

                    }

            lCurValue = BlendColor( alpha, v1, v2 );

            if( iAccumulate == KAccumSum && !iNoFrom )

                {

                    if(iValuesInt->Count() > 0)

                        {

                            TInt32  ColorToAdd = 0;

                            ColorToAdd = ((*iValuesInt) [iValuesInt->Count() -1]);

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

                                {

                                lCurValue = AddColor( lCurValue,  ColorToAdd );

                                }

                        }

                    else

                        {

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

                                {

                                lCurValue = AddColor( lCurValue, v2 )   ;

                                }

                            if(iHaveBy &&  iCurrentRepeatCount > 0)

                                {

                                lCurValue = AddColor( lCurValue,  iFromInt );

                                }

                        }

                }

            		// Fix for accum_addit_7.svg

            if ( ( iFill == KAnimFillFreeze ) )

                {

                iEndInt = lCurValue;

                iEndInt = lCurValue;

                }

            if ( ( iAdditive == KAdditiveSum ) && !iNoFrom ) //.

                {

                TInt32  lOrig;

                iTargetElement->GetAttributeIntL( iAttrId, lOrig );

                lCurValue = AddColor( lCurValue, lOrig );

                }

            iTargetElement->SetAttributeIntL( iAttrId, lCurValue );

            }

            break;

        case KSvgTypeTextAnchor:

        case KSvgTypeVisibility:

        case KSvgTypeGradientUnits:

        case KSvgTypeSpreadMethod:

        case KSvgTypeDisplay:

            {

			iAnimTime->GetAnimTimeForEnumeration( (aEvent->Time()-iNegativeBeginTime), alpha, valix, iKeyTimesPresent);

            TInt32  v1  = iFromInt;

            TInt32  v2  = iToInt;

            TInt32  lCurValue;

            if ( iValuesInt->Count() > 0 )

                {

				  // check for the range of valix

				if(valix >= iValuesInt->Count() )

					{

					valix = iValuesInt->Count() - 1;

					}

                if(iKeyTimesPresent)

					{

					if ( valix < iValuesInt->Count() )

						{

           				lCurValue = (*iValuesInt)[valix];

						}

					else

						{

						lCurValue = (*iValuesInt)[valix-1];

						}

					}

				else

					{

                TInt index = ( alpha * iValuesInt->Count() / 255 ) ;

					if(index == iValuesInt->Count()) index--;

                if ( index >= 0 )

                    {

                    lCurValue = (*iValuesInt)[index];

                    }

                else

                    {

                    lCurValue = (*iValuesInt)[0];

                    }

                }

                }

            else

                {

                if(alpha>=128) // average of 256 to determine which value should predominate

                    {

                    lCurValue = v2;

                    }

                else

                    {

                    lCurValue = v1;

                    }

                }

            if ( ( iFill == KAnimFillFreeze ) )

                {

                iEndInt = lCurValue;

                }

            iTargetElement->SetAttributeIntL( iAttrId, lCurValue );

            }

	       break;

		case KSvgTypeViewBox:

			 {

             DoViewBoxAnimProcL(aEvent);

             break;

			 }

        }

    CSvgAnimationBase::CheckForEndTimesAndFreezeL(this);

    return ETrue;

    }

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

//

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

void CSvgAnimateElementImpl::BlendPathL( TInt32 aAlpha,

                                         CGfxGeneralPath* aFromPath,

                                         CGfxGeneralPath* aToPath,

                                         CGfxGeneralPath*& aBlendPath )

    {

    if ( aFromPath && aToPath )

        {

        aBlendPath->SetPointTypeArrayL( aFromPath->PointTypeArray() );

        RArray<TFloatFixPt>* lCurPoints  = new ( ELeave ) RArray<TFloatFixPt>( 20 );

        CleanupStack::PushL( lCurPoints );

        lCurPoints->AppendL(NULL);

        lCurPoints->Remove(0);

	    RArray<TFloatFixPt>* fromPoints  = aFromPath->PointCoordsArrayAll();

	    RArray<TFloatFixPt>* toPoints    = aToPath->PointCoordsArrayAll();

	    TInt            lFromcount       = fromPoints->Count();

		TInt            lTocount       = toPoints->Count();

	    TInt            i           = 0;

	    TFloatFixPt          lCurPoint;

	    while (i < lFromcount && i < lTocount )

	        {

	        lCurPoint = BlendFloat( aAlpha,

	                                fromPoints->operator[]( i ),

                                    toPoints->operator[]( i ) );

            lCurPoints->AppendL( lCurPoint );

            i++;

            }

        aBlendPath->SetPointCoordsArrayL( lCurPoints );

	    lCurPoints->Close();

	    CleanupStack::PopAndDestroy( 1 ); // lCurPoints

	    }

    }

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

//

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

void CSvgAnimateElementImpl::AddPathsL( CGfxGeneralPath*& aPathResult,

                                        CGfxGeneralPath* aPath1 )

    {

    RArray<TFloatFixPt>* lCurPoints  = new ( ELeave ) RArray<TFloatFixPt>( 20 );

    CleanupStack::PushL( lCurPoints );

    lCurPoints->AppendL(NULL);

    lCurPoints->Remove(0);

    RArray<TFloatFixPt>* points1 = aPath1->PointCoordsArrayAll();

    RArray<TFloatFixPt>* result  = aPathResult->PointCoordsArrayAll();

    TInt            pcount   = points1->Count();

    TInt            rcount   = result->Count();

    TInt            i       = 0;

    TFloatFixPt          lCurPoint;

    while ( i < pcount && i < rcount )

        {

        lCurPoint = points1->operator[]( i ) + result->operator[]( i );

        lCurPoints->AppendL( lCurPoint );

        i++;

        }