--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/svgtopt/SVG/SVGImpl/src/SVGTimeContainer.cpp Thu Jan 07 16:19:02 2010 +0200
@@ -0,0 +1,1490 @@
+/*
+* 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 implementation of a time container
+*
+*/
+
+
+
+// INCLUDE FILES
+#include "SVGTimeContainer.h"
+#include "SVGTimer.h"
+#include "SVGEvent.h"
+#include "SVGDocumentImpl.h"
+
+#include "SVGLockedRealTimeEntity.h"
+
+// 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 ===============================
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::CSvgTimeContainer
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CSvgTimeContainer::CSvgTimeContainer( CSvgDocumentImpl* aOwnerDoc,
+ const TBool aHasParent,
+ const TSvgSyncBehaviour aSyncBehavior,
+ const TBool aIsSyncMaster,
+ const TUint32 aSyncTolerance ) :
+ iTcSyncBehavior( aSyncBehavior ),
+ iTcSyncTolerance( aSyncTolerance ),
+ iTcSyncMasterConfig( aIsSyncMaster ),
+ iIsParentTcPresent( aHasParent ),
+ iOwnerDoc( aOwnerDoc ),
+ iMediaState( ESvgMediaReady ),
+ iUserState(ESvgUserRunning),
+ iIsSyncPaused(EFalse)
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::ConstructL()
+ {
+ //Add locked real time entity(LRTE) here
+ iLrte = CSvgLockedRealTimeEntity::NewL(iOwnerDoc);
+ // Populate the entity list item corresponding to LRTE
+ iLrteListItem.iTimedEntity = iLrte;
+ iLrteListItem.iMediaState = ESvgMediaIdle;
+ iLrteListItem.iUserState =ESvgUserRunning ;
+ iLrteListItem.iIsSyncPaused = EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CSvgTimeContainer* CSvgTimeContainer::NewL( CSvgDocumentImpl* aOwnerDoc,
+ const TBool aHasParent,
+ const TSvgSyncBehaviour aSyncBehavior,
+ const TBool aIsSyncMaster,
+ const TUint32 aSyncTolerance )
+ {
+ CSvgTimeContainer* self = new( ELeave ) CSvgTimeContainer( aOwnerDoc,
+ aHasParent, aSyncBehavior, aIsSyncMaster, aSyncTolerance );
+
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+
+// Destructor
+CSvgTimeContainer::~CSvgTimeContainer()
+ {
+ // Reset the observer
+ iObserver = NULL;
+ // Delete the locked realtime timed entity
+ delete iLrte;
+ // Cleanup the list of timed entities
+ CleanupTimedEntities();
+
+ // Delete the timer if present
+ if ( iTimer )
+ {
+ delete iTimer;
+ iTimer = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::GetSyncMasterForTimeContainer
+// Resolves the sync master within the time container and returns the same.
+// -----------------------------------------------------------------------------
+//
+MSvgTimedEntityInterface* CSvgTimeContainer::GetSyncMasterForTimeContainer()
+ {
+ // First check the number of elements in the time container
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+
+ // if there is only one element in the list(which is the document),
+ // return NULL to avoid list traversal
+ if ( lTimedEntityListCnt <= 1 )
+ {
+ return NULL;
+ }
+
+ TInt lFirstAudioIndex = iTcTimedEntities.Count(); // Store invalid value
+ MSvgTimedEntityInterface* lCurSyncMaster = NULL;
+
+ // Within the locked group of timed entities within the time
+ // container, need to find out which element is acting as master.
+
+ // For All Timed Entities
+ // Get the first eligible sync master
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ //get each element
+ MSvgTimedEntityInterface* lCurTimedEntity =
+ (iTcTimedEntities[ lItemIndex ]).iTimedEntity ;
+
+ // In case an audio element is found
+ // check whether is is locked and can generate tick
+ // If so, it is an eligible sync master
+ if( lFirstAudioIndex == lTimedEntityListCnt &&
+ lCurTimedEntity->ObjectType() == ESvgAudioElement &&
+ lCurTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked &&
+ lCurTimedEntity->CanGenerateTick() )
+ {
+ // Remember this so it can be used later if
+ // no eligible syncmaster found
+ lFirstAudioIndex = lItemIndex;
+ }
+
+ TBool lIsSyncMaster = EFalse;
+ lCurTimedEntity->GetCnfSyncMasterStatus( lIsSyncMaster );
+ // An element is an eligible sync master if:
+ // a. It is locked wrt the TC
+ // b. It is configured as a sync master
+ // c. It can generate tick i.e. it is active and has implicit duration.
+ if ( lCurTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked
+ && lIsSyncMaster
+ && lCurTimedEntity->CanGenerateTick() )
+ {
+ lCurSyncMaster = lCurTimedEntity;
+ break;
+ }
+ }
+
+
+ if ( !lCurSyncMaster )
+ {
+ if( lFirstAudioIndex != lTimedEntityListCnt )
+ {
+ // Did not find a sync master, and audio element available
+ lCurSyncMaster = iTcTimedEntities[ lFirstAudioIndex ].iTimedEntity;
+ }
+ //Locked real time entityas syncmaster
+ else
+ {
+ lCurSyncMaster = iLrteListItem.iTimedEntity;
+ }
+
+ }
+
+ if ( lCurSyncMaster )
+ {
+ // Sync Master found
+ // Store the syncMaster in iTcSyncMaster.
+ iTcSyncMaster = lCurSyncMaster;
+
+ // Set the state in the sync master that it is the chosen one.
+ iTcSyncMaster->SetCurSyncMasterStatus( ETrue );
+
+ // For All Timed Entities other than syncMaster in TC group
+ // SetCurSyncMasterStatus = False;
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ MSvgTimedEntityInterface* lCurTimedEntity =
+ (iTcTimedEntities[ lItemIndex ]).iTimedEntity ;
+ if ( lCurTimedEntity != iTcSyncMaster )
+ {
+ lCurTimedEntity->SetCurSyncMasterStatus( EFalse );
+ }
+ }
+
+ if(iLrteListItem.iTimedEntity != lCurSyncMaster)
+ {
+ iLrteListItem.iTimedEntity->SetCurSyncMasterStatus(EFalse);
+ }
+ }
+
+
+ return iTcSyncMaster;
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::AddTimedEntityL
+// Add a timed entity to the time container.
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::AddTimedEntityL(
+ MSvgTimedEntityInterface* aTimedEntity )
+ {
+ if ( !aTimedEntity )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ // check to see if entity is already in list and simply return
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ if ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity == aTimedEntity )
+ {
+ return;
+ }
+ }
+
+ TSvgTimedEntityListItem lListItem;
+ lListItem.iTimedEntity = aTimedEntity;
+
+ //Media State initially Idle
+ lListItem.iMediaState = ESvgMediaIdle;
+
+ //User state initially is running
+ lListItem.iUserState =ESvgUserRunning ;
+
+ // Sync State is Playing
+ lListItem.iIsSyncPaused = EFalse;
+
+ // Append to Timed Entity List
+ iTcTimedEntities.AppendL( lListItem );
+
+ // Obtain the post order list of media elements
+ RPointerArray<CSvgElementImpl> lMediaEleList;
+ lMediaEleList.Reset();
+
+ CSvgElementImpl *handle = (CSvgElementImpl *)(iOwnerDoc->RootElement());
+ iOwnerDoc->ParsePostOrderMediaElements( handle, lMediaEleList );
+
+ // Rearrange as per Post order
+ RearrangeTimedEntityList( lMediaEleList );
+
+ // Done with the list
+ lMediaEleList.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::DelTimedEntity
+// Removes the timed entity from the time container.
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::DelTimedEntity(
+ MSvgTimedEntityInterface* aTimedEntity )
+ {
+ // check whether the entity exists and then remove it from the list
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ if ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity == aTimedEntity )
+ {
+ iTcTimedEntities.Remove( lItemIndex );
+ break;
+ }
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::CleanupTimedEntities
+// Removes all the timed entities from the time container.
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::CleanupTimedEntities( )
+ {
+ // Delete the entries in the timed entity list; does not delete the
+ // timed entities.
+ iTcTimedEntities.Reset();
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::SetCurrentTime
+// Set Function for the TC's current time
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::SetCurrentTime( TInt32 aCurTime )
+ {
+ iCurrentTime = aCurTime;
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::CurrentTime
+// Accessor for the TC's current time
+// ---------------------------------------------------------------------------
+TInt32 CSvgTimeContainer::CurrentTime()
+ {
+ return iCurrentTime;
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::SetSyncBehavior
+// Set the Synchronised behaviour for the time container
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::SetSyncBehavior( const TSvgSyncBehaviour aValue )
+ {
+ iTcSyncBehavior = aValue;
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::SetSyncTolerance
+// Set the Synchronised Tolerance for the time container
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::SetSyncTolerance( const TUint32 aValue )
+ {
+ iTcSyncTolerance = aValue;
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::SetSyncMaster
+// Set the time container as Synchronised Master
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::SetSyncMaster( const TBool aValue )
+ {
+ iTcSyncMasterConfig = aValue;
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::GetCurTick
+// Accessor function to get the current tick
+// ---------------------------------------------------------------------------
+TSvgTick CSvgTimeContainer::GetCurTick()
+ {
+ return iCurrentTick;
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::Document
+// Accessor function to get the owner doc of the TC
+// ---------------------------------------------------------------------------
+CSvgDocumentImpl* CSvgTimeContainer::Document()
+ {
+ return iOwnerDoc;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::TimedEntityNotReady
+// Informing the time container that timed entity is not ready
+ /*
+ If this element is locked
+ {
+ PauseLockedElements
+ {
+ (Whether ready/not ready)
+ For all locked elements:
+ SyncPauseElement.
+ }
+ If TC Observer present
+ Give Not Ready Event
+ }
+
+ */
+ // ---------------------------------------------------------------------------
+void CSvgTimeContainer::TimedEntityNotReady(
+ MSvgTimedEntityInterface* aTimedEntity )
+ {
+
+
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ //get current element
+ if ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity == aTimedEntity )
+ {
+ //set current element as not ready
+ (iTcTimedEntities[ lItemIndex ]).iMediaState = ESvgMediaNotReady;
+
+ //if current element is locked
+ if((iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ {
+ //Indicate the timecontainer is not ready
+ SetMediaState(ESvgMediaNotReady);
+
+ PauseLockedEntities();
+
+ // Inform the observer that the time container is not ready
+ if ( iObserver )
+ {
+ iObserver->TimeContainerNotReady();
+ }
+ }
+ //Once we have got the right timed entity on which not ready was called
+ //exit the loop
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::SyncpauseElement
+//Pauses running syncronised elements
+ /*
+ Pauses a single element
+
+ If ( syncStatus is not paused AND ( userStatus is not paused or not stopped ) )
+ Pause Element
+ Set syncStatus = Paused // iIsSyncPaused
+
+
+ If Element type = Animation
+ {
+ Get Child TC Pointer.
+ If Valid,
+ Call Child Tc->SyncPause
+ }
+
+
+ */
+ // -----------------------------------------------------------------------------
+//
+
+
+void CSvgTimeContainer::SyncPauseElement(TSvgTimedEntityListItem* aTimedEntityItem)
+ {
+ if (
+ (!aTimedEntityItem->iIsSyncPaused)
+ && (aTimedEntityItem->iUserState == ESvgUserRunning)
+ )
+ {
+ aTimedEntityItem->iTimedEntity->PauseTimedEntity();
+ }
+ aTimedEntityItem->iIsSyncPaused = ETrue;
+
+ if(aTimedEntityItem->iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* lAnimTimeContainer = aTimedEntityItem->iTimedEntity->GetChildTimeContainer();
+ if(lAnimTimeContainer)
+ {
+ lAnimTimeContainer->SyncPause();
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::TimedEntityReady
+// Informing the time container that timed entity is ready
+ /*
+ If this element is locked
+ {
+ If all locked elements ready
+ {
+ ResumeLockedElements
+ {
+ For all locked elements:
+ SyncResumeElement.
+
+ }
+ If TC Observer present
+ Give ready of TC
+ }
+ }
+ */
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::TimedEntityReady(
+ MSvgTimedEntityInterface* aTimedEntity )
+ {
+
+ TBool lIsOkToResume = ETrue;
+
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ //get current element from entities list
+ if ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity == aTimedEntity )
+ {
+ //set current element as not ready
+ (iTcTimedEntities[ lItemIndex ]).iMediaState = ESvgMediaReady;
+
+ //if current element is locked
+ if((iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ {
+ //for all timed entities
+ for ( lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ // check if any timed entities are locked and not ready
+ // Idle elements cannot be checked as they are not active
+ if(
+ ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ && ((iTcTimedEntities[lItemIndex].iMediaState == ESvgMediaNotReady))
+ )
+ {
+ //Indicate cant resume now as some locked entities are not ready
+ lIsOkToResume = EFalse;
+ //exit loop
+ break;
+ }
+ }
+ }
+ //Once we have got the right timed entity on which ready was called
+ //exit the loop
+ break;
+ }
+ }
+
+ if ( lIsOkToResume )
+ {
+ //Indicate the timecontainer is ready as all elements are ready
+ SetMediaState(ESvgMediaReady);
+
+ ResumeLockedEntities();
+
+ // Inform the observer that the time container is ready
+ if ( iObserver )
+ {
+ iObserver->TimeContainerReady();
+ }
+ }
+ }
+
+//-------------------------------------------------------------------------------
+//void CSvgTimeContainer::SyncResumeElement
+ /*
+ Resumes a single element
+
+ if ( syncStatus is not running AND (userStatus is running))
+ AND (TC.syncStatus is running) AND (TC.userStatus is running))
+ {
+
+ Resume Element
+ }
+ Set syncStatus = running
+ If Element type = Animation
+ {
+ Get Child TC Pointer.
+ If Valid,
+ Call Child Tc->SyncResume
+ }
+
+ */
+//-------------------------------------------------------------------------------
+void CSvgTimeContainer::SyncResumeElement(TSvgTimedEntityListItem* aTimedEntity)
+ {
+ if(
+ (aTimedEntity->iIsSyncPaused)
+ && (aTimedEntity->iUserState == ESvgUserRunning)
+ && (!iIsSyncPaused)
+ && (iUserState == ESvgUserRunning )
+ )
+ {
+ aTimedEntity->iTimedEntity->ResumeTimedEntity();
+ }
+ aTimedEntity->iIsSyncPaused = EFalse;
+
+ if(aTimedEntity->iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* AnimTimeContainer = aTimedEntity->iTimedEntity->GetChildTimeContainer();
+ if(AnimTimeContainer)
+ {
+ AnimTimeContainer->SyncResume();
+ }
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::PauseLockedEntities
+// Pauses the time container's locked entities
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::PauseLockedEntities()
+ {
+ /*
+ (Whether ready/not ready)
+ For all locked elements:
+ SyncPauseElement.
+ */
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ if((iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ {
+ SyncPauseElement(&iTcTimedEntities[ lItemIndex ]);
+ }
+ }
+ SyncPauseElement(&iLrteListItem);
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::ResumeLockedEntities
+// Resumes the time container's locked entities
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::ResumeLockedEntities()
+ {
+ /*
+ For all locked elements:
+ SyncResumeElement.
+ */
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ if((iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ {
+ SyncResumeElement(&iTcTimedEntities[ lItemIndex ]);
+ }
+ }
+ SyncResumeElement(&iLrteListItem) ;
+
+
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::SetTcObserver
+// Set the observer for the time container
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::SetTcObserver( MSvgTimeContainerObserver* aTCObserver )
+ {
+ iObserver = aTCObserver;
+ // Inform the observer that the time container is ready
+ if ( iObserver )
+ {
+ if ( iMediaState == ESvgMediaReady)
+ {
+ iObserver->TimeContainerReady();
+ }
+ else
+ {
+ iObserver->TimeContainerNotReady();
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserStop
+// Called to handle user/client generated stop event
+/*
+ UserStop()
+ {
+
+ Set the TC.UserState too
+ This.UserState = Paused.
+
+
+ For all timed entities
+ {
+ UserStopElement()
+ {
+ StopElement()
+ Set userStatus = Stopped
+ If Element type = Animation
+ {
+ Get Child TC Pointer.
+ If Valid,
+ Call Child Tc->UserStop
+ }
+
+ }
+ }
+ }
+ */
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::UserStop()
+ {
+ SetUserState(ESvgUserStopped);
+ // Cancel the timer
+ if ( iTimer )
+ {
+ iTimer->SVGStop();
+ }
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ UserStopElement(&iTcTimedEntities[lItemIndex]);
+ }
+ UserStopElement(&iLrteListItem);
+
+ }
+
+
+void CSvgTimeContainer::UserStopElement(TSvgTimedEntityListItem* aTimedEntity)
+{
+ aTimedEntity->iTimedEntity->StopTimedEntity();
+
+ aTimedEntity->iIsSyncPaused = EFalse;
+
+ SetUserState(ESvgUserStopped);
+
+ if(aTimedEntity->iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* AnimTimeContainer = aTimedEntity->iTimedEntity->GetChildTimeContainer();
+ if(AnimTimeContainer)
+ {
+ AnimTimeContainer->UserStop();
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserResume
+// Called to handle user/client generated resume event
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::UserResume( TInt32 aTime )
+ {
+
+ SetUserState(ESvgUserRunning);
+ if ( iTimer )
+ {
+ iTimer->SVGResume( aTime );
+ }
+
+
+
+ /*
+ UserResume()
+ {
+ For all timed entities
+ {
+ UserResumeElement()
+ }
+ }
+ */
+
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ UserResumeElement(&iTcTimedEntities[ lItemIndex ]);
+ }
+
+
+ UserResumeElement(&iLrteListItem);
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserResumeElement
+/*
+UserResumeElement()
+ {
+ If(Element is locked)
+ {
+ If ( syncStatus is running AND TC.syncStatus is running)
+ Resume Element
+ }
+ Else
+ {
+ ResumeElement()
+ }
+
+ Set userStatus = running
+ If Element type = Animation
+ {
+ Get Child TC Pointer.
+ If Valid,
+ Call Child Tc->UserResume
+ }
+
+ }
+*/
+// -----------------------------------------------------------------------------
+//
+
+void CSvgTimeContainer::UserResumeElement(TSvgTimedEntityListItem* aTimedEntity)
+ {
+ aTimedEntity->iUserState = ESvgUserRunning ;
+
+ if(//Element is locked
+ (aTimedEntity->iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked)
+ &&((aTimedEntity->iIsSyncPaused) || (iIsSyncPaused))
+ //element or timecontainer is syncpaused
+ )
+ {
+ //Do not resume
+ }
+ else
+ {
+ aTimedEntity->iTimedEntity->ResumeTimedEntity();
+ }
+
+
+ if(aTimedEntity->iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* AnimTimeContainer = aTimedEntity->iTimedEntity->GetChildTimeContainer();
+ if(AnimTimeContainer)
+ {
+ AnimTimeContainer->UserResume();
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserPlay
+// Called to handle user/client generated play event
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::UserPlay()
+ {
+
+
+ if ( !iTimer )
+ {
+ // Check whether this time container has a parent
+ // then we do not have to create the timer
+ if ( !iIsParentTcPresent )
+ {
+ // Obtain the post order list of media elements
+ RPointerArray<CSvgElementImpl> lMediaEleList;
+ lMediaEleList.Reset();
+
+ CSvgElementImpl *handle = (CSvgElementImpl *)(iOwnerDoc->RootElement());
+
+ //Parse postorderr only if there are media elements
+ if(iTcTimedEntities.Count() > 1 )
+ {
+ iOwnerDoc->ParsePostOrderMediaElements( handle, lMediaEleList );
+ }
+
+
+ // Rearrange as per Post order
+ RearrangeTimedEntityList( lMediaEleList );
+
+ // Done with the list
+ lMediaEleList.Close();
+
+ TRAPD( lTimerCreateErr, iTimer = CSvgTimer::NewL( this ) );
+
+ if ( lTimerCreateErr != KErrNone )
+ {
+ // Error Processing
+ return;
+ }
+
+ iTimer->SetStartTime();
+
+ // the current home time needs to be updated.
+ if ( iOwnerDoc && iCurrentTime != 0 )
+ {
+ iCurrentTime = 0;
+ iCurrentTick.iParentTcTick = 0;
+ iCurrentTick.iRealTimeTick = 0;
+ TSvgTimerEvent timeEvent( iCurrentTime );
+ iOwnerDoc->Reset( &timeEvent );
+ }
+
+ if ( !iTimer->IsActive() )
+ {
+ iTimer->After( 1000 );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserPause
+
+ /*
+
+ Set the TC.UserState too
+ This.UserState = Paused.
+
+ UserPause()
+ {
+ For all timed entities
+ {
+ UserPauseElement() iIsSyncPaused is syncStatus
+
+ }
+ }
+ */
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::UserPause()
+{
+ SetUserState(ESvgUserPaused);
+ if ( iTimer )
+ {
+ iTimer->SVGStop();
+ }
+
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ UserPauseElement(&iTcTimedEntities[ lItemIndex ]);
+ }
+
+ UserPauseElement(&iLrteListItem);
+
+}
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserPauseElement
+// Called to handle user/client generated pause event
+//
+/*
+ UserPauseElement() iIsSyncPaused is syncStatus
+ {
+ If ( syncStatus is not Paused AND userStatus is not paused or stopped )
+ Pause Element
+ Set userStatus = Paused
+
+ If Element type = Animation
+ {
+ Get Child TC Pointer.
+ If Valid,
+ Call Child Tc->UserPause
+ }
+
+ }
+*/
+
+//-----------------------------------------------------------------------------
+//
+
+ void CSvgTimeContainer::UserPauseElement(TSvgTimedEntityListItem* aTimedEntity)
+{
+ if(
+ !(aTimedEntity->iIsSyncPaused )
+ && (aTimedEntity->iUserState == ESvgUserRunning)
+ )
+ {
+ aTimedEntity->iTimedEntity->PauseTimedEntity();
+
+ }
+ aTimedEntity->iUserState = ESvgUserPaused;
+
+ if(aTimedEntity->iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* AnimTimeContainer = aTimedEntity->iTimedEntity->GetChildTimeContainer();
+ if(AnimTimeContainer)
+ {
+ AnimTimeContainer->UserPause();
+ }
+ }
+
+}
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::UserSeek
+// Called to handle user/client generated seek event
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::UserSeek(
+ TInt aTime ) // Time in msecs to seek
+ {
+ if ( iTimer )
+ {
+ //if ( iOwnerDoc && iCurrentTime != aTime )
+ if ( iOwnerDoc)
+ {
+ iCurrentTime = aTime;
+ iCurrentTick.iParentTcTick = aTime;
+ iCurrentTick.iRealTimeTick = aTime;
+ TSvgTimerEvent timeEvent( iCurrentTime );
+ iOwnerDoc->Reset( &timeEvent );
+ }
+
+ iTimer->SetSeekTime( aTime );
+ }
+ // Need to send user resume events to timed entities
+ SetUserState(ESvgUserRunning);
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ UserResumeElement( &iTcTimedEntities[ lItemIndex ] );
+ }
+
+ UserResumeElement(&iLrteListItem);
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::UserResetTime
+// Resets the time variables
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::UserResetTime()
+ {
+ if ( iTimer )
+ {
+ iTimer->ResetTime();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::UserChangeFrameDuration
+// Changes the frame duration in the timer
+// ---------------------------------------------------------------------------
+void CSvgTimeContainer::UserChangeFrameDuration( TUint32 aTimerDuration )
+ {
+ if ( iTimer )
+ {
+ iTimer->ChangeFrameDuration( aTimerDuration );
+ }
+ }
+// ---------------------------------------------------------------------------
+// CSvgTimeContainer::UserFps
+// Returns number of frames per sec(debug api)
+// ---------------------------------------------------------------------------
+TUint CSvgTimeContainer::UserFps()
+ {
+ if ( iTimer )
+ {
+ return iTimer->Fps();
+ }
+ return 0;
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::ParentTimeContainerTick
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::ParentTimeContainerTick(
+ TSvgTick aTick ) // Current tick information
+ {
+ // Update the member variable keeping track of current tick
+ iCurrentTick.iRealTimeTick = aTick.iRealTimeTick;
+
+ // If the TC is locked wrt to its parent and parent is present
+ if ( ( iTcSyncBehavior == ESvgSyncLocked ) && iIsParentTcPresent )
+ {
+ iCurrentTick.iParentTcTick = aTick.iParentTcTick;
+ // Propogate the tick to all timed elements in the container
+ PropogateTickToContainerElements( iCurrentTick );
+ }
+ else
+ {
+ // Container not locked with respect to parent.
+ // Get Sync Master Entity in the group and use its clock as timing
+ // reference for the Time container.
+ MSvgTimedEntityInterface* lSyncMaster = GetSyncMasterForTimeContainer();
+
+ if ( !lSyncMaster )
+ {
+ // No Sync Master
+ iCurrentTick.iParentTcTick = aTick.iRealTimeTick;
+ // Propogate the tick to all timed elements in the container
+ PropogateTickToContainerElements( iCurrentTick );
+ }
+ else
+ {
+ // Sync Master Present, check whether it can generate tick
+ if ( lSyncMaster->CanGenerateTick() )
+ {
+ TUint32 lMasterCurTime = 0;
+ lSyncMaster->GetEntityCurrentTime( lMasterCurTime );
+ iCurrentTick.iParentTcTick = lMasterCurTime;
+ // Propogate the tick to all timed elements in the container
+ PropogateTickToContainerElements( iCurrentTick );
+ }
+ else
+ {
+ // Sync Master present but cannot generate tick, so use
+ // real time tick
+ iCurrentTick.iParentTcTick = aTick.iRealTimeTick;
+ // Propogate the tick to all timed elements in the container
+ PropogateTickToContainerElements( iCurrentTick );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::GetEntitySyncBehavior
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+//
+TSvgSyncBehaviour CSvgTimeContainer::GetEntitySyncBehavior()
+ {
+ return iTcSyncBehavior;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::GetEntityCurrentTime
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::GetEntityCurrentTime( TUint32&
+ aEntityCurTime ) // Current Entity Time in msecs.
+ {
+ // IF GetCurSyncMasterStatus == FALSE, Error. // Shouldn't be happening.
+ TBool lCurSyncMasterStatus = EFalse;
+ GetCurSyncMasterStatus( lCurSyncMasterStatus );
+
+ if ( lCurSyncMasterStatus )
+ {
+ // Resolve the sync Master for the container. (Should have happened?)
+ MSvgTimedEntityInterface* lSyncMaster = GetSyncMasterForTimeContainer();
+ // IF no syncMaster, Error (Shouldn't be happening.)
+ if ( !lSyncMaster )
+ {
+ return;
+ }
+ lSyncMaster->GetEntityCurrentTime( aEntityCurTime );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::GetCnfSyncMasterStatus
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+//
+void CSvgTimeContainer::GetCnfSyncMasterStatus(
+ TBool& aIsSyncMaster ) // Indicates whether the element is configured as
+ // Sync Master.
+ {
+ iTcSyncMasterConfig = aIsSyncMaster;
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::GetCurSyncMasterStatus
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::GetCurSyncMasterStatus(
+ TBool& aIsSyncMaster ) // Indicates whether the element is currrently
+ // Sync Master.
+ {
+ aIsSyncMaster = iTcSyncMasterCurrent;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::SetCurSyncMasterStatus
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::SetCurSyncMasterStatus(
+ TBool aSyncMasterStatus ) // Indicates whether the element is currrently
+ // Sync Master.
+ {
+ iTcSyncMasterCurrent = aSyncMasterStatus;
+ // Update the state of current sync master if there is one
+ if ( iTcSyncMaster )
+ {
+ iTcSyncMaster->SetCurSyncMasterStatus( aSyncMasterStatus );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::CanGenerateTick
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+TBool CSvgTimeContainer::CanGenerateTick()
+ {
+ MSvgTimedEntityInterface* lSyncMaster = GetSyncMasterForTimeContainer();
+ if(lSyncMaster == iLrteListItem.iTimedEntity)
+ {
+ return EFalse;
+ }
+ return ( lSyncMaster ? ETrue:EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::CanUseParentTick
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+TBool CSvgTimeContainer::CanUseParentTick()
+ {
+ // This function returns true if it does not have a parent time container
+ // Hence the root time container creates the timer and hence can use
+ // parent tick
+ return ( !iIsParentTcPresent );
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::ResyncTimedEntity
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::ResyncTimedEntity(
+ TUint32 /*aSynctime */) // Time for resync in msecs.
+ {
+ // TODO: Resync Logic
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::PauseTimedEntity
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::PauseTimedEntity()
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::ResumeTimedEntity
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::ResumeTimedEntity()
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::StopTimedEntity
+// From MSvgTimedEntityInterface
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::StopTimedEntity()
+ {
+
+ }
+
+
+//From MSvgTimedEntityInterface
+TSvgObjectType CSvgTimeContainer::ObjectType()
+{
+ return ESvgInvalidReference;
+}
+
+//returns the child time container of the element
+//used in timecontainer
+CSvgTimeContainer* CSvgTimeContainer::GetChildTimeContainer()
+{
+ return NULL;
+}
+
+//-------------------------------------------------------------------------------
+/*
+TC::SyncPause()
+{
+ tc.SyncStatus = Paused;
+
+ For All Locked Elements
+ {
+ Pause Element;
+ Note: No element level state change, as element level syncStatus reflects only
+ syncStatus evaluated in TC group level. ,e.g. syncStatus could be running in this
+ case
+ If element = animation
+ {
+ Get Child TC pointer
+ If Child TC
+ childTc->SyncPause;
+ }
+
+ }
+}
+
+
+*/
+//-------------------------------------------------------------------------------
+void CSvgTimeContainer::SyncPause()
+ {
+ //iIsSyncPaused = ETrue;
+ SetSyncState(ETrue);
+
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ if((iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ {
+ iTcTimedEntities[lItemIndex].iTimedEntity->PauseTimedEntity();
+ }
+
+ if(iTcTimedEntities[lItemIndex].iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* AnimTimeContainer = iTcTimedEntities[lItemIndex].iTimedEntity->GetChildTimeContainer();
+ if(AnimTimeContainer)
+ {
+ AnimTimeContainer->SyncPause();
+ }
+ }
+ }
+ iLrteListItem.iTimedEntity->PauseTimedEntity() ;
+
+ }
+
+//----------------------------------------------------------------------------------
+//
+/*
+TC::SyncResume()
+{
+ tc.SyncStatus = Running;
+ For all locked elements
+ {
+ If (syncStatus == running AND userStatus == running AND TC.userStatus == running)
+ {
+ Resume Element
+ }
+
+ If element = animation
+ {
+ Get Child TC pointer
+ If Child TC
+ childTc->SyncResume;
+ }
+ }
+}
+
+
+*/
+//----------------------------------------------------------------------------------
+void CSvgTimeContainer::SyncResume()
+ {
+ SetSyncState(EFalse);
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ if((iTcTimedEntities[ lItemIndex ]).iTimedEntity->GetEntitySyncBehavior() == ESvgSyncLocked )
+ {
+ if(
+ !(iTcTimedEntities[lItemIndex].iIsSyncPaused)
+ &&(iTcTimedEntities[lItemIndex].iUserState == ESvgUserRunning)
+ &&(iUserState == ESvgUserRunning)
+ )
+ {
+ iTcTimedEntities[lItemIndex].iTimedEntity->ResumeTimedEntity();
+ }
+
+ }
+
+ if(iTcTimedEntities[lItemIndex].iTimedEntity->ObjectType() == ESvgMediaAnimationElement)
+ {
+ CSvgTimeContainer* AnimTimeContainer = iTcTimedEntities[lItemIndex].iTimedEntity->GetChildTimeContainer();
+ if(AnimTimeContainer)
+ {
+ AnimTimeContainer->SyncResume();
+ }
+ }
+ }
+
+ iLrteListItem.iTimedEntity->ResumeTimedEntity();
+
+}
+//---------------------------------------------------------------
+//Sets the time container User state
+//void CSvgTimeContainer::SetUserState(TSvgEntityUserState state)
+//---------------------------------------------------------------
+void CSvgTimeContainer::SetUserState(TSvgEntityUserState state)
+{
+ iUserState = state;
+ /* #ifdef _DEBUG
+ RDebug::Print(_L("CSvgTimeContainer User State changed to %d"),state);
+ RDebug::Print(_L("\n0.ESvgUserRunning 1.ESvgUserPaused 2.ESvgUserStopped\n\n"));
+ #endif
+ */
+}
+
+
+//---------------------------------------------------------------
+//Sets the time container Media state
+//void CSvgTimeContainer::SetMediaState(TSvgEntityMediaState state)
+//---------------------------------------------------------------
+void CSvgTimeContainer::SetMediaState(TSvgEntityMediaState state)
+{
+ iMediaState = state;
+ /*
+ #ifdef _DEBUG
+ RDebug::Print(_L("CSvgTimeContainer Media State changed to %d"),state);
+ RDebug::Print(_L("\n0.ESvgMediaIdle 1.ESvgMediaNotReady 2.ESvgMediaReady\n\n"));
+ #endif
+ */
+}
+
+//---------------------------------------------------------------
+//Sets the time container sync state state
+//void CSvgTimeContainer::SetSyncState(TBool state)
+//---------------------------------------------------------------
+void CSvgTimeContainer::SetSyncState(TBool state)
+{
+ iIsSyncPaused = state;
+/* #ifdef _DEBUG
+ RDebug::Print(_L("CSvgTimeContainer iIsyncPaused changed to %d"),state);
+ RDebug::Print(_L("\n0 False 1 True\n\n"));
+ #endif
+ */
+}
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::PropogateTickToContainerElements
+// Propogate tick to all elements in time container
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::PropogateTickToContainerElements( TSvgTick& aTick )
+ {
+ // Propogate the tick to all container elements
+ TInt lTimedEntityListCnt = iTcTimedEntities.Count();
+ for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
+ {
+ (iTcTimedEntities[ lItemIndex ]).iTimedEntity->ParentTimeContainerTick( aTick );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::RearrangeTimedEntityList
+// Rearrange the timed entities as per post order
+// -----------------------------------------------------------------------------
+void CSvgTimeContainer::RearrangeTimedEntityList( RPointerArray<CSvgElementImpl>&
+ aPostOrderList )
+ {
+ TUint lCurElement = 0;
+ TUint lCurTimedEntity = 0;
+ for ( ;lCurElement < aPostOrderList.Count(); lCurElement++, lCurTimedEntity++ )
+ {
+ CSvgMediaElementBase* lCurMediaEle = ( CSvgMediaElementBase* )
+ aPostOrderList[ lCurElement ];
+
+ // Start looking in the timed entity list from lCurTimedEntity
+ TUint lListIndex = lCurTimedEntity;
+
+ // Find the element in the current timed entity list
+ /*for ( ; ( ( iTcTimedEntities[ lListIndex ].iTimedEntity !=
+ ( MSvgTimedEntityInterface* ) lCurMediaEle ) &&
+ ( lListIndex < iTcTimedEntities.Count() ) );
+ lListIndex++ )
+ {
+ }
+ */
+ do
+ {
+ if( iTcTimedEntities[ lListIndex ].iTimedEntity == ( MSvgTimedEntityInterface* ) lCurMediaEle )
+ break;
+ lListIndex++;
+ }while(lListIndex < iTcTimedEntities.Count() ) ;
+
+
+ if ( lListIndex != iTcTimedEntities.Count() )
+ {
+ if ( lListIndex != lCurTimedEntity )
+ {
+ // Not in same position, need to swap
+ TSvgTimedEntityListItem lTempItem = iTcTimedEntities[ lCurTimedEntity ];
+ iTcTimedEntities[ lCurTimedEntity ] = iTcTimedEntities[ lListIndex ];
+ iTcTimedEntities[ lListIndex ] = lTempItem;
+ }
+ }
+ else
+ {
+ // Can occur in case of Delete Timed Entity -> ignore
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSvgTimeContainer::?member_function
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+
+
+// End of File