/*

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