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

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

Symbian

开发平台：

Visual C++

smltime.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: smltime.cpp,v 1.2.12.1 2004/07/09 01:57:38 hubbe 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 <stdlib.h>
  51. #include <stdio.h>
  52. #include <ctype.h>
  54. #include "hxtypes.h"
  55. #include "hxresult.h"
  56. #include "hxcom.h"
  57. #include "hxcomm.h"
  58. #include "ihxpckts.h"
  59. #include "hxfiles.h"
  60. #include "hxformt.h"
  61. #include "hxengin.h"
  62. #include "hxplugn.h"
  63. #include "hxpends.h"
  64. #include "hxasm.h"
  65. #include "hxprefs.h"
  66. #include "hxassert.h"
  67. #include "chxpckts.h"
  68. #include "nptime.h"
  69. #include "smpte.h"
  70. #include "debug.h"
  71. #include "hxstrutl.h"
  72. #include "hxstring.h"
  73. #include "cbqueue.h"
  74. #include "hxslist.h"
  75. #include "hxmap.h"
  76. #include "hxstack.h"
  77. #include "hxwintyp.h"
  78. #include "chxxtype.h"
  80. #include "hxxml.h"
  81. #include "hxxmlprs.h"
  82. #include "xmlreslt.h"
  84. #include "looseprs.h"
  86. #include "sm1elem.h"
  87. #include "sm1parse.h"
  88. #include "sm1time.h"
  91. /*
  92.  * CSmil1TimelineElementManager methods
  93.  */
  95. CSmil1TimelineElementManager::CSmil1TimelineElementManager():
  96.     m_pElementMap(NULL),
  97.     m_pNotifierMap(NULL)
  98. {
  99. }
  101. CSmil1TimelineElementManager::~CSmil1TimelineElementManager()
  102. {
  103.     HX_DELETE(m_pElementMap);
  104.     if(m_pNotifierMap)
  105.     {
  106. CHXMapStringToOb::Iterator i = m_pNotifierMap->Begin();
  107. for(; i != m_pNotifierMap->End(); ++i)
  108. {
  109.     CHXSimpleList* pList = (CHXSimpleList*)(*i);
  110.     delete pList;
  111. }
  112. HX_DELETE(m_pNotifierMap);
  113.     }
  114. }
  116. void
  117. CSmil1TimelineElementManager::addTimelineElement(CSmil1TimelineElement* pElement)
  118. {
  119.     if(!m_pElementMap)
  120.     {
  121. m_pElementMap = new CHXMapStringToOb;
  122.     }
  123.     (*m_pElementMap)[pElement->m_pID] = pElement;
  124. }
  126. CSmil1TimelineElement*
  127. CSmil1TimelineElementManager::getTimelineElement(const char* pID)
  128. {
  129.     CSmil1TimelineElement* pElement = NULL;
  130.     if(m_pElementMap)
  131.     {
  132. m_pElementMap->Lookup(pID, (void*&)pElement);
  133.     }
  134.     return pElement;
  135. }
  137. void
  138. CSmil1TimelineElementManager::addNotification(const char* pID,
  139.      CSmil1TimelineElement* pElement)
  140. {
  141.     if(!m_pNotifierMap)
  142.     {
  143. m_pNotifierMap = new CHXMapStringToOb;
  144.     }
  146.     CHXSimpleList* pNotifyList = NULL;
  147.     if(!m_pNotifierMap->Lookup(pID, (void*&)pNotifyList))
  148.     {
  149. pNotifyList = new CHXSimpleList;
  150. (*m_pNotifierMap)[pID] = pNotifyList;
  151.     }
  152.     pNotifyList->AddTail(pElement);
  153. }
  155. void
  156. CSmil1TimelineElementManager::notify(const char* pID)
  157. {
  158.     CHXSimpleList* pNotifyList = NULL;
  159.     if(m_pNotifierMap)
  160.     {
  161. if(m_pNotifierMap->Lookup(pID, (void*&)pNotifyList))
  162. {
  163.     CSmil1TimelineElement* pDependentElement = NULL;
  164.     if(m_pElementMap->Lookup(pID, (void*&)pDependentElement))
  165.     {
  166. CHXSimpleList::Iterator i = pNotifyList->Begin();
  167. for(; i != pNotifyList->End(); ++i)
  168. {
  169.     CSmil1TimelineElement* pElement = 
  170. (CSmil1TimelineElement*)(*i);
  171.     pElement->elementResolved(pDependentElement);
  172. }
  173.     }
  174. }
  175.     }
  176. }
  178. void
  179. CSmil1TimelineElementManager::resetTimeline()
  180. {
  181.     if(m_pElementMap)
  182.     {
  183. CHXMapStringToOb::Iterator i = m_pElementMap->Begin();
  184. for(; i != m_pElementMap->End(); ++i)
  185. {
  186.     CSmil1TimelineElement* pElement = 
  187. (CSmil1TimelineElement*)(*i);
  188.     pElement->reset();
  189. }
  190.     }
  191. }
  192. /*
  193.  * CSmil1TimelineElement methods
  194.  */
  196. CSmil1TimelineElement::CSmil1TimelineElement(CSmil1Element* pSourceElement,
  197.    CSmil1Parser* pParser):
  198.     m_pSourceElement(pSourceElement),
  199.     m_pParser(pParser),
  200.     m_bDurationSet(FALSE),
  201.     m_bMaxDurationSet(FALSE),
  202.     m_bDelaySet(FALSE),
  203.     m_bDontResetDuration(FALSE),
  204.     m_bNonEventDelaySet(FALSE),
  205.     m_bDelayEvent(FALSE),
  206.     m_bDurationEvent(FALSE),
  207.     m_pParent(NULL),
  208.     m_pChildren(NULL),
  209.     m_pDependent(NULL)
  210. {
  211.     m_pID = new char[pSourceElement->m_pNode->m_id.GetLength() + 1];
  212.     strcpy(m_pID, (const char*)m_pSourceElement->m_pNode->m_id); /* Flawfinder: ignore */
  214.     if (m_pParser && m_pParser->m_pTimelineElementManager)
  215.     {
  216.         m_pParser->m_pTimelineElementManager->addTimelineElement(this);
  218.         if(pSourceElement->m_nBeginEventSourceTag == SMILEventSourceBegin ||
  219.     pSourceElement->m_nBeginEventSourceTag == SMILEventSourceEnd ||
  220.     pSourceElement->m_nBeginEventSourceTag == SMILEventSourceClock)
  221.         {
  222.     m_pParser->m_pTimelineElementManager->addNotification(pSourceElement->m_BeginEventSourceID,
  223.         this);
  224.     m_bDelayEvent = TRUE;
  225.         }
  227.         if(pSourceElement->m_nEndEventSourceTag == SMILEventSourceBegin ||
  228.     pSourceElement->m_nEndEventSourceTag == SMILEventSourceEnd ||
  229.     pSourceElement->m_nEndEventSourceTag == SMILEventSourceClock)
  230.         {
  231.     m_pParser->m_pTimelineElementManager->addNotification(pSourceElement->m_EndEventSourceID,
  232.         this);
  233.     m_bDurationEvent = TRUE;
  234.         }
  236.         if(pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceID)
  237.         {
  238.     m_pParser->m_pTimelineElementManager->addNotification(pSourceElement->m_EndsyncEventSourceID,
  239.         this);
  240.     m_bDurationEvent = TRUE;
  241.         }
  242.     }
  244. }
  246. CSmil1TimelineElement::~CSmil1TimelineElement()
  247. {
  248.     delete m_pChildren;
  249.     delete[] m_pID;
  250. }
  252. void
  253. CSmil1TimelineElement::reset()
  254. {
  255.     m_bDelaySet = FALSE;
  256.     m_bNonEventDelaySet = FALSE;
  257.     m_bDurationSet = FALSE;
  258.     m_bMaxDurationSet = FALSE;
  259. }
  261. void 
  262. CSmil1TimelineElement::setDelay(UINT32 ulDelay)
  263. {
  264.     if(!m_bDelaySet)
  265.     {
  266. if(!m_bDelayEvent)
  267. {
  268.     if(m_pSourceElement->m_ulBeginOffset != (UINT32)-1)
  269.     {
  270. m_pSourceElement->m_ulDelay = ulDelay + 
  271.     m_pSourceElement->m_ulBeginOffset;
  272.     }
  273.     else
  274.     {
  275. m_pSourceElement->m_ulDelay = ulDelay;
  276.     }
  277.     m_bDelaySet = TRUE;
  278.     m_pParser->insertTimelineElement(m_pID, 
  279. m_pSourceElement->m_ulDelay);
  280. }
  281.     }
  282.     else
  283.     {
  284. if(m_pSourceElement->m_ulBeginOffset != (UINT32)-1)
  285. {
  286.     m_pSourceElement->m_ulDelay = ulDelay + 
  287. m_pSourceElement->m_ulBeginOffset;
  288. }
  289. else
  290. {
  291.     m_pSourceElement->m_ulDelay = ulDelay;
  292. }
  293.     }
  294. }
  296. void 
  297. CSmil1TimelineElement::setDuration(UINT32 ulDuration, BOOL bSetFromParent)
  298. {
  299.     if(bSetFromParent)
  300.     {
  301. m_pSourceElement->m_ulDuration = ulDuration;
  302. m_bDurationSet = m_bDontResetDuration = TRUE;
  303. m_pParser->resetTimelineElementDuration(m_pID,
  304.     m_pSourceElement->m_ulDuration);
  305.     }
  306.     else
  307.     {
  308. if(!m_bDurationSet)
  309. {
  310.     if(m_pSourceElement->m_ulBeginOffset != (UINT32)-1)
  311.     {
  312. m_pSourceElement->m_ulDuration = ulDuration + 
  313.     m_pSourceElement->m_ulBeginOffset;
  314.     }
  315.     else
  316.     {
  317. m_pSourceElement->m_ulDuration = ulDuration;
  318.     }
  319.     m_bDurationSet = TRUE;
  320.     if(m_pParent)
  321.     {
  322. m_pParent->addDuration(m_pSourceElement->m_ulDuration, 
  323.     m_pSourceElement->m_ulDelay, m_pID);
  324.     }
  325. }
  326. else if(!m_bDontResetDuration)
  327. {
  328.     m_pSourceElement->m_ulDuration = ulDuration;
  329.     m_pParser->resetTimelineElementDuration(m_pID,
  330. m_pSourceElement->m_ulDuration);
  331. }
  332.     }
  333.     if(m_pDependent)
  334.     {
  335. //Removed the addition of m_pSourceElement->m_ulDelay from the
  336. // source's duration because the source's duration already includes
  337. // its delay; we don't want to count the delay twice. Fixes PR 13983:
  338. // /*XXXEH- UNFIXES 13983 by adding back in the ...m_ulDelay addition;
  339. // the full fix for 13983 requires keeping track of begin=... delay
  340. // (as opposed to seq-related delay) and then subtracting that begin
  341. // delay from the m_ulDelay below:
  342. adjustDependentDuration(m_pDependent);
  343. m_pDependent->setDelay(m_pSourceElement->m_ulDelay + m_pSourceElement->m_ulDuration);
  344.     }
  346.     if (m_pParser && m_pParser->m_pTimelineElementManager)
  347.     {
  348.         m_pParser->m_pTimelineElementManager->notify(m_pID);
  349.     }
  350. }
  352. void
  353. CSmil1TimelineElement::setMaxDuration(UINT32 ulMaxDuration)
  354. {
  355.     m_bMaxDurationSet = TRUE;
  356.     m_pSourceElement->m_ulMaxDuration = ulMaxDuration;
  357. }
  359. void 
  360. CSmil1TimelineElement::adjustDependentDuration(CSmil1TimelineElement* pDependent)
  361. {
  362.     if (m_pParent)
  363.     {
  364. m_pParent->adjustDependentDuration(m_pDependent);
  365.     }
  366. }
  368. void
  369. CSmil1TimelineElement::elementResolved(CSmil1TimelineElement* pEventElement)
  370. {
  371.     //First, let's see if we have a begin event to resolve:
  372.     if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceBegin)
  373.     {
  374. if(pEventElement->m_bDelaySet)
  375. {
  376.     m_bDelaySet = TRUE;
  377.     m_pSourceElement->m_ulDelay = 
  378. pEventElement->m_pSourceElement->m_ulDelay;
  379.     m_pParser->insertTimelineElement(m_pID, 
  380. m_pSourceElement->m_ulDelay);
  381. }
  382.     }
  383.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceEnd)
  384.     {
  385. if(pEventElement->m_bDurationSet)
  386. {
  387.     m_bDelaySet = TRUE;
  388.     m_pSourceElement->m_ulDelay = 
  389. pEventElement->m_pSourceElement->m_ulDuration +
  390.     pEventElement->m_pSourceElement->m_ulDelay;
  391.     m_pParser->insertTimelineElement(m_pID, 
  392. m_pSourceElement->m_ulDelay);
  393. }
  394.     }
  395.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceClock)
  396.     {
  397. //We want event *BEGIN* plus clock therefor check for m_bDelaySet not
  398. // m_bDurationSet; after all, it's the eventElement's m_ulDelay
  399. // that's used, below:
  400. if(pEventElement->m_bDelaySet)
  401. {
  402.     m_bDelaySet = TRUE;
  403.     m_pSourceElement->m_ulDelay = 
  404.     pEventElement->m_pSourceElement->m_ulDelay;
  405.     //[SMIL 1.0 compliance] helps fix 23025:
  406.     // Rather than putting all the offset into m_ulDelay,
  407.     // we want to put the event element's delay into our
  408.     // delay and then put the event clock value into our
  409.     // m_ulBeginOffset so that we can properly adjust
  410.     // for any timing imposed on us later by our container
  411.     // (parent):
  412.     HX_ASSERT(m_pSourceElement->m_ulBeginOffset == UINT32(-1));
  413.     m_pSourceElement->m_ulBeginOffset =
  414.     m_pSourceElement->m_ulBeginEventClockValue;
  415.             m_pParser->insertTimelineElement(m_pID, 
  416. m_pSourceElement->m_ulDelay +
  417. //Allows SYMM 3/13/2000 test case 1.13 to work again
  418. // while allowing 23025 to keep working:
  419. m_pSourceElement->m_ulBeginOffset);
  420. }
  421.     }
  423.     //[SMIL 1.0 compliance] Fixes PR 16629:
  424.     //Next, let's see if we have an end event to resolve:
  425.     if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceBegin)
  426.     {
  427. if(pEventElement->m_bDelaySet)
  428. {
  429.     m_bDurationSet = TRUE;
  430.     m_pSourceElement->m_ulDuration = 
  431. pEventElement->m_pSourceElement->m_ulDelay;
  432.     m_pParser->insertTimelineElement(m_pID, 
  433. m_pSourceElement->m_ulDelay);
  434. }
  435.     }
  436.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceEnd)
  437.     {
  438. if(pEventElement->m_bDurationSet)
  439. {
  440.     m_bDurationSet = TRUE;
  441.     m_pSourceElement->m_ulDuration = 
  442. pEventElement->m_pSourceElement->m_ulDuration +
  443.     pEventElement->m_pSourceElement->m_ulDelay;
  444.     m_pParser->insertTimelineElement(m_pID, 
  445. m_pSourceElement->m_ulDelay);
  446. }
  447.     }
  448.     //[SMIL 1.0 compliance] Fixes PR 16629; we need to set our duration
  449.     // to the event element's end time plus the clock offset:
  450.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceClock)
  451.     {
  452. if(pEventElement->m_bDelaySet)
  453. {
  454.     m_bDurationSet = TRUE;
  455.     m_pSourceElement->m_ulDuration = 
  456.     pEventElement->m_pSourceElement->m_ulDelay +
  457.     m_pSourceElement->m_ulEndEventClockValue;
  458.     m_pParser->insertTimelineElement(m_pID, 
  459. m_pSourceElement->m_ulDelay);
  460. }
  461.     }
  462. }
  464. #if 0
  465. void
  466. CSmil1TimelineElement::setEvent(SMILEventSourceTag eTag,
  467. SMILSyncAttributeTag aTag,
  468. const char* pEventSourceID,
  469. UINT32 ulEventClockValue)
  470. {
  471.     m_eEventSourceTag = eTag;
  472.     m_eSyncAttributeTag = aTag;
  473.     if(pEventSourceID)
  474.     {
  475. m_pEventSourceID = new char[strlen(pEventSourceID)+1];
  476. strcpy(m_pEventSourceID, pEventSourceID); /* Flawfinder: ignore */
  477.         if (m_pParser && m_pParser->m_pTimelineElementManager)
  478.         {
  479.             m_pParser->m_pTimelineElementManager->addNotification(pEventSourceID, this);
  480.         }
  481.     }
  482.     m_ulEventClockValue = ulEventClockValue;
  483. }
  484. #endif
  487. void 
  488. CSmil1TimelineElement::addChild(CSmil1TimelineElement* pChild)
  489. {
  490.     if(!m_pChildren)
  491.     {
  492. m_pChildren = new CHXSimpleList;
  493.     }
  494.     m_pChildren->AddTail(pChild);
  495.     pChild->setParent(this);
  496. }
  498. UINT32
  499. CSmil1TimelineElement::getDuration()
  500. {
  501.     return m_pSourceElement->m_ulDuration;
  502. }
  504. UINT32
  505. CSmil1TimelineElement::getDelay()
  506. {
  507.     return m_pSourceElement->m_ulDelay;
  508. }
  510. void 
  511. CSmil1TimelineElement::dump()
  512. {
  513. }
  516. /*
  517.  * CSmil1TimelinePar methods
  518.  */
  520. CSmil1TimelinePar::CSmil1TimelinePar(CSmil1Element* pSourceElement,
  521.    CSmil1Parser* pParser):
  522.     CSmil1TimelineElement(pSourceElement, pParser),
  523.     m_nDurationAdded(0),
  524.     m_ulFirstDuration(0),
  525.     m_ulLastDuration(0)
  526. {
  527. }
  529. CSmil1TimelinePar::~CSmil1TimelinePar()
  530. {
  531. }
  533. void 
  534. CSmil1TimelinePar::setDelay(UINT32 ulDelay)
  535. {
  536.     if(m_pSourceElement->m_ulBeginOffset != (UINT32)-1)
  537.     {
  538. m_pSourceElement->m_ulDelay = ulDelay + 
  539.     m_pSourceElement->m_ulBeginOffset;
  540.     }
  541.     else
  542.     {
  543. m_pSourceElement->m_ulDelay = ulDelay;
  544.     }
  545.     if (!m_bDelayEvent) //[SMIL 1.0 compliance] helps fix PR 14420.
  546.     {
  547. m_bDelaySet = TRUE;
  548. if(m_pChildren)
  549. {
  550.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  551.     for(; i != m_pChildren->End(); ++i)
  552.     {
  553. CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)(*i);
  554. pElement->setDelay(m_pSourceElement->m_ulDelay);
  555.     }
  556. }
  558. if (m_pSourceElement->m_ulDuration != (UINT32)-1)
  559. {
  560.     setDuration(m_pSourceElement->m_ulDuration);
  561. }
  562.     }
  563.     else //[SMIL 1.0 compliance] for PR 14420:
  564. // let's not claim that the delay is set when we still
  565. // are awaiting a delay (begin) event; we *do* need to
  566. // add the delay of this to the event's begin offset.
  567. // This is done by setting the new "m_bNonEventDelaySet"
  568. // variable to TRUE and leaving m_bDelaySet to FALSE
  569. // until the ElementResolved() call sets it to true:
  570.     {
  571. //Parent calls setDelay before we get to ElementResolved,
  572. // thus m_bDelaySet should never be TRUE if we have a
  573. // delay event:
  574. HX_ASSERT(!m_bDelaySet);
  575. m_bNonEventDelaySet = TRUE; //ElementResolved will look at this.
  576.     }
  577. }
  579. void
  580. CSmil1TimelinePar::setDuration(UINT32 ulDuration, BOOL bSetFromParent)
  581. {
  582.     m_pSourceElement->m_ulDuration = ulDuration;
  583.     m_bDurationSet = TRUE;
  584.     if(m_pChildren)
  585.     {
  586. CHXSimpleList::Iterator i = m_pChildren->Begin();
  587. for(; i != m_pChildren->End(); ++i)
  588. {
  589.     CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)(*i);
  590.     pElement->setDuration(m_pSourceElement->m_ulDuration, TRUE);
  591.         }
  592.     }
  593.     
  594.     if(m_pDependent)
  595.     {
  596. adjustDependentDuration(m_pDependent);
  597. m_pDependent->setDelay(m_pSourceElement->m_ulDelay + m_pSourceElement->m_ulDuration);
  598.     }
  600.     //[SMIL 1.0 comliance] Helps fix PR 14420 and 23025:
  601.     if (m_pParser && m_pParser->m_pTimelineElementManager)
  602.     {
  603.         m_pParser->m_pTimelineElementManager->notify(m_pID);
  604.     }
  605. }
  607. void
  608. CSmil1TimelinePar::setMaxDuration(UINT32 ulMaxDuration)
  609. {
  610.     HX_ASSERT(m_pChildren);
  611.     m_bMaxDurationSet = TRUE;
  612.     m_pSourceElement->m_ulMaxDuration = ulMaxDuration;
  614.     if (m_pChildren)
  615.     {
  616. CHXSimpleList::Iterator i = m_pChildren->Begin();
  617. for(; i != m_pChildren->End(); ++i)
  618. {
  619.     CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)(*i);
  620.     pElement->setMaxDuration(ulMaxDuration);
  621. }
  622.     }
  623. }
  625. void 
  626. CSmil1TimelinePar::adjustDependentDuration(CSmil1TimelineElement* pDependent)
  627. {
  628.     if (m_pParent)
  629.     {
  630. m_pParent->adjustDependentDuration(pDependent);
  631.     }
  633.     return;
  634. }
  636. void 
  637. CSmil1TimelinePar::addDuration(UINT32 ulDuration,
  638.       UINT32 ulDelay,
  639.       const char* pElementID)
  640. {
  641.     if(m_pSourceElement->m_ulDuration == (UINT32)-1)
  642.     {
  643. m_pSourceElement->m_ulDuration = ulDuration;
  644. m_ulFirstDuration = ulDuration;
  645. m_ulLastDuration = ulDuration;
  646.     }
  647.     else
  648.     {
  649. m_pSourceElement->m_ulDuration = 
  650.     (ulDuration > m_pSourceElement->m_ulDuration) ?
  651.     ulDuration : m_pSourceElement->m_ulDuration;
  652. if(ulDuration < m_ulFirstDuration)
  653. {
  654.     m_ulFirstDuration = ulDuration;
  655. }
  656. if(ulDuration > m_ulLastDuration)
  657. {
  658.     m_ulLastDuration = ulDuration;
  659. }
  660.     }
  662.     m_nDurationAdded++;
  663.     if(m_nDurationAdded == m_pChildren->GetCount() &&
  664. !m_bDurationEvent)
  665.     {
  666. if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  667.     SMILEventSourceFirst)
  668. {
  669.     durationResolved(m_ulFirstDuration, TRUE);
  670. }
  671. else if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  672.     SMILEventSourceLast)
  673. {
  674.     durationResolved(m_ulLastDuration, TRUE);
  675. }
  676. else
  677. {
  678.     durationResolved(m_pSourceElement->m_ulDuration, FALSE);
  679. }
  680.     }
  681. }
  683. void
  684. CSmil1TimelinePar::elementResolved(CSmil1TimelineElement* pEventElement)
  685. {
  686. //XXXEH: do we really want to check m_bDurationSet and m_bDelaySet...etc.
  687. // first???? (as in old version)
  689. //XXXEH: also, shouldn't we be making sure the pEventElement's id
  690. // matches the m_[XXX]EventSourceID?  Otherwise, a begin event on one id
  691. // and an end event on another may cause problems...
  693.     //First, let's see if we have a begin event to resolve:
  694.     if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceBegin)
  695.     {
  696. if(pEventElement->m_bDelaySet)
  697. {
  698.     //[SMIL 1.0 Compliance] Helps fix 14420:
  699.     if (m_bNonEventDelaySet)
  700.     {
  701. //Add non-event delay to begin event delay:
  702. m_pSourceElement->m_ulDelay += 
  703.     pEventElement->m_pSourceElement->m_ulDelay;
  704.     }
  705.     else
  706.     {
  707. //Just set delay to event delay:
  708. m_pSourceElement->m_ulDelay = 
  709.     pEventElement->m_pSourceElement->m_ulDelay;
  711.     }
  712.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  713.     if(m_pChildren)
  714.     {
  715. CHXSimpleList::Iterator i = m_pChildren->Begin();
  716. for(; i != m_pChildren->End(); ++i)
  717. {
  718.     CSmil1TimelineElement* pElement =
  719.     (CSmil1TimelineElement*)(*i);
  720.     pElement->setDelay(m_pSourceElement->m_ulDelay);
  721. }
  722.     }
  723. }
  724.     }
  725.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceEnd)
  726.     {
  727. if(pEventElement->m_bDurationSet)
  728. {
  729.     //[SMIL 1.0 Compliance] Helps fix 14420:
  730.     if (m_bNonEventDelaySet)
  731.     {
  732. //Add non-event delay to begin event delay:
  733. m_pSourceElement->m_ulDelay += 
  734.     pEventElement->m_pSourceElement->m_ulDuration +
  735.     pEventElement->m_pSourceElement->m_ulDelay;
  736.     }
  737.     else
  738.     {
  739. //Just set delay to event delay:
  740. m_pSourceElement->m_ulDelay = 
  741.     pEventElement->m_pSourceElement->m_ulDuration +
  742.     pEventElement->m_pSourceElement->m_ulDelay;
  744.     }
  745.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  746.     if(m_pChildren)
  747.     {
  748. CHXSimpleList::Iterator i = m_pChildren->Begin();
  749. for(; i != m_pChildren->End(); ++i)
  750. {
  751.     CSmil1TimelineElement* pElement =
  752.     (CSmil1TimelineElement*)(*i);
  753.     pElement->setDelay(m_pSourceElement->m_ulDelay);
  754. }
  755.     }
  756. }
  757.     }
  758.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceClock)
  759.     {
  760. //We want event *BEGIN* plus clock therefor check for m_bDelaySet not
  761. // m_bDurationSet; after all, it's the eventElement's m_ulDelay
  762. // that's used, below:
  763. if(pEventElement->m_bDelaySet)
  764. {
  765.     if (m_bNonEventDelaySet)
  766.     {
  767. //Add non-event delay to begin event delay + clock val:
  768. m_pSourceElement->m_ulDelay += 
  769.     pEventElement->m_pSourceElement->m_ulDelay +
  770.     m_pSourceElement->m_ulBeginEventClockValue;
  771.     }
  772.     else
  773.     {
  774. //Just set delay to event delay:
  775. m_pSourceElement->m_ulDelay = 
  776.     pEventElement->m_pSourceElement->m_ulDelay +
  777.     m_pSourceElement->m_ulBeginEventClockValue;
  779.     }
  780.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  781.     if(m_pChildren)
  782.     {
  783. CHXSimpleList::Iterator i = m_pChildren->Begin();
  784. for(; i != m_pChildren->End(); ++i)
  785. {
  786.     CSmil1TimelineElement* pElement =
  787.     (CSmil1TimelineElement*)(*i);
  788.     pElement->setDelay(m_pSourceElement->m_ulDelay);
  789. }
  790.     }
  791. }
  792.     }
  794.     
  795. //XXXEH: shouldn't we be making sure the pEventElement's id
  796. // matches the m_[XXX]EventSourceID, otherwise a begin event on one id
  797. // and an end event on another will cause problems.
  798. #if defined(XXXEH_UNTESTED_AND_NOT_EXAMINED_WELL)
  799.     if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceBegin)
  800.     {
  801. if(pEventElement->m_bDelaySet)
  802. {
  803.     durationResolved(pEventElement->m_pSourceElement->m_ulDelay,
  804.     TRUE);
  805. }
  806.     }
  807.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceEnd)
  808.     {
  809. if(pEventElement->m_bDurationSet)
  810. {
  811.     durationResolved(pEventElement->getDuration(), TRUE);
  812. }
  813.     }
  814.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceClock)
  815.     {
  816. if(pEventElement->m_bDelaySet)
  817. {
  818.     durationResolved(pEventElement->m_pSourceElement->m_ulDelay +
  819.     m_pSourceElement->m_ulEndEventClockValue, TRUE);
  820. }
  821.     }
  822. #endif // defined(XXXEH_UNTESTED_AND_NOT_EXAMINED_WELL).
  823.     //[SMIL 1.0 compliance] Helps fix PR 32578:
  824.     if (m_pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceID)
  825.     {
  826. if(pEventElement->m_bDurationSet)
  827. {
  828.     durationResolved(pEventElement->getDuration(), TRUE);
  829. }
  830.     }
  831. }
  833. void
  834. CSmil1TimelinePar::durationResolved(UINT32 ulDuration, BOOL bUpdateChildren)
  835. {
  836.     if(!m_bDurationSet)
  837.     {
  838. m_bDurationSet = TRUE;
  839. m_pSourceElement->m_ulDuration = ulDuration;
  840. if(m_pParent)
  841. {
  842.     m_pParent->addDuration(ulDuration, 
  843. m_pSourceElement->m_ulDelay, m_pID);
  844. }
  845. if(m_pDependent)
  846. {
  847.     //XXXEH- should "m_pSourceElement->m_ulDelay +" be removed, too?
  848.     // I can't get any content to hit this line so I'm not going to
  849.     // change it.  See fix for PR SMIL/13983:
  850.     adjustDependentDuration(m_pDependent);
  851.     m_pDependent->setDelay(m_pSourceElement->m_ulDelay +
  852. m_pSourceElement->m_ulDuration);     
  853. }
  854. if(bUpdateChildren)
  855. {
  856.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  857.     for(; i != m_pChildren->End(); ++i)
  858.     {
  859. CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)(*i);
  860. pElement->setDuration(m_pSourceElement->m_ulDuration, TRUE);
  861.     }
  862. }
  863.     }
  864. }
  866. #if 0
  867. void 
  868. CSmil1TimelinePar::setEndsync(EndsyncType eType, 
  869.      const char* pEndsyncID,
  870.      UINT32 ulEndsyncClockValue)
  871. {
  872.     m_eEndsyncType = eType;
  873.     m_ulEndsyncClockValue = ulEndsyncClockValue;
  874.     if(pEndsyncID)
  875.     {
  876. m_pEndsyncID = new char[strlen(pEndsyncID)+1];
  877. strcpy(m_pEndsyncID, pEndsyncID); /* Flawfinder: ignore */
  878.     }
  879. }
  880. #endif
  882. /*
  883.  * CSmil1TimelineSeq methods
  884.  */
  885. CSmil1TimelineSeq::CSmil1TimelineSeq(CSmil1Element* pSourceElement,
  886.    CSmil1Parser* pParser):
  887.     CSmil1TimelineElement(pSourceElement, pParser),
  888.     m_nDurationAdded(0)
  889. {
  890. }
  892. void 
  893. CSmil1TimelineSeq::addDuration(UINT32 ulDuration, 
  894.       UINT32 ulDelay,
  895.       const char* pID)
  896. {
  897.     ASSERT(m_pChildren);
  899.     if(!m_bDurationSet)
  900.     {
  901. if(m_pSourceElement->m_ulDuration == (UINT32)-1)
  902. {
  903.     m_pSourceElement->m_ulDuration = ulDuration;
  904. }
  905. else
  906. {
  907.     m_pSourceElement->m_ulDuration += ulDuration;
  908. }
  909.     }
  911.     m_nDurationAdded++;
  912.     if(m_nDurationAdded == m_pChildren->GetCount())
  913.     {
  914. m_bDurationSet = TRUE;
  915. if(m_pParent)
  916. {
  917.     m_pParent->addDuration(
  918. m_pSourceElement->m_ulDuration, 
  919. m_pSourceElement->m_ulDelay, m_pID);
  920. }
  921. if(m_pDependent)
  922. {
  923.     //XXXEH- should "m_pSourceElement->m_ulDelay +" be removed, too?
  924.     // I can't get any content to hit this line so I'm not going to
  925.     // change it.  See fix for PR SMIL/13983:
  926.     adjustDependentDuration(m_pDependent);
  927.     m_pDependent->setDelay(m_pSourceElement->m_ulDelay +
  928. m_pSourceElement->m_ulDuration);     
  929. }
  930. // /[SMIL 1.0 Compliance] Fixes PR 23779:
  931. // if a source has event-based timing based on this seq's
  932. // duration, then we need to notify that source that we've
  933. // resolved this value:
  934.         if (m_pParser && m_pParser->m_pTimelineElementManager)
  935.         {
  936.             m_pParser->m_pTimelineElementManager->notify(m_pID);
  937.         }
  938.     }
  939. }
  941. void 
  942. CSmil1TimelineSeq::setDelay(UINT32 ulDelay)
  943. {
  944.     if(m_pSourceElement->m_ulBeginOffset != (UINT32)-1)
  945.     {
  946. m_pSourceElement->m_ulDelay = ulDelay + 
  947.     m_pSourceElement->m_ulBeginOffset;
  948.     }
  949.     else
  950.     {
  951. m_pSourceElement->m_ulDelay = ulDelay;
  952.     }
  953.     //XXXJHUG - we need to prevent overwriting the delay when
  954.     // setInitalDelay is called on THIS element, changing this
  955.     // bool causes initialDelaySet to return TRUE.
  956.     m_bDelaySet = TRUE;
  957.     if(m_pChildren && m_pChildren->GetCount() > 0)
  958.     {
  959. // set delay on first child of seq
  960. CSmil1TimelineElement* pElement = 
  961.     (CSmil1TimelineElement*)m_pChildren->GetHead();
  962. pElement->setDelay(m_pSourceElement->m_ulDelay);
  963.     }
  965.     if (m_pSourceElement->m_ulDuration != (UINT32)-1)
  966.     {
  967. setDuration(m_pSourceElement->m_ulDuration);
  968.     }
  970.     //[SMIL 1.0 Compliance] Helps fix PR 14420 and 23025:
  971.     // if a source has event-based timing based on this seq's
  972.     // begin time (delay) then we need to notify that source
  973.     // that we've resolved this value:
  974.     if (m_pParser && m_pParser->m_pTimelineElementManager)
  975.     {
  976.         m_pParser->m_pTimelineElementManager->notify(m_pID);
  977.     }
  978. }
  980. void
  981. CSmil1TimelineSeq::setDuration(UINT32 ulDuration, BOOL bSetFromParent)
  982. {
  983.     ASSERT(m_pChildren);
  985.     if(!m_bDurationSet)
  986.     {
  987. m_pSourceElement->m_ulDuration = ulDuration;
  988. m_bDurationSet = TRUE;
  989.     }
  991.     UINT32 ulDurationLeft = m_pSourceElement->m_ulDuration;
  992.     RepeatTag repeatTag = RepeatUnknown;
  994.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  995.     for(; i != m_pChildren->End(); ++i)
  996.     {
  997. CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)(*i);
  999. if (!setElementDuration(ulDurationLeft, pElement))
  1000. {
  1001.     break;
  1002. }
  1003.     }
  1005.     if(m_pDependent)
  1006.     {
  1007. adjustDependentDuration(m_pDependent);
  1008. m_pDependent->setDelay(m_pSourceElement->m_ulDelay + m_pSourceElement->m_ulDuration);
  1009.     }
  1011.     //[SMIL 1.0 comliance] Helps fix PR 14420 and 23025:
  1012.     if (m_pParser && m_pParser->m_pTimelineElementManager)
  1013.     {
  1014.         m_pParser->m_pTimelineElementManager->notify(m_pID);
  1015.     }
  1016. }
  1018. void
  1019. CSmil1TimelineSeq::setMaxDuration(UINT32 ulMaxDuration)
  1020. {
  1021.     HX_ASSERT(m_pChildren);
  1022.     m_bMaxDurationSet = TRUE;
  1023.     m_pSourceElement->m_ulMaxDuration = ulMaxDuration;
  1025.     if (m_pChildren)
  1026.     {
  1027. CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)m_pChildren->GetHead();
  1028. pElement->setMaxDuration(ulMaxDuration);
  1029.     }
  1030. }
  1032. void 
  1033. CSmil1TimelineSeq::adjustDependentDuration(CSmil1TimelineElement* pDependent)
  1034. {
  1035.     if(m_bDurationSet || m_bMaxDurationSet)
  1036.     {
  1037. UINT32     ulDurationLeft = m_bDurationSet?m_pSourceElement->m_ulDuration:
  1038.     m_pSourceElement->m_ulMaxDuration;
  1039. BOOL     bAdjusted = FALSE;
  1040. RepeatTag   repeatTag = RepeatUnknown;
  1042. CHXSimpleList::Iterator i = m_pChildren->Begin();
  1043. for(; i != m_pChildren->End(); ++i)
  1044. {
  1045.     CSmil1TimelineElement* pElement = (CSmil1TimelineElement*)(*i);
  1046.     UINT32 ulChildDuration = pElement->getDuration();
  1048.     if (pElement == pDependent)
  1049.     {
  1050. bAdjusted = TRUE;
  1051.     }
  1053.     if (bAdjusted)
  1054.     {
  1055. if (!setElementDuration(ulDurationLeft, pElement))
  1056. {
  1057.     break;
  1058. }
  1059.     }
  1060.     else
  1061.     {
  1062. if(ulDurationLeft >= ulChildDuration)
  1063. {
  1064.     ulDurationLeft -= ulChildDuration;
  1065. }
  1066. else
  1067. {
  1068.     ulDurationLeft = 0;
  1069. }     
  1070.     }
  1071. }
  1073. if (!bAdjusted && m_pParent)
  1074. {
  1075.     m_pParent->adjustDependentDuration(pDependent);
  1076. }
  1077.     }
  1078. }
  1080. BOOL
  1081. CSmil1TimelineSeq::setElementDuration(UINT32& ulDurationLeft, CSmil1TimelineElement* pElement)
  1082. {
  1083.     BOOL bContinue = TRUE;
  1084.     UINT32 ulChildDuration = pElement->getDuration();
  1085.     RepeatTag   repeatTag = pElement->m_pSourceElement->m_pNode->m_repeatTag;
  1087.     if (repeatTag == RepeatIndefiniteOnMe)
  1088.     {
  1089. pElement->setMaxDuration(ulDurationLeft);
  1090. ulDurationLeft = 0;
  1091. goto cleanup;
  1092.     }
  1093.     else if (repeatTag == RepeatIndefiniteOnGroup)
  1094.     {
  1095. pElement->setMaxDuration(ulDurationLeft);
  1096. bContinue = FALSE;
  1097. goto cleanup;
  1098.     }
  1100.     // no more duration left, take care of the duration of the rest of 
  1101.     // the elements
  1102.     if (0 == ulDurationLeft)
  1103.     {
  1104. pElement->setDuration(ulDurationLeft, TRUE);
  1105.     }
  1106.     // if this is the last child, then enforce the duration whatever
  1107.     // left
  1108.     else if (pElement == m_pChildren->GetTail())
  1109.     {
  1110. pElement->setDuration(ulDurationLeft, TRUE);
  1111. bContinue = FALSE;
  1112.     }
  1113.     // unknown duration, so we apply max. duration here
  1114.     else if (ulChildDuration == (UINT32)-1)
  1115.     {
  1116. pElement->setMaxDuration(ulDurationLeft);
  1117. bContinue = FALSE;
  1118.     }
  1119.     else
  1120.     {
  1121. if(ulDurationLeft >= ulChildDuration)
  1122. {
  1123.     ulDurationLeft -= ulChildDuration;
  1124. }
  1125. else
  1126. {
  1127.     pElement->setDuration(ulDurationLeft, TRUE);
  1128.     ulDurationLeft = 0;
  1129. }
  1130.     }
  1132. cleanup:
  1134.     return bContinue;
  1135. }
  1137. /*
  1138.  * CSmil1TimelineAnchor methods
  1139.  */
  1141. CSmil1TimelineAnchor::CSmil1TimelineAnchor(CSmil1Element* pSourceElement,
  1142.    CSmil1Parser* pParser):
  1143.     CSmil1TimelineElement(pSourceElement, pParser)
  1144.     , m_nDurationAdded(0)
  1145. {
  1146. }
  1148. CSmil1TimelineAnchor::~CSmil1TimelineAnchor()
  1149. {
  1150. }
  1152. void
  1153. CSmil1TimelineAnchor::elementResolved(CSmil1TimelineElement* pEventElement)
  1154. {
  1155. //XXXEH: shouldn't we be making sure the pEventElement's id
  1156. // matches the m_[XXX]EventSourceID?  Otherwise, a begin event on one id
  1157. // and an end event on another may cause problems...
  1159.     //First, let's see if we have a begin event to resolve:
  1160.     if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceBegin)
  1161.     {
  1162. if(pEventElement->m_bDelaySet)
  1163. {
  1164.     //[SMIL 1.0 Compliance] Helps fix 14420:
  1165.     if (m_bNonEventDelaySet)
  1166.     {
  1167. //Add non-event delay to begin event delay:
  1168. m_pSourceElement->m_ulDelay += 
  1169.     pEventElement->m_pSourceElement->m_ulDelay;
  1170.     }
  1171.     else
  1172.     {
  1173. //Just set delay to event delay:
  1174. m_pSourceElement->m_ulDelay = 
  1175.     pEventElement->m_pSourceElement->m_ulDelay;
  1177.     }
  1178.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  1179.     if(m_pChildren)
  1180.     {
  1181. CHXSimpleList::Iterator i = m_pChildren->Begin();
  1182. for(; i != m_pChildren->End(); ++i)
  1183. {
  1184.     CSmil1TimelineElement* pElement =
  1185.     (CSmil1TimelineElement*)(*i);
  1186.     pElement->setDelay(m_pSourceElement->m_ulDelay);
  1187. }
  1188.     }
  1189. }
  1190.     }
  1191.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceEnd)
  1192.     {
  1193. if(pEventElement->m_bDurationSet)
  1194. {
  1195.     //[SMIL 1.0 Compliance] Helps fix 14420:
  1196.     if (m_bNonEventDelaySet)
  1197.     {
  1198. //Add non-event delay to begin event delay:
  1199. m_pSourceElement->m_ulDelay += 
  1200.     pEventElement->m_pSourceElement->m_ulDuration +
  1201.     pEventElement->m_pSourceElement->m_ulDelay;
  1202.     }
  1203.     else
  1204.     {
  1205. //Just set delay to event delay:
  1206. m_pSourceElement->m_ulDelay = 
  1207.     pEventElement->m_pSourceElement->m_ulDuration +
  1208.     pEventElement->m_pSourceElement->m_ulDelay;
  1210.     }
  1211.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  1212.     if(m_pChildren)
  1213.     {
  1214. CHXSimpleList::Iterator i = m_pChildren->Begin();
  1215. for(; i != m_pChildren->End(); ++i)
  1216. {
  1217.     CSmil1TimelineElement* pElement =
  1218.     (CSmil1TimelineElement*)(*i);
  1219.     pElement->setDelay(m_pSourceElement->m_ulDelay);
  1220. }
  1221.     }
  1222. }
  1223.     }
  1224.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceClock)
  1225.     {
  1226. //We want event *BEGIN* plus clock therefor check for m_bDelaySet not
  1227. // m_bDurationSet; after all, it's the eventElement's m_ulDelay
  1228. // that's used, below:
  1229. if(pEventElement->m_bDelaySet)
  1230. {
  1231.     if (m_bNonEventDelaySet)
  1232.     {
  1233. //Add non-event delay to begin event delay + clock val:
  1234. m_pSourceElement->m_ulDelay += 
  1235.     pEventElement->m_pSourceElement->m_ulDelay +
  1236.     m_pSourceElement->m_ulBeginEventClockValue;
  1237.     }
  1238.     else
  1239.     {
  1240. //Just set delay to event delay:
  1241. m_pSourceElement->m_ulDelay = 
  1242.     pEventElement->m_pSourceElement->m_ulDelay +
  1243.     m_pSourceElement->m_ulBeginEventClockValue;
  1245.     }
  1246.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  1247.     if(m_pChildren)
  1248.     {
  1249. CHXSimpleList::Iterator i = m_pChildren->Begin();
  1250. for(; i != m_pChildren->End(); ++i)
  1251. {
  1252.     CSmil1TimelineElement* pElement =
  1253.     (CSmil1TimelineElement*)(*i);
  1254.     pElement->setDelay(m_pSourceElement->m_ulDelay);
  1255. }
  1256.     }
  1257. }
  1258.     }
  1260.     
  1261. //XXXEH: shouldn't we be making sure the pEventElement's id
  1262. // matches the m_[XXX]EventSourceID, otherwise a begin event on one id
  1263. // and an end event on another will cause problems.
  1264. #if defined(XXXEH_UNTESTED_AND_NOT_EXAMINED_WELL)
  1265.     if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceBegin)
  1266.     {
  1267. if(pEventElement->m_bDelaySet)
  1268. {
  1269.     durationResolved(pEventElement->m_pSourceElement->m_ulDelay);
  1270. }
  1271.     }
  1272.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceEnd)
  1273.     {
  1274. if(pEventElement->m_bDurationSet)
  1275. {
  1276.     durationResolved(pEventElement->getDuration());
  1277. }
  1278.     }
  1279.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceClock)
  1280.     {
  1281. if(pEventElement->m_bDelaySet)
  1282. {
  1283.     durationResolved(pEventElement->m_pSourceElement->m_ulDelay +
  1284.     m_pSourceElement->m_ulEndEventClockValue);
  1285. }
  1286.     }
  1287. #endif // defined(XXXEH_UNTESTED_AND_NOT_EXAMINED_WELL).
  1288. }
  1290. void
  1291. CSmil1TimelineAnchor::durationResolved(UINT32 ulDuration)
  1292. {
  1293.     if(!m_bDurationSet)
  1294.     {
  1295. m_bDurationSet = TRUE;
  1296. m_pSourceElement->m_ulDuration = ulDuration;
  1297.     }
  1298. }