/*

* Copyright (c) 2005 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 FILES

#include "SVGAnimationElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

#include "SVGAnimationBase.h"

#include "SVGEvent.h"

#include "SVGEventHandler.h"

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

// ============================= LOCAL FUNCTIONS ===============================

// Setter functions

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

// SetRecursionVariable: Set aIsRecursion to indicate that the element has been

// cloned or not.

//

// Returns: TFloatFixPt

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

//

void CSvgAnimationElementImpl::SetRecursionVariable(TBool aIsRecursion)

	{

	iUseInRecursion = aIsRecursion;

	}

// ============================ MEMBER FUNCTIONS ===============================

// Getter functions

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

// X: returns iX

//

// Returns: TFloatFixPt

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

//

TFloatFixPt CSvgAnimationElementImpl::X()

    {

    return iX;

    }

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

// Y: returns iY

//

// Returns: TFloatFixPt

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

//

TFloatFixPt CSvgAnimationElementImpl::Y()

    {

    return iY;

    }

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

// Width: returns iWidth

//

// Returns: TFloatFixPt

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

//

TFloatFixPt CSvgAnimationElementImpl::Width()

    {

    return iWidth;

    }

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

// Height: return iHeight

//

// Returns: TFloatFixPt

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

//

TFloatFixPt CSvgAnimationElementImpl::Height()

    {

    return iHeight;

    }

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

// PreservRatio: Returns the PreserveAspecRatio's setting. Mainly used by encoder.

//

// Returns: Descriptor of PreserveAspecRatio value

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

//

const TDesC& CSvgAnimationElementImpl::PreservRatio()

    {

    return (TDesC&) *iPreservRatio;

    }

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

// SetAttributeL: Called by Contenthandler or decoder to set attributes

//

// Returns: TInt error code

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

//

TInt CSvgAnimationElementImpl::SetAttributeL( const TDesC& aName,

                                        const TDesC& aValue )

    {

    _LIT( KXlink, "xlink:href" );

    _LIT( KPreserveAspectRatio, "preserveAspectRatio" );

    if ( aName == KXlink )

        {

        // 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 );

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

				{

				iReferencedElement = ( CSvgElementImpl * )

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

				if(iReferencedElement == NULL)

					{

					// failure in finding the referenced element

					CleanupStack::PopAndDestroy( 1 ); // tBufC

					return KErrReferencedElementNotFound;

					}

				}

			CleanupStack::PopAndDestroy( 1 ); // tBufC

			}

		}

	else if ( aName == KPreserveAspectRatio )

    	{

        iPreservRatio = aValue.AllocL();

    	}

	else

	    {

    	CSvgAnimationBase::SetAttributeL(aName, aValue);

	    }

	return KErrNone;

    }

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

// SetAttributeFloatL: Called by Contenthandler or decoder to set attributes

//

// Returns: TInt error code

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

//

TInt CSvgAnimationElementImpl::SetAttributeFloatL( const TInt aNameId,

                                                   const TFloatFixPt aValue )

    {

    switch ( aNameId )

        {

        case KAtrX:

            iX = aValue;

            break;

        case KAtrY:

            iY = aValue;

            break;

        case KAtrWidth:

            iWidth = aValue;

            break;

        case KAtrHeight:

            iHeight = aValue;

            break;

        default:

            return CSvgElementImpl::SetAttributeFloatL( aNameId, aValue );

        }

    return KErrNone;

    }

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

// GetAttributeFloat: returns value of the floating attribute

//

// Returns: TInt error code

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

//

TInt CSvgAnimationElementImpl::GetAttributeFloat( const TInt aNameId, TFloatFixPt& aValue )

    {

    switch ( aNameId )

        {

        case KAtrX:

				 aValue = iX ;

			     break;

        case KAtrY:

				aValue = iY ;

			    break;

        case KAtrWidth:

				aValue = iWidth ;

		        break;

        case KAtrHeight:

				aValue = iHeight ;

		        break;

        default:

            return CSvgElementImpl::GetAttributeFloat( aNameId, aValue );

        }

    return KErrNone;

    }

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

// GetUriRefId: Get the id of reference target id

//

// Returns: TDesC& id

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

//

//const TDesC& CSvgAnimationElementImpl::GetUriRefId()

//	{

//	return (TDesC&) (iReferencedElement->Id());

//	}

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

// IsUriRefSet: Return true or not if uri is set

//

// Returns: TBool

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

//

TBool CSvgAnimationElementImpl::IsUriRefSet()

	{

    if(iReferencedElement)

        {

		return ETrue;

	    }

	  else

	    {

		return EFalse;

	    }

	}

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

// ReceiveEventL: The implemented function will be called whenever subscribed

// events are received.

//

// From MSvgEventReceiver

//

// Return: TBool ETrue if redraw is needed

//               EFalse if redraw is not needed

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

//

TBool CSvgAnimationElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

    // Processing events after begin time

	if( CSvgElementImpl::IsSVGEnginePaused())

    {

    	return EFalse;

    }

	CSvgEngineImpl* engine = ((CSvgDocumentImpl*)iOwnerDocument)->Engine();

	if (engine == NULL)

		{

		return EFalse;

		}

    TInt32 lEngineCurrentTime = engine->CurrentTIme();

    if ( lEngineCurrentTime < iAbsoluteBeginTime)

        {

        // not begin yet.

        return ETrue;

        }

    else

        {

        // rewrite engine time to simulate different timer

    	if ( aEvent->EventType() == ESvgEngineEventTimer )

    		{

        	((MSvgTimerEvent*)aEvent)->SetTime( (TInt32)(lEngineCurrentTime

        		- iAbsoluteBeginTime ));

    		}

        }

    // Basically forward received events to all its children as if they receive

    // event from DocumentImpl.

    if ( iAnimationEventHandler->ProcessEventL( aEvent ))

        {

        if (iInitSortList)

            {

            iAnimationEventHandler->SortEventList();

            iInitSortList = EFalse;

            }

        iAnimationEventHandler->DoAnimProcL(aEvent);

        engine->RedrawL();

        }

    else

        {

        // this is to keep the dom in its final state.

        if(aEvent->EventType() == ESvgEngineEventTimer)

            {

            iAnimationEventHandler->DoAnimProcL(aEvent);

            }

        }

    // Process key event separately.

	if (aEvent->EventType() == ESvgEngineEventKeyPress)

		{

		}

    // return true to be redrawn

    return ETrue;

    }

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

// RecursionVariable: Getter function that could be called by Contenthandler or

// decoder to determine if the element has been cloned.

// elements

//

// Return: TBool ETrue if the element is cloned already

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

//

TBool CSvgAnimationElementImpl::RecursionVariable()

	{

	return iUseInRecursion;

	}

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

// SetRefElemById: Called by Contenthandler or decoder to set referenced

// elements

//

// Return: none

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

//

TInt  CSvgAnimationElementImpl::SetRefElemById(const TDesC& aName)

	{

	 iReferencedElement = ( CSvgElementImpl * )

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

     if( iReferencedElement == NULL )

     	{

     	return KErrNotFound;

     	}

     else

     	{

         return KErrNone;

    	}

	}

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

// SetReferenceElementL: Called by Contenthandler or decoder to clone referenced

// element which has been determined in SetRefElemById(...).

//

// Return: none

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

//

void CSvgAnimationElementImpl::SetReferenceElementL()

    {

    _LIT( KPreserveAspectRatio, "preserveAspectRatio" );

	if(!RecursionVariable())

		{

		if( iReferencedElement != NULL )

			{

			// Setting iUseInRecursion to True so that the Call to CloneL

			// is not called to this instance of use in this recursion

			SetRecursionVariable(ETrue);

     		CSvgElementImpl* theElement = (CSvgElementImpl *)iReferencedElement->CloneL((MXmlElement*)this);

     		CleanupStack::PushL(theElement);

			this->CXmlElementImpl::AppendChildL(theElement);

			CleanupStack::Pop();

			if(!RecursionVariable())

				{

				// The Recursion variable is set to false only when the Cloning

				// goes into loop.

				// Using this information and then Setting the Recursion variable

				// back to True to use the information to set error code in

				// StartElementL in Content Handler

				//

				SetRecursionVariable(ETrue);

				}

			else // Normal CloneL loop exit

				{

				// Setting iUseInRecursion back to False

				SetRecursionVariable(EFalse);

				}

                CSvgDocumentImpl* doc = ( CSvgDocumentImpl* ) OwnerDocument();

                CSvgSvgElementImpl* lSvgRoot = (CSvgSvgElementImpl*) doc->RootElement();

                if (iPreservRatio != NULL)

                	{

                	lSvgRoot->SetAttributeL( KPreserveAspectRatio, iPreservRatio->Des() );

                	}

                lSvgRoot->SetWidth( iX );

                lSvgRoot->SetHeight( iY );

			}

    	}

    }

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

// ResetEventListener: Reset event listeners for it's children

//

// Returns: none

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

//

void CSvgAnimationElementImpl::ResetEventListener()

    {

    FindAllAnimationElements( (CSvgElementImpl* )this, iMyAnimationElementList );

    // Remove event listening for every animation elements that are child of

    // this Animation element. This is to implement a separated time container

    //

    // Instead, register event linstening to the event handler of this element.

    //

    TInt myAnimationEleListCnt = iMyAnimationElementList->Count();

	for (int i=0; i<myAnimationEleListCnt; i++)

    	{

		CSvgElementImpl* lCurElem =

		    (CSvgElementImpl*)iMyAnimationElementList->operator[](i);

		// Removing...

        ((CSvgDocumentImpl*)iOwnerDocument)->RemoveFromEventReceiverList(lCurElem);

        // Adding...

        TUint8 eventMask = iAnimationEventHandler->EventMask(lCurElem);

        TRAPD(err, iAnimationEventHandler->AddToEventReceiverListL( lCurElem, eventMask ));

        if (err != KErrNone)

            {

            #ifdef _DEBUG

            _LIT(msg, "CSvgAnimationElementImpl::ResetEventListener():Can't add myself to event receiverList");

            RDebug::Print(msg);

            #endif //_DEBUG

            }

        }

    }

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

// RemoveEventListener: Remove event listeners for it's children

//

// Returns: none

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

//

void CSvgAnimationElementImpl::RemoveEventListener()

    {

    FindAllAnimationElements( (CSvgElementImpl* )this, iMyAnimationElementList );

    // Remove event listening for every animation elements that are child of

    // this Animation element. This is to implement a separated time container

    //

    // Instead, register event linstening to the event handler of this element.

    //

	for (int i=0; i<iMyAnimationElementList->Count(); i++)

    	{

		CSvgElementImpl* lCurElem =

		    (CSvgElementImpl*)iMyAnimationElementList->operator[](i);

		// Removing...

        iAnimationEventHandler->RemoveFromEventReceiverList( lCurElem );

        }

    }

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

// CSvgAnimationElementImpl: Find all animation elements and save it to aList

//

// Returns: none

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

//

void CSvgAnimationElementImpl::FindAllAnimationElements(

                               CSvgElementImpl* aElement,

                               RPointerArray<CSvgElementImpl>* aList )

    {

    CSvgElementImpl* child = (CSvgElementImpl*)aElement->FirstChild();

    while ( child != NULL )

    	{

        if ( IsAnimationElement(child) )

        	{

            aList->Append( child );

        	}

        FindAllAnimationElements( child, aList );

        child = (CSvgElementImpl*)child->NextSibling();

    	}

    }

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

// IsAnimationElement: A utility function that check if the element

// is an animation element.

//

// Returns: TBool ETrue if the element is a animation element.

//                EFalse if the element is not an animation element.

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

//

TBool CSvgAnimationElementImpl::IsAnimationElement(CSvgElementImpl* aElement)

    {