/*

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

#include "SVGDocumentImpl.h"

#include "SVGSchemaData.h"

#include "SVGAnimTimingParser.h"

#include "SVGEngineImpl.h"

#include "SVGAnimationBase.h"

#include "SVGRectElementImpl.h"

#include "SVGEvent.h"

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

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

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

// RemoveTargetElement: A utility function that renmoves target element.

// Remove target element and all its child from its parent level.

// Allocated Style properties of the target elements have to be deleted here.

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

//

void CSvgDiscardElementImpl::RemoveTargetElement()

	{

    if (iTargetElement!= NULL)

        {

		CSvgElementImpl* lParent = (CSvgElementImpl*)iTargetElement->ParentNode();

		if ( lParent != NULL )

		    {

		    lParent->RemoveChild(iTargetElement);

		    }

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

			{

			// remove all children

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

		    CSvgElementImpl* sib = (CSvgElementImpl*) NULL;

		    while ( (child != NULL ) || sib != (CSvgElementImpl*) NULL )

		    	{

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

		        // remove myself later

				if (child != this)

					{					

					iTargetElement->RemoveChild(child);

					delete child;

					}

				child = sib;

		    	}

			}

        // make sure that the target element is not root

        if ( iTargetElement->ElemID() != KSvgSvgElement )

        	{

			delete iTargetElement;        	

			iTargetElement = NULL;

        	}

        iRemoveMyself = ETrue;

        }

	}

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

// FindTargetElementL: A utility function that finds target element

// and adjust the begin time.

//

// Returns: TBool ETrue if target is set.

//                EFalse if target is not found.

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

//

TBool CSvgDiscardElementImpl::FindTargetElementL()

	{

	if (iTargetElement)

		return ETrue;

	// Target could be set from one of the following ways:

	// 1) Defined as SyncBased value.  ==> get element

	// 2) xlink-href defined.          ==> get element

	// 3) Invalid element id           ==> Ignore

	// 4) No specified xlink-href nor other element id. ==> Use parent

	if ( iHrefValueDefined )

    	{

    	// Case 2 & 3

    	TPtrC lPtr = iTargetId->Des();

		iTargetElement = ( CSvgElementImpl * )

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

    	if (iTargetElement == NULL)

        	{

        	// Case 3

        	// Ignore and remove myself later.

        	iRemoveMyself = ETrue;

        	return EFalse;

        	}

    	}

    else // Case 4

        {

        // Set parent to target only when the parent is an animation element

		iTargetElement = ( CSvgElementImpl * ) ParentNode();

        }

	// Target element should be determined by now.

	// Check to see if the target element is animatable.

	// If not, remove myself.

	// Calculate begin time.

	if ( iSyncValueDefined )

		{

		// Get reference target element

		iRefTargetElement = ( CSvgElementImpl * )

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

	    // Only Syncbased begin time

	    if (!iEventValueDefined)

	    	{

	    	// If specified element doesn't exist or the element is not animated,

	    	// remove myself.

	    	if ((iRefTargetElement == NULL) /*|| !IsAnimationElement(iRefTargetElement)*/)

	        	{

	        	// No referenced element or not animatable element (no begin/end attr)

	        	// ==> Ignore and remove myself later.

	        	iRemoveMyself = ETrue;

	        	return EFalse;

	        	}

	        // re-calculate begin time. e.g. id1.start+5s

	        if (iBeginReferenceEvent == ESvgEventBeginEvent)

	        	{

				iAbsoluteBeginTime +=

					((CSvgAnimationBase*)iRefTargetElement)->GetAbsoluteBeginTime();

	        	}

	        else if (iBeginReferenceEvent == ESvgEventEndEvent)

	        	{

				iAbsoluteBeginTime +=

					((CSvgAnimationBase*)iRefTargetElement)->GetEndTime();

	        	}

	    	}

	    else // iEventValueDefined is TRUE

	    	{

	    	// Listen external events

	        ((CSvgDocumentImpl*)

	        	iOwnerDocument)->AddToEventReceiverListL(iRefTargetElement,

                                                KSvgEventMaskExternalUI);

	    	}

		}

	else if (iEventValueDefined)

    	{

       	// Listen external events

        ((CSvgDocumentImpl*)

        	iOwnerDocument)->AddToEventReceiverListL(iTargetElement,

                                            KSvgEventMaskExternalUI);

    	}

    return ETrue; // Set Target element

	}

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

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

// contains animation element(s).

