/*
* 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