/*

* Copyright (c) 2005-2006 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 "Gfx2dGcOpenVG.h"

#include "GfxRoundRectangle2D.h"

#include "SVGMediaAnimationElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGSchemaData.h"

#include "SVGEventHandler.h"

_LIT( KXlink, "xlink:href" );

_LIT( KFocusable, "focusable" );

_LIT(KInitialVisibility, "initialVisibility");

_LIT( KSvgFile, ".svg");

_LIT( KSvgbFile, ".svgb");

_LIT( KSvgzFile, ".svgz");

_LIT(msg, "Fail to open file for reading: ");

_LIT( KErrorMsg, "Failed to Load Svg Content: Read File Size Error." );

_LIT( KMemoryErrorMsg, "Failed to Load Svg Content: Out of memory");

_LIT( KReadErrorMsg, "Failed to Load Svg Content: Read File Data Error");

_LIT(KEngineFailed, "Failed to Create Svg Document: Out of Memory");

_LIT( KTmpDur, "dur" );

_LIT( KTmpDurMedia, "media" );

CSvgMediaAnimationElementImpl* CSvgMediaAnimationElementImpl::NewL(const TUint8

                                               aElemID,CSvgDocumentImpl* aDoc )

    {

    CSvgMediaAnimationElementImpl* self = CSvgMediaAnimationElementImpl::NewLC

                                                                (aElemID,aDoc);

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgMediaAnimationElementImpl* CSvgMediaAnimationElementImpl::NewLC(const TUint8

                                              aElemID, CSvgDocumentImpl* aDoc )

    {

    CSvgMediaAnimationElementImpl* self = new ( ELeave ) CSvgMediaAnimationElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID,aDoc );

    return self;

    }

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

// CSvgMediaAnimationElementImpl::SetSyncBehavior

// Set the Synchronised behaviour for the animation element

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

//        

void CSvgMediaAnimationElementImpl::SetSyncBehavior( const TDesC& aValue )

    {

    CSvgMediaElementBase::SetSyncBehavior( aValue );

    // If document is created then set the sync value to the time container

    if ( iNewDocument )

        {

        iNewDocument->SetTCSyncBehavior( iSyncBehavior );

        }

    }

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

// CSvgMediaAnimationElementImpl::SetSyncTolerance

// Set the Synchronised Tolerance for the animation element

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

//        

void CSvgMediaAnimationElementImpl::SetSyncTolerance( const TDesC& aValue )

    {

    CSvgMediaElementBase::SetSyncTolerance( aValue );

    // If document is created then set the sync value to the time container

    if ( iNewDocument )

        {

        iNewDocument->SetTCSyncTolerance( iSyncTolerance );

        }

    }

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

// CSvgMediaAnimationElementImpl::SetSyncMaster

// Set the animation element as Synchronised Master

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

//        

void CSvgMediaAnimationElementImpl::SetSyncMaster( const TDesC& aValue )

    {

    CSvgMediaElementBase::SetSyncMaster( aValue );

    // If document is created then set the sync value to the time container

    if ( iNewDocument )

        {

        iNewDocument->SetTCSyncMaster( iSyncMasterConfig );

        }

    }

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

//

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

void CSvgMediaAnimationElementImpl::ConstructL(  const TUint8 aElemID,

                                       CSvgDocumentImpl*  /* aDoc */ )

    {

	CSvgMediaElementBase::ConstructL( aElemID );

	iViewBoxImpl = CSvgFitToViewBoxImpl::NewL();

	iIsFocusable = ETrue;

	iDurMediaTime = ETrue;

    iSvgError = CSvgErrorImpl::NewL();

    if(!iSvgTransformable)

        iSvgTransformable = CSvgTransformableImpl::NewL();

    iChildSvgName = HBufC::NewL( 100 );

	#ifdef SVG_FLOAT_BUILD

    iX = ( 0 );

    iY = ( 0 );

	#else

    iX.operator = ( 0 );

    iY.operator = ( 0 );

	#endif

	#ifdef SVG_FLOAT_BUILD

    iScale = ( 0 );

	#else

    iScale.operator = ( 0 );

	#endif

	iIsOriginalRootTrSet = EFalse;

	if (OwnerDocument())

	{

	((CSvgDocumentImpl*)OwnerDocument())->AddInternalMouseListener( this );

	     ((CSvgDocumentImpl*)iOwnerDocument)->AddToEventReceiverListL(

                                               this, KSvgEventMaskExternalUI );

	}

    }

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

