/*
* 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.
//
// Returns: void
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::SetAbsoluteBeginTime(TInt aAbsoluteBeginTime)
    {
    if (aAbsoluteBeginTime == -1)
    	{
	    iAbsoluteBeginTime = KTimeIndefinite;
    	}
    else
    	{
	    iAbsoluteBeginTime = aAbsoluteBeginTime;
    	}
    }



// -----------------------------------------------------------------------------
// SetRefBeginTime: Set aRefBeginTime to the object. Mainly used by decoder.
//
// Returns: void
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::SetRefBeginTime(TInt aRefBeginTime)
    {
    iRefBeginTime = aRefBeginTime;
    }



// -----------------------------------------------------------------------------
// SetKeyValue: Set aKeyValue to the object. Mainly used by decoder.
//
// Returns: void
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::SetKeyValue(TInt aKeyValue)
    {
    iKeyValue = aKeyValue;
    }



// -----------------------------------------------------------------------------
// TargetId: Returns iBeginReferenceEvent that is specified in begin attribute.
// Mainly used by encoder.
//
// Returns: void
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::SetBeginReferenceEvent(TSvgEvent aBeginReferenceEvent)
    {
    iBeginReferenceEvent = aBeginReferenceEvent;
    }


// Getter functions

// -----------------------------------------------------------------------------
// TargetId: Returns the target element's id. Mainly used by encoder.
//
// Returns: Descriptor of target element's id
// -----------------------------------------------------------------------------
//
const TDesC& CSvgDiscardElementImpl::TargetId()
    {
    return (TDesC&) *iTargetId;
    }



// -----------------------------------------------------------------------------
// BeginSyncElementId: Returns element's id that is specified in begin attribute.
// Mainly used by encoder.
//
// Returns: Descriptor of the element's id
// -----------------------------------------------------------------------------
//
const TDesC& CSvgDiscardElementImpl::BeginSyncElementId()
    {
    return iBeginSyncElementId;
    }



// -----------------------------------------------------------------------------
// AbsoluteBeginTime: Returns the absolute begin time that is identified in
// SetAttribute. The begin time may be changed when using with SyncBase or
// EventBased attribute.
//
// Mainly used by encoder.
//
// Returns: TInt AbsoluteBeginTime
// -----------------------------------------------------------------------------
//
TInt CSvgDiscardElementImpl::AbsoluteBeginTime()
    {
    if (iAbsoluteBeginTime == KTimeIndefinite)
    	{
    	// write -1 in case both encorder and decoder understand.
    	return -1;
    	}
    else
		{
	    return iAbsoluteBeginTime;
		}
    }


// -----------------------------------------------------------------------------
// IsSyncValueDefined: Returns the flag iSyncValueDefined that was set in
// SetAttribute.
//
// Mainly used by encoder.
//
// Returns: TBool iSyncValueDefined
// -----------------------------------------------------------------------------
//
TBool CSvgDiscardElementImpl::IsSyncValueDefined()
    {
    return iSyncValueDefined;
    }


// -----------------------------------------------------------------------------
// IsEventValueDefined: Returns the flag iEventValueDefined that was set in
// SetAttribute.
//
// Mainly used by encoder.
//
// Returns: TBool iEventValueDefined
// -----------------------------------------------------------------------------
//
TBool CSvgDiscardElementImpl::IsEventValueDefined()
    {
    return iEventValueDefined;
    }


// -----------------------------------------------------------------------------
// IsHrefValueDefined: Returns the flag iHrefValueDefined that was set in
// SetAttribute.
//
// Mainly used by encoder.
//
// Returns: TBool iHrefValueDefined
// -----------------------------------------------------------------------------
//
TBool CSvgDiscardElementImpl::IsHrefValueDefined()
    {
    return iHrefValueDefined;
    }


// -----------------------------------------------------------------------------
// RefBeginTime: Returns the reference begin time that was set in
// SetAttribute.
//
// Mainly used by encoder.
//
// Returns: TInt iRefBeginTime
// -----------------------------------------------------------------------------
//
TInt CSvgDiscardElementImpl::RefBeginTime()
    {
    return iRefBeginTime;
    }


// -----------------------------------------------------------------------------
// KeyValue: Returns the key value (scan code) that was set in
// SetAttribute.
//
// Mainly used by encoder.
//
// Returns: TInt iKeyValue
// -----------------------------------------------------------------------------
//
TInt CSvgDiscardElementImpl::KeyValue()
    {
    return iKeyValue;
    }


// -----------------------------------------------------------------------------
// KeyValue: Returns the iBeginReferenceEvent that was set in
// SetAttribute.
//
// Mainly used by encoder.
//
// Returns: TSvgEvent iBeginReferenceEvent
// -----------------------------------------------------------------------------
//
TSvgEvent CSvgDiscardElementImpl::BeginReferenceEvent()
    {
    return iBeginReferenceEvent;
    }



// -----------------------------------------------------------------------------
// CloneL: Perform a deep clone of this object
//
// Returns: MXmlElement pointer to the newly created element.
// -----------------------------------------------------------------------------
//
MXmlElement* CSvgDiscardElementImpl::CloneL(MXmlElement* aParentElement)
    {
	CSvgDiscardElementImpl* newElement = CSvgDiscardElementImpl::NewL( this->ElemID(),
	        ((CSvgDocumentImpl*)iOwnerDocument) );
	CleanupStack::PushL(newElement);
	newElement->iParentNode = aParentElement;

    // copy everything over
    this->CopyL(newElement);
    CleanupStack::Pop();

    return newElement;
    }


// -----------------------------------------------------------------------------
// CopyL: Perform a deep copy of this object
//
// Returns: none
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::CopyL( CSvgDiscardElementImpl* aDestElement )
    {
    if(aDestElement)
	   	{
	    aDestElement->iOwnerDocument = this->iOwnerDocument;
		// copy stuff from superclass
	    this->CSvgElementImpl::CopyL(aDestElement);
	    }
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSvgDiscardElementImpl* CSvgDiscardElementImpl::NewL( const TUint8 aElemID,
                                                      CSvgDocumentImpl* aDoc)
    {
    CSvgDiscardElementImpl* self = new (ELeave)CSvgDiscardElementImpl(aDoc);
    CleanupStack::PushL( self );
    self->ConstructL( aElemID );
    CleanupStack::Pop();

    return self;
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSvgDiscardElementImpl* CSvgDiscardElementImpl::NewLC( const TUint8 aElemID,
                                                       CSvgDocumentImpl* aDoc)
    {
    CSvgDiscardElementImpl* self = new (ELeave) CSvgDiscardElementImpl(aDoc);
    CleanupStack::PushL( self );
    self->ConstructL( aElemID );

    return self;
    }

// -----------------------------------------------------------------------------
// C++ default constructor
// -----------------------------------------------------------------------------
//
CSvgDiscardElementImpl::CSvgDiscardElementImpl( CSvgDocumentImpl* aDoc )
	{
    SetOwnerDocument(aDoc);
    }


// -----------------------------------------------------------------------------
// Symbian default constructor that can leave.
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::ConstructL(  const TUint8 aElemID )
    {
    CXmlElementImpl::InitializeL( aElemID );

 	iTargetElement = NULL;
 	iTargetId = HBufC::NewL(0);
 	iAbsoluteBeginTime = 0;
 	iRemoveMyself = EFalse;
 	iHrefValueDefined = EFalse;
 	iBeginReferenceEvent = (TSvgEvent)NULL;
 	iSyncValueDefined = EFalse;
 	iEventValueDefined = EFalse;
 	iRefBeginTime = 0;
	iRefTargetElement = NULL;
	iRefBeginTimeSet = EFalse;
	iKeyValue = 0;
	iBeginSyncElementId.SetLength(0);

    ((CSvgDocumentImpl*)
    	iOwnerDocument)->AddToEventReceiverListL(this, KSvgEventMaskTimer |
    	    KSvgEventMaskInternal | KSvgEventMaskExternalUI);
    }


// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CSvgDiscardElementImpl::~CSvgDiscardElementImpl()
    {
    delete iTargetId;
    }

// -----------------------------------------------------------------------------
// Print
// -----------------------------------------------------------------------------
//
void CSvgDiscardElementImpl::Print( TBool aIsEncodeOn )
{
	if (!aIsEncodeOn)
	{
		#ifdef _DEBUG
		RDebug::Printf("<discard xlink:href =\"hmm\" begin=\"%d\" />", /*Href(),*/ (int)iAbsoluteBeginTime);
		#endif
	}
}

//  End of File