//

// Returns: TBool ETrue if the element contains animation element(s)

//                EFalse if the element doesn't animated.

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

//

/*

TBool CSvgDiscardElementImpl::HasAnimationElements(CSvgElementImpl* aElement)

    {

	TBool lFound = EFalse;

	// Return immediately if the target element is already an animation element.

	if (IsAnimationElement(aElement))

		return ETrue;

	// Look through childs

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

    while ( child != NULL )

    	{

        if ( IsAnimationElement(child) )

        	{

        	lFound = ETrue;

        	break;

        	}

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

    	}

    if (lFound)

    	return ETrue;

    return EFalse;

    }

*/

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

// 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 CSvgDiscardElementImpl::IsAnimationElement(CSvgElementImpl* aElement)

    {

	TInt id = aElement->ElemID();

    return (( id == KSvgAnimateElement ) ||

	        ( id == KSvgAnimateMotionElement ) ||

	        ( id == KSvgAnimateTransformElement ) ||

	        ( id == KSvgSetElement ) ||

	        ( id == KSvgAnimateColorElement ));

    }

*/

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

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

// SetAttributeL: The implemented function will be called from CSvgContentHandler.

//

// From CSvgElementImpl

//

// There will be two attributes been set: begin and xlink:href.

// If xlink:href is not specified, the target element will be parent element

// If begin time is not specifid, the target element will be remove immdeiately.

//

// Returns: ETrue always in this case.

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

//

TInt CSvgDiscardElementImpl::SetAttributeL( const TDesC& aName,

                                            const TDesC& aValue )

    {

    _LIT( KTmpXlinkHref, "xlink:href" );

    _LIT( KTmpBegin, "begin" );

    // If not xlink:href, it must be attribute "begin"

     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 the Decoder

		iHrefValueDefined = ETrue;

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

		if ( pos == 0 )

			{

			if (iTargetId)

				{

				delete iTargetId;

				iTargetId = NULL;

				}

			iTargetId = aValue.AllocL();

	    	TPtr tPtr = iTargetId->Des();

			tPtr.Delete(pos, 1);

			}

        }

    else if ( aName == KTmpBegin )

        {

        CSvgAnimTimingParser* atParser = CSvgAnimTimingParser::NewLC( aValue, this );

        TInt32     clockValue;

        TReal32    lRepeatBeginValue;

        atParser->Parse( iBeginSyncElementId,

                         iBeginReferenceEvent,

                         clockValue,

                         lRepeatBeginValue,

                         ETrue);

   		iAbsoluteBeginTime = clockValue;

        if ( iBeginSyncElementId.Size() != 0 )

        	{

        	iSyncValueDefined = ETrue;

        	}

        if ( iBeginReferenceEvent != ESvgEventNone )

        	{

        	iEventValueDefined = ETrue;

        	iRefBeginTime = clockValue;

	   		iAbsoluteBeginTime = KTimeIndefinite;

        	if (iBeginReferenceEvent == ESvgEventKey)

        		{

        		iKeyValue = atParser->AccekeyValue();

        		}

        	}

        CleanupStack::PopAndDestroy( 1 );     // atParser

        }

	CSvgElementImpl::SetAttributeL(aName,aValue);

    return KErrNone;

    }

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