//  Constructor

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

CSvgMediaAnimationElementImpl::CSvgMediaAnimationElementImpl

                               ( CSvgDocumentImpl* aDoc ):CSvgMediaElementBase

                               ( aDoc ),iAnimationStatus(EPlayerStateIdle),iInitialVisibility(EAnimationNotVisible)

    {

    iAttrId = KAtrMediaAnimationId;

	}

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

// perform a deep clone of this object

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

MXmlElement* CSvgMediaAnimationElementImpl::CloneL(MXmlElement* aParentElement)

    {

    CSvgMediaAnimationElementImpl* newElement = CSvgMediaAnimationElementImpl::

    NewL( this->ElemID(), ((CSvgDocumentImpl*)iOwnerDocument) );

    CleanupStack::PushL(newElement);

    newElement->iParentNode = aParentElement;

    // copy everything over

    this->CopyL(newElement);

    CleanupStack::Pop();

    return newElement;

    }

// ==========================================================================

// perform a deep copy of this object

// ==========================================================================

void CSvgMediaAnimationElementImpl::CopyL( CSvgMediaAnimationElementImpl* aDestElement )

    {

    if(aDestElement)

		{

	    // copy stuff from superclass

	    this->CSvgElementImpl::CopyL(aDestElement);

	    this->CSvgMediaElementBase::CopyL(aDestElement);

	    aDestElement->iWidth = iWidth;

        aDestElement->iHeight = iHeight;

        aDestElement->iInitialVisibility = iInitialVisibility;

        aDestElement->iDurMediaTime = iDurMediaTime;

        aDestElement->iX = iX;

        aDestElement->iY = iY;

        aDestElement->iScale = iScale;

        aDestElement->iOriginalRootTr = iOriginalRootTr;

        aDestElement->iIsOriginalRootTrSet = iIsOriginalRootTrSet;

        aDestElement->iAnimationStatus = iAnimationStatus;

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

		aDestElement->iTargetSet = ETrue;

		TInt handle = 0;

        TInt engine = 0;

        TPtr    tPtr    = this->iChildSvgName->Des();

        aDestElement->PrepareDomChildSvg(tPtr,handle,engine);

	    }

    }

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

//  Destructor

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

CSvgMediaAnimationElementImpl::~CSvgMediaAnimationElementImpl()

    {

    delete iViewBoxImpl;

    delete iSvgError;

    delete iNewDocument;

    iSvgMouseEnteredElements.Close(); 

    delete iChildSvgName;        

    }

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

//

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

