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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
perscmgr.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：33k
源码类别：

Symbian

开发平台：

Visual C++

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