// 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 CSvgDiscardElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

	if (iRemoveMyself)

		{

		// Two reasons to remove myself.

		// 1) when discard element is not sepcified inside of the target

	    //    element so the object is not removed automatically along with

	    //    target element.

	    // 2) Invalid begin time

		iTargetElement = ( CSvgElementImpl * ) ParentNode();

		iTargetElement->RemoveChild(this);

		delete this;

		return EFalse;

    	}

	// Looking for target as soon as first event received. Also adject time

	// according to timeing attribute.

	if (!FindTargetElementL())

		{

		// Target not found, exit and remove myself next time

		return EFalse;

		}

	// Target element should be identified by now.

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

	if (engine == NULL)

		{

		return EFalse;

		}

    TInt32 lEngineCurrentTime = engine->CurrentTIme();

	// User input event

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

		{

        MSvgUiKeyEvent* evt   = ( MSvgUiKeyEvent* ) aEvent;

    	if (evt->KeyCode() == iKeyValue)

    	    {

    		// Remove target immediately

        	RemoveTargetElement();

        	engine->RedrawL();

        	return ETrue;

    	    }

        return EFalse;

		}

	// Timer event

    if (aEvent->EventMask() == KSvgEventMaskTimer)

        {

        if (lEngineCurrentTime >= iAbsoluteBeginTime)

            {

            // Time to remove target

        	RemoveTargetElement();

            }

        }

    // Internal event

    else if ((aEvent->EventMask() == KSvgEventMaskInternal )

    		 && (!iRefBeginTimeSet))

    	{

        MSvgInternalEvent*  evt = ( MSvgInternalEvent* ) aEvent;

        TSvgEvent s_evt = evt->SvgEvent();

        if (s_evt == iBeginReferenceEvent)

        	{

	    	// Event other than AccessKey

	    	// Check to see if there is a clock associated with the event.

	    	 if (s_evt == iBeginReferenceEvent)

	    		{

	    		// This is some form of event+(-)clock so delay removing

	    		// Note that once the reference time is set, the absolutetime

	    		// can't be changed with other events.

	    		if (iRefTargetElement != NULL)

	    			{

					// This is a syncbased event

		    		if (evt->ObjectAddress() == iRefTargetElement)

		    			{

			    		iAbsoluteBeginTime = lEngineCurrentTime + iRefBeginTime;

			    		iRefBeginTimeSet = ETrue;

			    		return EFalse;

		    			}

	    			}

	    		else

	    			{

					// Not syncbased event

		    		if (evt->ObjectAddress() == iTargetElement)

		    			{

			    		iAbsoluteBeginTime = lEngineCurrentTime + iRefBeginTime;

			    		iRefBeginTimeSet = ETrue;

			    		return EFalse;

		    			}

	    			}

	    		} //  if (s_evt == iBeginReferenceEvent)...

	    	else

	    		{

	    		// No clock assoicated with the event.

	    		if (iRefTargetElement != NULL)

	    			{

	    			// This is a syncbased event

		    		if (evt->ObjectAddress() == iRefTargetElement)

		    			{

			    		// Remove target immediately

			        	RemoveTargetElement();

		    			}

	    			}

				// Not syncbased event

	    		else if (evt->ObjectAddress() == iTargetElement)

	    			{

		    		// Remove target immediately

		        	RemoveTargetElement();

	    			}

	    		}

        	} // if (s_evt == iBeginReferenceEvent)...

    	} //if ((aEvent->EventMask() == KSvgEventMaskInte...

    else

   		{

   		// Not interested event

    	return EFalse;

   		}

    // return true to be redrawn

    return ETrue;

    }

// Setter functions

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

// SetTargetId: Set iTargetId to the object. Mainly used by decoder.

//

// Returns: void

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

//

void CSvgDiscardElementImpl::SetTargetId(const TDesC& aTargetId)

    {

    delete iTargetId;

    iTargetId = NULL;

    TRAPD(err, iTargetId = aTargetId.AllocL());

    if (err != KErrNone)

        {

        // Only display error message. If this failed, iTargetId can safely to be null.

        #ifdef _DEBUG

            RDebug::Printf("CSvgDiscardElementImpl::SetTargetId Error: memory allocation failed.");

        #endif

        }

    }

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

// SetSyncValueDefined: Set iSyncValueDefined to the object. Mainly used by decoder.

//

// Returns: void

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

//

void CSvgDiscardElementImpl::SetSyncValueDefined(TBool aSyncValueDefined)

    {

    iSyncValueDefined = aSyncValueDefined;

    }

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

// SetEventValueDefined: Set iEventValueDefined to the object. Mainly used by decoder.

//

// Returns: void

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

//

void CSvgDiscardElementImpl::SetEventValueDefined(TBool aEventValueDefined)

    {

    iEventValueDefined = aEventValueDefined;

    }

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

// SetHrefValueDefined: Set iHrefValueDefined to the object. Mainly used by decoder.

//

// Returns: void

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

//

void CSvgDiscardElementImpl::SetHrefValueDefined(TBool aHrefValueDefined)

    {

    iHrefValueDefined = aHrefValueDefined;

    }

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

// SetBeginSyncElementId: Set aBeginSyncElementId to the object. Mainly used by decoder.

//

// Returns: void

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

//

void CSvgDiscardElementImpl::SetBeginSyncElementId(const TDesC& aBeginSyncElementId)

    {

    iBeginSyncElementId.SetLength(0);

    iBeginSyncElementId.Append(aBeginSyncElementId);

    }

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

// SetAbsoluteBeginTime: Set iAbsoluteBeginTime to the object. Mainly used by decoder.