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

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

Symbian

开发平台：

C/C++

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