TInt CSvgMediaAnimationElementImpl::SetAttributeL( const TDesC& aName,

                                          const TDesC& aValue )

    {

     CSvgElementImpl::SetAttributeL(aName,aValue);

            //added for the bug if no begin is given

    if ( !iTargetSet )

			{

			// default is parent element

			iTargetElement = ( CSvgElementImpl * ) ParentNode();

			iTargetSet = ETrue;

			}

    // Encapsulates both viewBox and preserveAspectRatio attributes.

    if ( iViewBoxImpl->SetViewBoxL( aName, aValue ) )

        {

                if ( iNewDocument && iNewDocument->RootElement() )

                    {

                        MSvgPreserveAspectRatio* lAspectRatio;

                        iViewBoxImpl->GetPreserveAspectRatio(lAspectRatio);

                        if ( lAspectRatio )

                            {

                            ((CSvgSvgElementImpl *)

                             (iNewDocument->RootElement()))->SetPreserveAspectRatioL

                             (lAspectRatio->GetAlign(), lAspectRatio->GetMeetOrSlice());                

                            }    

                    }

                return KErrNone;

        }

    if ( aName == KXlink )

        {

            if ( aValue.Length() != 0 )

            {

            iChildSvgName = iChildSvgName->ReAlloc(aValue.Length());

            TPtr    tPtr    = iChildSvgName->Des();

            tPtr.Copy( aValue );

            TInt length = tPtr.Length();

            TPtrC tPtrCSvg = tPtr.Right(4);

            TPtrC tPtrCSvgX = tPtr.Right(5);

            if ( tPtrCSvg.Find(KSvgFile) == KErrNotFound && 

                            tPtrCSvgX.Find(KSvgbFile) == KErrNotFound  

                            && tPtrCSvgX.Find(KSvgzFile) == KErrNotFound  )

                {

                return KErrGeneral;

                }

            else

                {

                TInt handle = 0;

                TInt engine = 0;

                TPtrC fileName;

                PrepareDomChildSvg(tPtr,handle,engine);

                // Check if error occured

                if ( !iSvgError->HasError() )

                    {

                    // If document is valid then set parameters of child svg

                    // element from animation element 

                    if ( iNewDocument && iNewDocument->RootElement() )

                        {

                        ((CSvgSvgElementImpl *)

                         (iNewDocument->RootElement()))->iWidthInPercentage = EFalse;

                        ((CSvgSvgElementImpl *)

                         (iNewDocument->RootElement()))->iHeightInPercentage = EFalse;

                        ((CSvgSvgElementImpl *)

                         (iNewDocument->RootElement()))->SetWidth((TFloatFixPt)iWidth);

                        ((CSvgSvgElementImpl *)

                         (iNewDocument->RootElement()))->SetHeight((TFloatFixPt)iHeight);

                  // Set the Sync Values from animation element to time container

                        // Sync Behaviour

                        iNewDocument->SetTCSyncBehavior( iSyncBehavior );

                        // Sync Tolerance

                        iNewDocument->SetTCSyncTolerance( iSyncTolerance );

                        // Sync Mastership

                        iNewDocument->SetTCSyncMaster( iSyncMasterConfig );

                        MSvgPreserveAspectRatio* lAspectRatio;

                        iViewBoxImpl->GetPreserveAspectRatio(lAspectRatio);

                        if ( lAspectRatio )

                            {

                            ((CSvgSvgElementImpl *)

                             (iNewDocument->RootElement()))->

                             SetPreserveAspectRatioL(lAspectRatio->GetAlign(), 

                             lAspectRatio->GetMeetOrSlice());                

                            }

                        }

                    }

                 else  

                    {

                      return KErrGeneral;

                    }

                }

              }

		}

    else if ( aName == KFocusable )

        {

            if ( aValue == _L("true") )

                iIsFocusable = ETrue;

            if ( aValue == _L("false") )

                 iIsFocusable = EFalse;

        }

    else if ( aName == KInitialVisibility )    

        {

                if ( aValue == _L("always") )

                {

                    iInitialVisibility =  EAnimationVisible;

                }

        }

    else if ( aName == KTmpDur && aValue != KTmpDurMedia )

           {

           iDurMediaTime = EFalse;

           return CSvgMediaElementBase::SetAttributeL(aName, aValue);

           }

    else 

	    {

   	    return CSvgMediaElementBase::SetAttributeL(aName, aValue);

	    }

	return KErrNone;

    }

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

//

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

TInt  CSvgMediaAnimationElementImpl::SetAttributeDesL( const TInt aNameId,

											   const TDesC& aValue )

	{

	return CSvgMediaElementBase::SetAttributeDesL( aNameId, aValue );

    }

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

