/*

* Copyright (c) 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:  Provides the base class implementation for the media elements.

*

*/

// INCLUDE FILES

#include "SVGMediaElementBase.h"

#include "SVGAnimTimingParser.h"

#include "SVGTimeContainer.h"

_LIT( KTmpCanSlip, "canSlip" );

_LIT( KTmpLocked, "locked" );

_LIT( KTmpIndependent, "independent" );

_LIT( KTmpDefault, "default" );

_LIT( KTmpSyncBehavior, "syncBehavior" );

_LIT( KTmpSyncTolerance, "syncTolerance" );

_LIT( KTmpSyncMaster, "syncMaster" );

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// CSvgMediaElementBase::CSvgMediaElementBase

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSvgMediaElementBase::CSvgMediaElementBase( CSvgDocumentImpl* aDoc ):

    CSvgAnimationBase( aDoc ),

    iSyncMasterConfig( EFalse ),

    iSyncMasterCurrent( EFalse ),

    iSyncOffset( 0 )

    {

    // Obtain the default sync behaviour/tolerance from the root element

    CSvgSvgElementImpl* lSvgEle =  (CSvgSvgElementImpl* )aDoc->RootElement();

    if ( lSvgEle )

        {

        iSyncBehavior = lSvgEle->SyncBehaviorDefault();

        iSyncTolerance = lSvgEle->SyncToleranceDefault();

        }    

    }

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

// CSvgMediaElementBase::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSvgMediaElementBase::ConstructL( const TUint8 aElemID )

    {

    CSvgAnimationBase::ConstructL( aElemID );

    // Add this element to the time container to recieve runtime sync events

    ((CSvgDocumentImpl* )iOwnerDocument)->TimeContainer()->AddTimedEntityL( this );

    }

// Destructor

CSvgMediaElementBase::~CSvgMediaElementBase()

    {

    // Remove this element from the time container

    ((CSvgDocumentImpl* )iOwnerDocument)->TimeContainer()->DelTimedEntity( this );

    }

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

// CSvgMediaElementBase::SetSyncBehavior

// Set the Synchronised behaviour for the media element

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

//        

void CSvgMediaElementBase::SetSyncBehavior( const TDesC& aValue )

    {

	if ( !aValue.CompareF( KTmpCanSlip ) )

	    {

        iSyncBehavior = ESvgSyncCanSlip;        

	    }

	else if ( !aValue.CompareF( KTmpLocked ) )

	    {

        iSyncBehavior = ESvgSyncLocked;

	    }

	else if ( !aValue.CompareF( KTmpIndependent ) )

	    {

        iSyncBehavior = ESvgSyncIndependent;

	    }

	else if ( !aValue.CompareF( KTmpDefault ) )

	    {

        // Obtain the sync behaviour from the root of time container

        CSvgDocumentImpl* lSvgDoc = (( CSvgDocumentImpl* ) 

            iOwnerDocument);

        CSvgSvgElementImpl* lSvgEle =  (CSvgSvgElementImpl* )lSvgDoc->RootElement();

        if ( lSvgEle )

            {

            iSyncBehavior = lSvgEle->SyncBehaviorDefault();

            }

	    }

    }

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

// CSvgMediaElementBase::SetSyncTolerance

// Set the Synchronised Tolerance for the media element

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

//        

void CSvgMediaElementBase::SetSyncTolerance( const TDesC& aValue )

    {

	if ( aValue.CompareF( KTmpDefault ) )

	    {

	    CSvgAnimTimingParser* lATParserPtr = NULL;

	    // Treat as clock value

	    TRAPD( lCreateATPErr, 

	        {

	        lATParserPtr = CSvgAnimTimingParser::NewL( aValue, this );

	        } );

	    if ( lCreateATPErr != KErrNone )

	        {

	        // Error Processing

	        return;

	        }

        TInt32 lClockValue;

        TLex lLex( aValue );

        lATParserPtr->ParseClockValue( lLex, lClockValue );

        delete lATParserPtr;

        iSyncTolerance = lClockValue; 

	    }

	else

	    {

	    // Get clock value from parent

        CSvgDocumentImpl* lSvgDoc = (( CSvgDocumentImpl* ) 

            iOwnerDocument);

        CSvgSvgElementImpl* lSvgEle =  (CSvgSvgElementImpl* )lSvgDoc->RootElement();

        if ( lSvgEle )

            {

            iSyncTolerance = lSvgEle->SyncToleranceDefault();

            }	    

	    }

    }

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

