开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
perscmgr.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：32k
源码类别：

Symbian

开发平台：

C/C++

perscmgr.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxcom.h"
  37. #include "hxresult.h"
  38. #include "hxstrutl.h"
  39. #include "hxstring.h"
  40. #include "hxmap.h"
  41. #include "smiltype.h"
  42. #include "hxausvc.h"
  43. #include "hxengin.h"
  44. #include "hxcore.h"
  45. #include "hxgroup.h"
  46. #include "basgroup.h"
  47. #include "advgroup.h"
  48. #include "hxplay.h"
  49. #include "hxbsrc.h"
  50. #include "hxsrc.h"
  51. #include "hxplugn.h"
  52. #include "hxrendr.h"
  53. #include "srcinfo.h"
  54. #include "sitemgr.h"
  55. #include "perscmgr.h"
  57. #include "hxheap.h"
  58. #ifdef _DEBUG
  59. #undef HX_THIS_FILE
  60. static const char HX_THIS_FILE[] = __FILE__;
  61. #endif
  63. HXPersistentComponent::HXPersistentComponent(HXPersistentComponentManager* pManager)
  64.     : m_lRefCount(0)
  65.     , m_bInitialized(FALSE)
  66.     , m_bToBeClosed(FALSE)
  67.     , m_bCleanupLayoutCalled(FALSE)
  68.     , m_uGroups(0)
  69.     , m_uTracks(0)
  70.     , m_ulComponentID(0)
  71.     , m_pSourceInfo(NULL)
  72.     , m_pPersistentRenderer(NULL)
  73.     , m_pRendererAdviseSink(NULL)
  74.     , m_pGroupSink(NULL)
  75.     , m_pComponentManager(NULL)
  76.     , m_pPersistentParent(NULL)
  77.     , m_pPersistentChildList(NULL)
  78.     , m_pProperties(NULL)
  79.     , m_ulPersistentType(0)
  80. {
  81.     m_pComponentManager = pManager;    
  82.     HX_ADDREF(m_pComponentManager);
  83. }
  85. HXPersistentComponent::~HXPersistentComponent(void)
  86. {
  87.     Remove();
  89.     HX_DELETE(m_pPersistentChildList);
  90.     HX_RELEASE(m_pPersistentParent);
  91.     HX_RELEASE(m_pComponentManager);
  92. }
  94. /*
  95.  *  IUnknown methods
  96.  */
  97. STDMETHODIMP HXPersistentComponent::QueryInterface(REFIID riid, void** ppvObj)
  98. {
  99.     QInterfaceList qiList[] =
  100.         {
  101.             { GET_IIDHANDLE(IID_IHXPersistentComponent), (IHXPersistentComponent*)this },
  102.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPersistentComponent*)this },
  103.         };
  104.     
  105.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  106. }
  108. STDMETHODIMP_(ULONG32) HXPersistentComponent::AddRef()
  109. {
  110.     return InterlockedIncrement(&m_lRefCount);
  111. }
  113. STDMETHODIMP_(ULONG32) HXPersistentComponent::Release()
  114. {
  115.     if (InterlockedDecrement(&m_lRefCount) > 0)
  116.     {
  117.         return m_lRefCount;
  118.     }
  120.     delete this;
  121.     return 0;
  122. }
  124. /************************************************************************
  125.  * Method:
  126.  *     IHXPersistentComponent::Init
  127.  * Purpose:
  128.  *     initialize persistent component
  129.  */
  130. STDMETHODIMP
  131. HXPersistentComponent::Init(IHXPersistentRenderer* pPersistentRenderer)
  132. {
  133.     m_bInitialized = TRUE;
  135.     m_pPersistentRenderer = pPersistentRenderer;
  136.     HX_ADDREF(m_pPersistentRenderer);
  138.     return HXR_OK;
  139. }
  141. /************************************************************************
  142.  * Method:
  143.  *     IHXPersistentComponent::AddRendererAdviseSink
  144.  * Purpose:
  145.  *     add renderer advise sink
  146.  */
  147. STDMETHODIMP
  148. HXPersistentComponent::AddRendererAdviseSink(IHXRendererAdviseSink* pSink)
  149. {
  150.     m_pRendererAdviseSink = pSink;
  151.     HX_ADDREF(m_pRendererAdviseSink);
  153.     return HXR_OK;
  154. }
  156. /************************************************************************
  157.  * Method:
  158.  *     IHXPersistentComponent::RemoveRendererAdviseSink
  159.  * Purpose:
  160.  *     remove renderer advise sink
  161.  */
  162. STDMETHODIMP
  163. HXPersistentComponent::RemoveRendererAdviseSink(IHXRendererAdviseSink* pSink)
  164. {    
  165.     HX_RELEASE(m_pRendererAdviseSink);
  167.     return HXR_OK;
  168. }
  170. /************************************************************************
  171.  * Method:
  172.  *     IHXPersistentComponent::AddGroupSink
  173.  * Purpose:
  174.  *     add renderer advise sink
  175.  */
  176. STDMETHODIMP
  177. HXPersistentComponent::AddGroupSink(IHXGroupSink* pSink)
  178. {
  179.     m_pGroupSink = pSink;
  180.     HX_ADDREF(m_pGroupSink);
  182.     return HXR_OK;
  183. }
  185. /************************************************************************
  186.  * Method:
  187.  *     IHXPersistentComponent::RemoveGroupSink
  188.  * Purpose:
  189.  *     remove renderer advise sink
  190.  */
  191. STDMETHODIMP
  192. HXPersistentComponent::RemoveGroupSink(IHXGroupSink* pSink)
  193. {
  194.     HX_RELEASE(m_pGroupSink);
  196.     return HXR_OK;
  197. }
  199. /************************************************************************
  200.  * Method:
  201.  *     IHXPersistentComponent::GetPersistentRenderer
  202.  * Purpose:
  203.  *     get persistent renderer
  204.  */
  205. STDMETHODIMP
  206. HXPersistentComponent::GetPersistentRenderer(REF(IHXPersistentRenderer*) pPersistentRenderer)
  207. {
  208.     HX_RESULT rc = HXR_OK;
  210.     pPersistentRenderer = m_pPersistentRenderer;
  211.     HX_ADDREF(pPersistentRenderer);
  213.     return rc;
  214. }
  215.     
  216. /************************************************************************
  217.  * Method:
  218.  *     IHXPersistentComponent::GetPersistentProperties
  219.  * Purpose:
  220.  *     get persistent component properties
  221.  */
  222. STDMETHODIMP
  223. HXPersistentComponent::GetPersistentProperties(REF(IHXValues*) pProperties)
  224. {
  225.     pProperties = m_pProperties;
  226.     if (pProperties)
  227.     {
  228. pProperties->AddRef();
  229. return HXR_OK;
  230.     }
  232.     return HXR_FAILED;
  233. }
  235. HX_RESULT
  236. HXPersistentComponent::GetPersistentComponent(UINT32 ulComponentID, 
  237.        REF(IHXPersistentComponent*) pComponent)
  238. {
  239.     HX_RESULT     rc = HXR_FAILED;
  240.     HXPersistentComponent* pHXPersistentComponent = NULL;
  241.     CHXSimpleList::Iterator i;
  243.     pComponent = NULL;
  245.     if (m_ulComponentID == ulComponentID)
  246.     {
  247. QueryInterface(IID_IHXPersistentComponent, (void**)&pComponent);
  248. rc = HXR_OK;
  249.     }
  250.     else if (m_pPersistentChildList)
  251.     {
  252. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  253. {
  254.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  255.     rc = pHXPersistentComponent->GetPersistentComponent(ulComponentID, pComponent);
  257.     if (HXR_OK == rc && pComponent)
  258.     {
  259. break;
  260.     }
  261. }
  262.     }
  264.     return rc;
  265. }
  267. HX_RESULT
  268. HXPersistentComponent::CurrentGroupSet(UINT16 uGroupIndex, IHXGroup* pGroup)
  269. {
  270.     HX_RESULT     rc = HXR_OK;
  271.     HXPersistentComponent* pHXPersistentComponent = NULL;
  272.     CHXSimpleList::Iterator i;
  274.     if (m_pPersistentChildList)
  275.     {
  276. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  277. {
  278.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  279.     rc = pHXPersistentComponent->CurrentGroupSet(uGroupIndex, pGroup);
  280. }
  281.     }
  283.     m_pSourceInfo->Reset();
  285.     if (m_pGroupSink)
  286.     {
  287. rc = m_pGroupSink->CurrentGroupSet(uGroupIndex, pGroup);
  288.     }
  290.     return rc;
  291. }
  293. HX_RESULT
  294. HXPersistentComponent::OnTimeSync(UINT32 ulCurrentTime)
  295. {
  296.     HX_RESULT     rc = HXR_OK;
  297.     HXPersistentComponent* pHXPersistentComponent = NULL;
  298.     CHXSimpleList::Iterator i;
  300.     if (m_pPersistentChildList)
  301.     {
  302. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  303. {
  304.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  305.     rc = pHXPersistentComponent->OnTimeSync(ulCurrentTime);
  306. }
  307.     }
  309.     if (m_pSourceInfo)
  310.     {
  311. m_pSourceInfo->OnTimeSync(ulCurrentTime);
  312.     }
  314.    return rc;
  315. }
  317. UINT32
  318. HXPersistentComponent::GetPersistentComponentCount()
  319. {
  320.     UINT32 ulTotalCount = 0;
  321.     HXPersistentComponent* pHXPersistentComponent = NULL;
  322.     CHXSimpleList::Iterator i;
  324.     if (m_pPersistentChildList)
  325.     {
  326. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  327. {
  328.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  329.     ulTotalCount += pHXPersistentComponent->GetPersistentComponentCount();
  330. }
  331.     }
  333.     return (ulTotalCount + 1);
  334. }
  336. void
  337. HXPersistentComponent::TrackUpdated(UINT16 uGroupIndex, 
  338.      UINT16 uTrackIndex, 
  339.      IHXValues* pValues)
  340. {
  341.     HX_RESULT     rc = HXR_OK;
  342.     HXPersistentComponent* pHXPersistentComponent = NULL;
  343.     CHXSimpleList::Iterator i;
  345.     if (m_pPersistentChildList)
  346.     {
  347. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  348. {
  349.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  350.     pHXPersistentComponent->TrackUpdated(uGroupIndex, uTrackIndex, pValues);
  351. }
  352.     }
  354.     if (m_pRendererAdviseSink)
  355.     {
  356. m_pRendererAdviseSink->TrackUpdated(uGroupIndex, uTrackIndex, pValues);
  357.     }
  359.     return;
  360. }
  362. void
  363. HXPersistentComponent::AllRenderersClosed(void)
  364. {
  365.     HX_RESULT     rc = HXR_OK;
  366.     HXPersistentComponent* pHXPersistentComponent = NULL;
  367.     CHXSimpleList::Iterator i;
  369.     if (m_pPersistentChildList)
  370.     {
  371. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  372. {
  373.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  374.     pHXPersistentComponent->AllRenderersClosed();
  375. }
  376.     }
  378.     if (m_pSourceInfo)
  379.     {
  380. m_pSourceInfo->Reset();
  381.     }
  383.     return;
  384. }
  386. void
  387. HXPersistentComponent::Reset(void)
  388. {
  389.     HXPersistentComponent* pHXPersistentComponent = NULL;
  390.     CHXSimpleList::Iterator i;
  392.     if (m_pPersistentChildList)
  393.     {
  394. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  395. {
  396.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  397.     pHXPersistentComponent->Reset();
  398. }
  399.     }
  401.     m_pComponentManager->m_pPlayer->m_pSourceMap->RemoveKey(m_pSourceInfo->m_pSource);
  402.     m_pComponentManager->m_pPlayer->m_bSourceMapUpdated = TRUE;
  404.     m_pSourceInfo->m_bIsPersistentSource = FALSE;
  405.     m_pSourceInfo->Stop();
  407.     m_bToBeClosed = TRUE;
  409.     return;
  410. }
  412. void
  413. HXPersistentComponent::Remove()
  414. {
  415.     HXPersistentComponent* pHXPersistentComponent = NULL;
  416.     CHXSimpleList::Iterator i;
  418.     if (m_pPersistentChildList)
  419.     {
  420. for(i = m_pPersistentChildList->Begin();i != m_pPersistentChildList->End();++i)
  421. {
  422.     pHXPersistentComponent = (HXPersistentComponent*)(*i);
  423.     pHXPersistentComponent->Remove();
  424.     HX_RELEASE(pHXPersistentComponent);
  425. }
  426. m_pPersistentChildList->RemoveAll();
  427.     }
  428.     
  429.     if (m_pSourceInfo)
  430.     {
  431. HX_ASSERT(!m_pSourceInfo->m_bIsPersistentSource);
  432. m_pSourceInfo->CloseRenderers();
  433. HX_DELETE(m_pSourceInfo);
  434.     }
  436.     HX_RELEASE(m_pProperties);
  437.     HX_RELEASE(m_pRendererAdviseSink);
  438.     HX_RELEASE(m_pGroupSink);
  439.     HX_RELEASE(m_pPersistentRenderer);
  441.     return;
  442. }
  444. HXPersistentComponentManager::HXPersistentComponentManager(HXPlayer* pPlayer)
  445.     : m_lRefCount(0)
  446.     , m_ulComponentIndex(0)
  447.     , m_nCurrentGroup(0)
  448.     , m_pPlayer(pPlayer)
  449.     , m_pRootPersistentComponent(NULL)
  450. {
  451.     HX_ADDREF(m_pPlayer);
  452. }
  454. HXPersistentComponentManager::~HXPersistentComponentManager(void)
  455. {
  456.     Close();
  458.     HX_RELEASE(m_pPlayer);
  459. }
  461. /*
  462.  *  IUnknown methods
  463.  */
  464. STDMETHODIMP HXPersistentComponentManager::QueryInterface(REFIID riid, void** ppvObj)
  465. {
  466.     QInterfaceList qiList[] =
  467.         {
  468.             { GET_IIDHANDLE(IID_IHXPersistentComponentManager), (IHXPersistentComponentManager*)this },
  469.             { GET_IIDHANDLE(IID_IHXGroupSink), (IHXGroupSink*)this },
  470.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPersistentComponentManager*)this },
  471.         };
  472.     
  473.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  474. }
  476. STDMETHODIMP_(ULONG32) HXPersistentComponentManager::AddRef()
  477. {
  478.     return InterlockedIncrement(&m_lRefCount);
  479. }
  481. STDMETHODIMP_(ULONG32) HXPersistentComponentManager::Release()
  482. {
  483.     if (InterlockedDecrement(&m_lRefCount) > 0)
  484.     {
  485.         return m_lRefCount;
  486.     }
  488.     delete this;
  489.     return 0;
  490. }
  492. /************************************************************************
  493.  * Method:
  494.  *     IHXPersistentComponentManager::CreatePersistentComponent
  495.  * Purpose:
  496.  *     create persistent component
  497.  */
  498. STDMETHODIMP
  499. HXPersistentComponentManager::CreatePersistentComponent(REF(IHXPersistentComponent*)   pPersistentComponent)
  500. {
  501.     pPersistentComponent = new HXPersistentComponent(this);    
  502.     if (!pPersistentComponent)
  503.     {
  504. return HXR_OUTOFMEMORY;
  505.     }
  506.     
  507.     return HXR_OK;
  508. }
  510. /************************************************************************
  511.  * Method:
  512.  *     IHXPersistentComponentManager::AddPersistentComponent
  513.  * Purpose:
  514.  *     add persistent component
  515.  */
  516. STDMETHODIMP
  517. HXPersistentComponentManager::AddPersistentComponent(IHXPersistentComponent* pPersistentComponent)
  518. {
  519.     HX_RESULT rc = HXR_OK;
  520.     BOOL bFound = FALSE;
  521.     HXSource* pSource = NULL;
  522.     SourceInfo* pSourceInfo = NULL;
  523.     RendererInfo* pRendInfo = NULL;
  524.     HXPersistentComponent* pHXPersistentComponent = NULL;
  525.     HXPersistentComponent* pHXPersistentParentComponent = NULL;
  526.     IHXValues* pProperties = NULL;
  527.     IHXGroup* pGroup = NULL;
  528.     IHXPersistentComponent* pPersistentParentComponent = NULL;
  529.     IHXPersistentRenderer* pPersistentRenderer = NULL;
  530.     IHXRenderer* pRenderer = NULL;    
  531.     CHXMapPtrToPtr::Iterator ndxSource;
  532.     CHXMapLongToObj::Iterator ndxRend;
  533.     
  534.     pHXPersistentComponent = (HXPersistentComponent*)pPersistentComponent;
  535.     if (!pHXPersistentComponent || !pHXPersistentComponent->m_bInitialized)
  536.     {
  537. rc = HXR_FAILED;
  538. goto cleanup;
  539.     }
  541.     pPersistentRenderer = pHXPersistentComponent->m_pPersistentRenderer;
  542.     if (HXR_OK != pPersistentRenderer->QueryInterface(IID_IHXRenderer, (void**)&pRenderer))
  543.     {
  544. rc = HXR_INVALID_PARAMETER;
  545. goto cleanup;
  546.     }
  548.     // find component's source info - better way?
  549.     ndxSource = m_pPlayer->m_pSourceMap->Begin();
  550.     for (; ndxSource != m_pPlayer->m_pSourceMap->End() && !bFound; ++ndxSource)
  551.     {
  552. pSourceInfo = (SourceInfo*)(*ndxSource);
  553. pSource = pSourceInfo->m_pSource;
  555. ndxRend = pSourceInfo->m_pRendererMap->Begin();
  556. for (; ndxRend != pSourceInfo->m_pRendererMap->End(); ++ndxRend)
  557. {
  558.     pRendInfo = (RendererInfo*) (*ndxRend);
  559.     if (pRendInfo->m_pRenderer == pRenderer)
  560.     {
  561. bFound = TRUE;
  562. break;
  563.     }
  564. }
  565.     }
  567.     if (!bFound)
  568.     {
  569. rc = HXR_FAILED;
  570. goto cleanup;
  571.     }
  573.     if (!m_pRootPersistentComponent)
  574.     {
  575. m_ulComponentIndex = 0;
  576. m_pRootPersistentComponent = pHXPersistentComponent;
  577. m_pRootPersistentComponent->AddRef();
  579. // XXX HP TBD - when we support timing attributes on a SMIL URL
  580. // for now, we resets all timing attributes on the root persistent
  581. // component since there could be a case when the same timing values
  582. // are specified in a CGI URL sent to the player
  583. if (pSourceInfo && pSourceInfo->m_pSource)
  584. {     
  585.     IHXValues* pValues = new CHXHeader();
  586.     pValues->AddRef();
  588.     pValues->SetPropertyULONG32("Start", 0);
  589.     pValues->SetPropertyULONG32("End", 0);
  590.     pValues->SetPropertyULONG32("Delay", 0);
  591.     pValues->SetPropertyULONG32("Duration", 0);
  593.     pSourceInfo->m_pSource->UpdatePlayTimes(pValues);
  594.     HX_RELEASE(pValues);
  595. }     
  596.     }
  597.     else if (HXR_OK == GetPersistentComponent(pSourceInfo->m_ulPersistentComponentID, pPersistentParentComponent))
  598.     {
  599. pHXPersistentParentComponent = (HXPersistentComponent*)pPersistentParentComponent;
  601. // XXX HP 
  602. // to workaround the screwed-up layout handling within nested meta, we call
  603. // CleanupLayout() on the alternated persistent source if we haven't called 
  604. // CleanupLayout() yet. this is a no-worse-than-before temporary solution.
  605. // REMOVE THIS AFTER PROPERLY HANDLING LAYOUT WITHIN NESTED META
  606. if (pSourceInfo->m_bAltURL && !pHXPersistentParentComponent->m_bCleanupLayoutCalled)
  607. {
  608.     m_pPlayer->CleanupLayout();
  609.     pHXPersistentParentComponent->m_bCleanupLayoutCalled = TRUE;
  610. }
  612. if (!pHXPersistentParentComponent->m_pPersistentChildList)
  613. {
  614.     pHXPersistentParentComponent->m_pPersistentChildList = new CHXSimpleList();
  615. }
  616.     
  617. pHXPersistentParentComponent->m_pPersistentChildList->AddTail(pHXPersistentComponent);
  618. pHXPersistentComponent->AddRef();
  620. pHXPersistentComponent->m_pPersistentParent = pHXPersistentParentComponent;
  621. pHXPersistentParentComponent->AddRef();
  622.     }
  624.     pSourceInfo->m_bIsPersistentSource = TRUE;
  626.     if (HXR_OK == pHXPersistentComponent->m_pPersistentRenderer->GetPersistentProperties(pProperties))
  627.     {
  628. pProperties->GetPropertyULONG32("PersistentType", pHXPersistentComponent->m_ulPersistentType);
  629.     }
  630.     HX_RELEASE(pProperties);
  632.     pSourceInfo->m_ulPersistentComponentSelfID = m_ulComponentIndex;
  634.     // new persistent info
  635.     pHXPersistentComponent->m_pSourceInfo = pSourceInfo;
  636.     pHXPersistentComponent->m_ulComponentID = m_ulComponentIndex;
  638.     // get the persistent properties(track properties)
  639.     if (HXR_OK == m_pPlayer->m_pGroupManager->GetGroup(pSourceInfo->m_uGroupID, pGroup))
  640.     {
  641. pGroup->GetTrack(pSourceInfo->m_uTrackID, pHXPersistentComponent->m_pProperties);
  642.     }
  643.     HX_RELEASE(pGroup);
  645.     pPersistentRenderer->InitPersistent(m_ulComponentIndex, 
  646. pSourceInfo->m_uGroupID,
  647. pSourceInfo->m_uTrackID,
  648. pHXPersistentParentComponent?pHXPersistentParentComponent->m_pPersistentRenderer:((IHXPersistentRenderer*) NULL));
  649.     m_ulComponentIndex++;
  651.     m_pPlayer->m_pGroupManager->PersistentComponentAdded(pSourceInfo->m_uGroupID, pSourceInfo->m_uTrackID);
  653. cleanup:
  655.     HX_RELEASE(pPersistentParentComponent);
  656.     HX_RELEASE(pRenderer);
  658.     return rc;
  659. }
  661. /************************************************************************
  662.  * Method:
  663.  *     IHXPersistentComponentManager::RemovePersistentComponent
  664.  * Purpose:
  665.  *     remove persistent component
  666.  */
  667. STDMETHODIMP
  668. HXPersistentComponentManager::RemovePersistentComponent(UINT32 ulPersistentComponentID)
  669. {
  670.     HX_RESULT rc = HXR_OK;
  671.     LISTPOSITION lPosition = NULL;
  672.     HXPersistentComponent* pHXPersistentParentComponent = NULL;
  673.     HXPersistentComponent* pHXPersistentComponent = NULL;
  674.     IHXPersistentComponent* pPersistentComponent = NULL;
  676.     if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  677.     {
  678. pHXPersistentComponent = (HXPersistentComponent*)pPersistentComponent;
  679. pHXPersistentParentComponent = pHXPersistentComponent->m_pPersistentParent;
  681. if (pHXPersistentParentComponent)
  682. {
  683.     pHXPersistentComponent->Remove();
  685.     HX_ASSERT(pHXPersistentParentComponent->m_pPersistentChildList &&
  686.       pHXPersistentParentComponent->m_pPersistentChildList->GetCount());
  688.     lPosition = pHXPersistentParentComponent->m_pPersistentChildList->Find(pHXPersistentComponent);
  689.     HX_ASSERT(lPosition);
  691.     pHXPersistentParentComponent->m_pPersistentChildList->RemoveAt(lPosition);
  692.     HX_RELEASE(pHXPersistentComponent);
  693. }
  694.     }
  695.     HX_RELEASE(pPersistentComponent);
  697.     if (m_pRootPersistentComponent  &&
  698. m_pRootPersistentComponent->m_ulComponentID == ulPersistentComponentID)
  699.     {
  700. HX_RELEASE(m_pRootPersistentComponent);
  701.     }
  703.     return rc;
  704. }
  706. /************************************************************************
  707.  * Method:
  708.  *     IHXPersistentComponentManager::GetPersistentComponent
  709.  * Purpose:
  710.  *     get persistent component information
  711.  */
  712. STDMETHODIMP
  713. HXPersistentComponentManager::GetPersistentComponent(UINT32     ulPersistentComponentID,
  714.       REF(IHXPersistentComponent*) pPersistentComponent)
  715. {
  716.     HX_RESULT rc = HXR_FAILED;
  718.     pPersistentComponent = NULL;
  720.     if (m_pRootPersistentComponent)
  721.     {
  722. rc = m_pRootPersistentComponent->GetPersistentComponent(ulPersistentComponentID, pPersistentComponent);
  723.     }
  725.     return rc;
  726. }
  728. /************************************************************************
  729.  * Method:
  730.  *     IHXPersistentComponentManager::AttachPersistentComponentLayout
  731.  * Purpose:
  732.  *     get persistent component information
  733.  */
  734. STDMETHODIMP
  735. HXPersistentComponentManager::AttachPersistentComponentLayout(IUnknown*    pLSG,
  736.        IHXValues*  pProps)
  737. {
  738.     HX_RESULT     rc = HXR_OK;
  739.     IHXSiteUser*   pSiteUser = NULL;
  741.     if (m_pPlayer)
  742.     {
  743. #if defined(HELIX_FEATURE_VIDEO)
  744.         if (HXR_OK == pLSG->QueryInterface(IID_IHXSiteUser, (void**)&pSiteUser))
  745. {
  746.     rc = m_pPlayer->m_pSiteManager->HookupSingleSiteByPlayToFrom(pSiteUser, pProps, FALSE);
  747. }
  748. HX_RELEASE(pSiteUser);
  749. #endif //HELIX_FEATURE_VIDEO
  750.     }
  752.     return rc;
  753. }
  755. /************************************************************************
  756. *  Method:
  757. *      IHXGroupSink::GroupAdded
  758. *  Purpose:
  759. * Notification of a new group being added to the presentation.
  760. */
  761. STDMETHODIMP
  762. HXPersistentComponentManager::GroupAdded(UINT16 /*IN*/ uGroupIndex,
  763.   IHXGroup* /*IN*/ pGroup)
  764. {
  765.     HX_RESULT rc = HXR_OK;
  766.     UINT32 ulPersistentComponentID = 0;
  767.     IHXValues* pProperties = NULL;
  768.     IHXGroupSink* pGroupSink = NULL;
  769.     IHXPersistentComponent* pPersistentComponent = NULL;
  771.     pProperties = pGroup->GetGroupProperties();
  772.     if (pProperties)
  773.     {
  774. if (HXR_OK == pProperties->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
  775. {
  776.     if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  777.     {
  778. pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
  779. if (pGroupSink)
  780. {
  781.     pGroupSink->GroupAdded(uGroupIndex, pGroup);
  782. }
  783.     }
  784.     HX_RELEASE(pPersistentComponent);
  785. }
  786.     }
  787.     HX_RELEASE(pProperties);
  789.     return rc;
  790. }
  792. /************************************************************************
  793. *  Method:
  794. *      IHXGroupSink::GroupRemoved
  795. *  Purpose:
  796. * Notification of a group being removed from the presentation.
  797. */
  798. STDMETHODIMP
  799. HXPersistentComponentManager::GroupRemoved(UINT16 /*IN*/ uGroupIndex,
  800.     IHXGroup*  /*IN*/ pGroup)
  801. {
  802.     HX_RESULT rc = HXR_OK;
  803.     UINT32 ulPersistentComponentID = 0;
  804.     IHXValues* pProperties = NULL;
  805.     IHXGroupSink* pGroupSink = NULL;
  806.     IHXPersistentComponent* pPersistentComponent = NULL;
  808.     pProperties = pGroup->GetGroupProperties();
  809.     if (pProperties)
  810.     {
  811. if (HXR_OK == pProperties->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
  812. {
  813.     if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  814.     {
  815. pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
  816. if (pGroupSink)
  817. {
  818.     pGroupSink->GroupRemoved(uGroupIndex, pGroup);
  819. }
  820.     }
  821.     HX_RELEASE(pPersistentComponent);
  822. }
  823.     }
  824.     HX_RELEASE(pProperties);
  826.     return rc;
  827. }
  829. /************************************************************************
  830. *  Method:
  831. *      IHXGroupSink::AllGroupsRemoved
  832. *  Purpose:
  833. * Notification that all groups have been removed from the 
  834. * current presentation.
  835. */
  836. STDMETHODIMP
  837. HXPersistentComponentManager::AllGroupsRemoved(void)
  838. {
  839.     return HXR_OK;
  840. }
  842. /************************************************************************
  843. *  Method:
  844. *      IHXGroupSink::TrackAdded
  845. *  Purpose:
  846. * Notification of a new track being added to a group.
  847. */
  848. STDMETHODIMP
  849. HXPersistentComponentManager::TrackAdded(UINT16      /*IN*/ uGroupIndex,
  850.   UINT16      /*IN*/ uTrackIndex,
  851.   IHXValues*     /*IN*/ pTrack)
  852. {
  853.     HX_RESULT rc = HXR_OK;
  854.     UINT32 ulPersistentComponentID = 0;
  855.     IHXGroupSink* pGroupSink = NULL;
  856.     IHXPersistentComponent* pPersistentComponent = NULL;
  857.     UINT32                   bNotUsed = 0;
  859.     if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
  860.     {
  861. if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  862. {
  863.     pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
  864.     if (pGroupSink)
  865.     {
  866.             //If the persistant renderer isn't using groups don't call track added.
  867.             if (HXR_OK != pTrack->GetPropertyULONG32("NoGroupsPresent", bNotUsed))
  868.             {
  869.                 pGroupSink->TrackAdded(uGroupIndex, uTrackIndex, pTrack);
  870.             }
  871.             
  872.     }
  873. }
  874. HX_RELEASE(pPersistentComponent);
  875.     }
  877.     return rc;
  878. }
  880. /************************************************************************
  881. *  Method:
  882. *      IHXGroupSink::TrackRemoved
  883. *  Purpose:
  884. * Notification of a track being removed from a group.
  885. */
  886. STDMETHODIMP
  887. HXPersistentComponentManager::TrackRemoved(UINT16     /*IN*/ uGroupIndex,
  888.     UINT16      /*IN*/ uTrackIndex,
  889.     IHXValues*     /*IN*/ pTrack)
  890. {
  891.     HX_RESULT rc = HXR_OK;
  892.     UINT32 ulPersistentComponentID = 0;
  893.     IHXGroupSink* pGroupSink = NULL;
  894.     IHXPersistentComponent* pPersistentComponent = NULL;
  896.     if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
  897.     {
  898. if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  899. {
  900.     pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
  901.     if (pGroupSink)
  902.     {
  903. pGroupSink->TrackRemoved(uGroupIndex, uTrackIndex, pTrack);
  904.     }
  905. }
  906. HX_RELEASE(pPersistentComponent);
  907.     }
  909.     return rc;
  910. }
  912. /************************************************************************
  913. *  Method:
  914. *      IHXGroupSink::TrackStarted
  915. *  Purpose:
  916. * Notification of a track being started (to get duration, for
  917. * instance...)
  918. */
  919. STDMETHODIMP
  920. HXPersistentComponentManager::TrackStarted(UINT16     /*IN*/ uGroupIndex,
  921.     UINT16     /*IN*/ uTrackIndex,
  922.     IHXValues*     /*IN*/ pTrack)
  923. {
  924.     HX_RESULT rc = HXR_OK;
  925.     UINT32 ulPersistentComponentID = 0;
  926.     IHXGroupSink* pGroupSink = NULL;
  927.     IHXPersistentComponent* pPersistentComponent = NULL;
  929.     if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
  930.     {
  931. if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  932. {
  933.     pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
  934.     if (pGroupSink)
  935.     {
  936. pGroupSink->TrackStarted(uGroupIndex, uTrackIndex, pTrack);
  937.     }
  938. }
  939. HX_RELEASE(pPersistentComponent);
  940.     }
  942.     return rc;
  943. }
  945. /************************************************************************
  946. *  Method:
  947. *      IHXGroupSink::TrackStopped
  948. *  Purpose:
  949. * Notification of a track being stopped
  950. *
  951. */
  952. STDMETHODIMP
  953. HXPersistentComponentManager::TrackStopped(UINT16     /*IN*/ uGroupIndex,
  954.     UINT16     /*IN*/ uTrackIndex,
  955.     IHXValues*     /*IN*/ pTrack)
  956. {
  957.     HX_RESULT rc = HXR_OK;
  958.     UINT32 ulPersistentComponentID = 0;
  959.     IHXGroupSink* pGroupSink = NULL;
  960.     IHXPersistentComponent* pPersistentComponent = NULL;
  962.     if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
  963.     {
  964. if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
  965. {
  966.     pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
  967.     if (pGroupSink)
  968.     {
  969. pGroupSink->TrackStopped(uGroupIndex, uTrackIndex, pTrack);
  970.     }
  971. }
  972. HX_RELEASE(pPersistentComponent);
  973.     }
  975.     return rc;
  976. }
  978. /************************************************************************
  979. *  Method:
  980. *      IHXGroupSink::CurrentGroupSet
  981. *  Purpose:
  982. * This group is being currently played in the presentation.
  983. */
  984. STDMETHODIMP
  985. HXPersistentComponentManager::CurrentGroupSet(UINT16     /*IN*/ uGroupIndex,
  986.        IHXGroup*   /*IN*/ pGroup)
  987. {
  988.     HX_RESULT rc = HXR_OK;
  990.     m_nCurrentGroup = uGroupIndex;
  992.     if (m_pRootPersistentComponent)
  993.     {
  994. rc = m_pRootPersistentComponent->CurrentGroupSet(uGroupIndex, pGroup);
  995.     }
  997.     return rc;
  998. }
  1000. HX_RESULT
  1001. HXPersistentComponentManager::OnTimeSync(ULONG32 ulCurrentTime)
  1002. {
  1003.     HX_RESULT rc = HXR_OK;
  1005.     if (m_pRootPersistentComponent)
  1006.     {
  1007. rc = m_pRootPersistentComponent->OnTimeSync(ulCurrentTime);
  1008.     }
  1010.     return rc;
  1011. }
  1013. BOOL
  1014. HXPersistentComponentManager::IsCleanupLayoutNeeded(INT32 nCurrentGroup, INT32 nGroupSwitchTo)
  1015. {
  1016.     BOOL bResult = FALSE;
  1017.     UINT32 ulPersistentComponentIDSwitchTo = 0;
  1018.     IHXValues* pGroupProperties = NULL;
  1019.     IHXValues* pGroupSwitchToProperties = NULL;
  1020.     IHXGroup* pGroup = NULL;
  1021.     IHXGroup* pGroupSwitchTo = NULL;
  1022.     IHXGroup2* pGroup2 = NULL;
  1023.     IHXGroupManager* pGroupManager = NULL;
  1024.     IHXPersistentComponent* pPersistentComponent = NULL;
  1026.     // we will cleanup the layout if the from_group and to_group:
  1027.     // * associated with different persistent component OR
  1028.     // * associated with the same RAM
  1029.     if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pGroupManager))
  1030.     {
  1031. if (HXR_OK == pGroupManager->GetGroup(nGroupSwitchTo, pGroupSwitchTo))
  1032. {
  1033.     pGroupSwitchToProperties = pGroupSwitchTo->GetGroupProperties();
  1034.     if (pGroupSwitchToProperties)
  1035.     {
  1036. if (HXR_OK == pGroupSwitchToProperties->GetPropertyULONG32("PersistentComponentID", 
  1037.    ulPersistentComponentIDSwitchTo))
  1038. {
  1039.     if (HXR_OK == pGroupManager->GetGroup(nCurrentGroup, pGroup) &&
  1040. HXR_OK == pGroup->QueryInterface(IID_IHXGroup2, (void**)&pGroup2))
  1041.     {
  1042. if (HXR_OK == pGroup2->GetPersistentComponentProperties(ulPersistentComponentIDSwitchTo,
  1043. pGroupProperties))
  1044. {
  1045.     if (HXR_OK == GetPersistentComponent(ulPersistentComponentIDSwitchTo, pPersistentComponent))
  1046.     {
  1047. // switch group within RAM
  1048. if (((HXPersistentComponent*)pPersistentComponent)->m_ulPersistentType == PersistentRAM)
  1049. {
  1050.     bResult = TRUE;
  1051. }
  1052. // switch group within SMIL without root layout
  1053. // m_pPlayer->m_bAddLayoutSiteGroupCalled = TRUE when there is root layout
  1054. // specified in SMIL
  1055. // this needs to be revisited when fixing the nested meta layout
  1056. else if (!m_pPlayer->m_bAddLayoutSiteGroupCalled)
  1057. {
  1058.     bResult = TRUE;
  1059. }
  1060.     }
  1061.     else
  1062.     {
  1063. HX_ASSERT(FALSE);
  1064.     }
  1065.     HX_RELEASE(pPersistentComponent);
  1066. }
  1067. else
  1068. {
  1069.     bResult = TRUE;
  1070. }
  1071. HX_RELEASE(pGroupProperties);
  1072.     }
  1073.     HX_RELEASE(pGroup2);
  1074.     HX_RELEASE(pGroup);
  1075. }
  1076.     }
  1077.     HX_RELEASE(pGroupSwitchToProperties);
  1078. }
  1079. HX_RELEASE(pGroupSwitchTo);
  1080.     }
  1081.     HX_RELEASE(pGroupManager);
  1083.     return bResult;
  1084. }
  1086. UINT32
  1087. HXPersistentComponentManager::GetPersistentComponentCount(void)
  1088. {
  1089.     if (m_pRootPersistentComponent)
  1090.     {
  1091. return m_pRootPersistentComponent->GetPersistentComponentCount();
  1092.     }
  1094.     return 0;
  1095. }
  1097. void
  1098. HXPersistentComponentManager::TrackUpdated(UINT16 uGroupIndex, 
  1099.     UINT16 uTrackIndex, 
  1100.     IHXValues* pValues)
  1101. {
  1102.     if (m_pRootPersistentComponent)
  1103.     {
  1104. m_pRootPersistentComponent->TrackUpdated(uGroupIndex, 
  1105.              uTrackIndex,
  1106.  pValues);
  1107.     }
  1109.     return;
  1110. }
  1112. void
  1113. HXPersistentComponentManager::CloseAllRenderers(INT32 nGroupSwitchTo)
  1114. {
  1115.     // nested meta support
  1116.     if (m_pRootPersistentComponent)
  1117.     {
  1118. if (m_pRootPersistentComponent->m_bToBeClosed)
  1119. {
  1120.     m_pRootPersistentComponent->Remove();
  1121.     HX_RELEASE(m_pRootPersistentComponent);
  1122.     m_pPlayer->CleanupLayout();
  1123.         }
  1124.      else
  1125. {
  1126.     m_pRootPersistentComponent->AllRenderersClosed();
  1128.     if (IsCleanupLayoutNeeded(m_nCurrentGroup, nGroupSwitchTo))
  1129.     {
  1130. m_pPlayer->CleanupLayout();
  1131.     }
  1132. }
  1133.     }
  1134.     else
  1135.     {
  1136. m_pPlayer->CleanupLayout();
  1137.     }
  1139.     return;
  1140. }
  1142. void
  1143. HXPersistentComponentManager::Reset()
  1144. {
  1145.     if (m_pRootPersistentComponent)
  1146.     {
  1147. m_pRootPersistentComponent->Reset();
  1148.     }
  1149.     m_ulComponentIndex = 0;
  1151.     return;
  1152. }
  1154. void 
  1155. HXPersistentComponentManager::Close()
  1156. {
  1157.     HX_ASSERT(!m_pRootPersistentComponent);
  1159.     return;
  1160. }