//

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

TInt CSvgMediaAnimationElementImpl::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 CSvgMediaElementBase::GetAttributeFloat( aNameId, aValue );

     }

     return KErrNone;

    }

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

//

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

TInt CSvgMediaAnimationElementImpl::SetAttributeFloatL( const TInt aNameId,

                                               TFloatFixPt aValue )

    {

      switch ( aNameId )

      {

      case KAtrX:

          iX = aValue;

          SetInitialCTM();

          break;

      case KAtrY:

          iY = aValue;

          SetInitialCTM();

          break;

      case KAtrWidth:

          iWidth = aValue;

          break;

      case KAtrHeight:

          iHeight= aValue;

          break;

      default:

         return CSvgMediaElementBase::SetAttributeFloatL( aNameId, aValue );

        }

      return KErrNone;

    }

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

// From MSvgEventReceiver

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

TBool CSvgMediaAnimationElementImpl::ReceiveEventL( MSvgEvent* aEvent )

    {

    if( CSvgElementImpl::IsSVGEnginePaused())

    {

    	return EFalse;

    }

    if ( !iNewDocument )

        {

        return EFalse;

        }

    // Process animation element's events first    

    TBool lSelfRedrawReqd = CSvgMediaElementBase::ReceiveEventProcL( aEvent, 

        this );

    CSvgElementImpl::ReceiveEventL(aEvent);    

    // Only External UI events are sent to the child document

    if ( ( aEvent->EventMask() & KSvgEventMaskExternalUI ) )

        {

        TInt lEvtTime = 0;

        // Save the time as the ProcessEvent modifies the time of the event

        // to the document's current time for keypress events

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

            {

            lEvtTime = ( ( MSvgUiKeyEvent * ) aEvent )->Time();

            }

        // Send the events to the child document

        ( ( ( CSvgDocumentImpl* )

            iOwnerDocument )->Engine() )->ProcessEventL( iNewDocument, 

            aEvent, EFalse );

        // Restore the time, so that when the event is propogated to 

        // further elements in the DOM tree, the time is in sync with

        // respect to current document time. 

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

            {

            ( ( MSvgUiKeyEvent * ) aEvent )->SetTime( lEvtTime );

            }

        }

    return lSelfRedrawReqd;

    }

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

// 

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

void CSvgMediaAnimationElementImpl::ResetAnimationL()

    {

  	// Check if document is valid

	if ( !iNewDocument || !iNewDocument->RootElement() )

	    {

	    return;

	    }

        if (( iAnimStatus == KAnimActive ) ||

		( iAnimStatus == KAnimFinished) ||

		( iAnimStatus == KAnimEnd))

		{

		if (( iAnimationStatus == EPlayerStatePlaying ) ||

			( iAnimationStatus == EPlayerStateStop ))

			{

			// if previously audio is still playing, and asked to play again...

	            iNewDocument->SetCurrentTime( 0 );

                   iNewDocument->iAnimationResetNeeded = ETrue;

                if(this->iNewDocument && this->iNewDocument->iEventHandler)

                    {

                    this->iNewDocument->iEventHandler->SetCurrentTime(0);

                    }

            	 TSvgTimerEvent timeEvent(0);

            	 iNewDocument->Reset( &timeEvent );

        	// Save the animation start tick so that

        	// child document's tick can be correctly offset

	    	iBeginTick = ( ( CSvgDocumentImpl* )

	    	    iOwnerDocument )->TimeContainer()->GetCurTick(); 

	    	iAnimationStatus = EPlayerStatePlaying;

			}

		}

    }

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

//

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

void CSvgMediaAnimationElementImpl::Reset( MSvgEvent* aEvent )

	{

	iIsUserSeek = ETrue;

	// call the animation base function.

	TSvgTimerEvent* timerEvent  = ( TSvgTimerEvent* ) aEvent;