// CSvgMediaElementBase::SetSyncMaster

// Set the media element as Synchronised Master

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

//        

void CSvgMediaElementBase::SetSyncMaster( const TDesC& aValue )

    {

    if ( !aValue.CompareF(_L("true")) )

        {

        iSyncMasterConfig = ETrue;

        }

    else

        {

        iSyncMasterConfig = EFalse;

        }

    }

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

// CSvgMediaElementBase::SetSyncBehavior

// Set the Synchronised behaviour for the media element

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

//        

void CSvgMediaElementBase::SetSyncBehavior( 

    const TSvgSyncBehaviour aValue )

    {

    if ( aValue == ESvgSyncDefault )

        {

        // Obtain the sync behaviour from the root of time container

        CSvgDocumentImpl* lSvgDoc = (( CSvgDocumentImpl* ) 

            iOwnerDocument);

        CSvgSvgElementImpl* lSvgEle =  (CSvgSvgElementImpl* )lSvgDoc->RootElement();

        if ( lSvgEle )

            {

            iSyncBehavior = lSvgEle->SyncBehaviorDefault();

            }

        }

     else

        {

        iSyncBehavior = aValue;

        }

    }

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

// CSvgMediaElementBase::SetSyncTolerance

// Set the Synchronised Tolerance for the media element

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

//        

void CSvgMediaElementBase::SetSyncTolerance( const TInt32 aValue , 

    const TBool aUseDefault )

    {

    if ( aUseDefault )

        {

	    // Get clock value from parent

        CSvgDocumentImpl* lSvgDoc = (( CSvgDocumentImpl* ) 

            iOwnerDocument);

        CSvgSvgElementImpl* lSvgEle =  (CSvgSvgElementImpl* )lSvgDoc->RootElement();

        if ( lSvgEle )

            {

            iSyncTolerance = lSvgEle->SyncToleranceDefault();

            }	    

        }

        else

            {

            iSyncTolerance = aValue;            

            }

    }

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

// CSvgMediaElementBase::SetSyncMaster

// Set the media element as Synchronised Master

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

//        

void CSvgMediaElementBase::SetSyncMaster( const TBool aValue )    

    {

    iSyncMasterConfig = aValue;

    }

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

// CSvgMediaElementBase::SyncBehavior

// Accessor for the Synchronised behaviour for the media element

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

//        

TSvgSyncBehaviour CSvgMediaElementBase::SyncBehavior()    

    {

    return iSyncBehavior;

    }

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

// CSvgMediaElementBase::SyncTolerance

// Accessor for the Synchronised Tolerance for the media element

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

//        

TInt32 CSvgMediaElementBase::SyncTolerance()    

    {

    return iSyncTolerance;

    }

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

// CSvgMediaElementBase::SyncMaster

// Accessor for the Synchronised Mastership for the media element

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

//        

TBool CSvgMediaElementBase::SyncMaster()    

    {

    return iSyncMasterConfig;

    }

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

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

// From CSvgAnimationBase

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

//

TInt CSvgMediaElementBase::SetAttributeL( const TDesC& aName,

                                        const TDesC& aValue )

    {

    if ( !aName.CompareF( KTmpSyncBehavior ) )

        {

        SetSyncBehavior( aValue );

        }

    else if ( !aName.CompareF( KTmpSyncTolerance ) )

        {

        SetSyncTolerance( aValue );

        }

    else if ( !aName.CompareF( KTmpSyncMaster ) )

        {

        SetSyncMaster( aValue );

        }

    else

        {

        return CSvgAnimationBase::SetAttributeL( aName, aValue );

        }

    return KErrNone;

    }

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

// CSvgMediaElementBase::ParentTimeContainerTick

// From MSvgTimedEntityInterface

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

//

void CSvgMediaElementBase::ParentTimeContainerTick( 

    TSvgTick aTick ) // Current tick information 

    {

    // Check if the element is currently acting as syncMaster for the locked 

    // group it is part of.

    // Note element having syncMaster property set doesn't make it master. It 

    // needs to be resolved.

    TBool lIsCurSyncMaster = EFalse;

    GetCurSyncMasterStatus( lIsCurSyncMaster );

     if ( lIsCurSyncMaster || iSyncBehavior != ESvgSyncLocked ) 

     {

        // Could be locked, or not locked. In both cases, use media 

        // element clock.

        if ( CanGenerateTick() ) 

            {

            //No action.

            }

        else

            {

            // Use the Real Time Tick.

            // Create a timer event with real time tick

            // Send this event to engine

            }

     }

    if( !lIsCurSyncMaster  && iSyncBehavior == ESvgSyncLocked)

     {

        // The element needs to be in sync with Parent.

        if ( CanUseParentTick() )

        {

            // Run the media element with parent's tick.

            // Create a timer event with parent's tick

            // Send this event to engine

            // Only required at Document Level.

         }

        else

        {

            // Calculate SyncOffset value

            // Get the current tick on the element

            TUint32 lEntityTime;

            GetEntityCurrentTime( lEntityTime ); 

            // Calculate the drift

            TInt32 iSyncOffset = aTick.iParentTcTick - lEntityTime;

            // Media element running with its own clock, need 

            // to resynchronize if the element is out of sync 

            // wrt to parent clock.

            if ( Abs( iSyncOffset ) > iSyncTolerance )

                {

                // Resynchronize the Media Element wrt to 

                // Parent Clock.

                ResyncTimedEntity( aTick.iParentTcTick );

                }

          }

       }

    }

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

// CSvgMediaElementBase::GetEntitySyncBehavior

// From MSvgTimedEntityInterface

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

//        

TSvgSyncBehaviour CSvgMediaElementBase::GetEntitySyncBehavior()

    {

    return iSyncBehavior; 

    }

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

// CSvgMediaElementBase::GetEntityCurrentTime

// From MSvgTimedEntityInterface

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

//        

void CSvgMediaElementBase::GetEntityCurrentTime( TUint32& 

            /* aEntityCurTime*/ ) // Current Entity Time in msecs. 

    {

    }

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

// CSvgMediaElementBase::GetCnfSyncMasterStatus

// From MSvgTimedEntityInterface

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

//        

void CSvgMediaElementBase::GetCnfSyncMasterStatus( 

            TBool& aIsSyncMaster ) // Indicates whether the element is configured as 

                                   // Sync Master. 

    {

    aIsSyncMaster = iSyncMasterConfig;

    }                                   

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

// CSvgMediaElementBase::GetCurSyncMasterStatus

// From MSvgTimedEntityInterface

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

void CSvgMediaElementBase::GetCurSyncMasterStatus( 

            TBool& aIsSyncMaster ) // Indicates whether the element is currrently 

                                  // Sync Master. 

    {

    aIsSyncMaster = iSyncMasterCurrent;

    }        

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

// CSvgMediaElementBase::SetCurSyncMasterStatus

// From MSvgTimedEntityInterface

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

void CSvgMediaElementBase::SetCurSyncMasterStatus( 

    TBool aSyncMasterStatus ) //  Indicates whether the element is currrently 

                              // Sync Master.

    {

    iSyncMasterCurrent = aSyncMasterStatus;

    }

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

// CSvgMediaElementBase::CanGenerateTick

// From MSvgTimedEntityInterface

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

TBool CSvgMediaElementBase::CanGenerateTick()

    {

    return EFalse;

    }

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

// CSvgMediaElementBase::CanUseParentTick

// From MSvgTimedEntityInterface

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

TBool CSvgMediaElementBase::CanUseParentTick()

    {

    return EFalse;

    }

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

// CSvgMediaElementBase::ResyncTimedEntity

// From MSvgTimedEntityInterface

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

void CSvgMediaElementBase::ResyncTimedEntity( 

            TUint32 /* aSynctime */ ) // Time for resync in msecs.

    {

    }

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

// CSvgMediaElementBase::PauseTimedEntity

// From MSvgTimedEntityInterface

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

void CSvgMediaElementBase::PauseTimedEntity()

    {

    }

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

// CSvgMediaElementBase::ResumeTimedEntity

// From MSvgTimedEntityInterface

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

void CSvgMediaElementBase::ResumeTimedEntity()

    {

    }

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

// CSvgMediaElementBase::StopTimedEntity

// From MSvgTimedEntityInterface

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

void CSvgMediaElementBase::StopTimedEntity()

    {

    }

//From MSvgTimedEntityInterface

TSvgObjectType CSvgMediaElementBase::ObjectType()

{

	return ESvgInvalidReference ;	

}

//returns the child time container of the element 

//used in timecontainer

CSvgTimeContainer* CSvgMediaElementBase::GetChildTimeContainer()

{

    return NULL;

}

//  End of File