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

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

Symbian

开发平台：

Visual C++

smltime.cpp：源码内容
  1. m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2. {
  3.     HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  4. }
  6. if (HXR_OK !=
  7. m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  8. {
  9.     goto doneSettingDependent;
  10. }
  11. #else
  12. ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  13. m_pSourceElement->m_ulDuration;
  14. // /Helps fix PR 6XXXX(media version): if delay is already packed
  15. // into the duration, then don't count it twice (as can happen in
  16. // <seq><ref begin="1s" .../><ref begin="1s" .../>...):
  17. if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  18. {
  19.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  20. /*OK[]*/     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase !=(UINT32)-1)
  21.     {
  22. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  23. ulTotalDelay);
  24. if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  25. ulTotalDelay)
  26. {
  27.     ulTotalDelay -=
  28.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  29. }
  30.     }
  31. }
  32. #endif
  34. if (WAY_IN_THE_FUTURE < ulTotalDelay)
  35. {
  36.     HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  37.     ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  38. }
  39.  
  40. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION) 
  41. { 
  42.     FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout? 
  43.     ADDDURATION_DEBUGOUT_STR_NEW_FILE : 
  44.     ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE ); 
  45.     ::fprintf(f1, "nt%s:CSmilTimelinePar::resetDelay(%lu):from %lu to %lu;"
  46.     "tresetting dependent (%s)'s delay to %lun", (const char*)m_pID,
  47.     ulDelay, ulPriorDelay, m_pSourceElement->m_ulDelay,
  48.     (const char*)m_pDependent->m_pID, ulTotalDelay);
  49.     ::fclose(f1); 
  50.     bFirstTimeAddDurDebugout = FALSE; 
  51. } 
  52. #endif 
  53.  
  54. m_pDependent->resetDelay(ulTotalDelay);
  55. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  56. doneSettingDependent:
  57. #endif
  59. // /(Added while fixing PR 59851) Let others know our begin time changed:
  60. m_pParser->m_pTimelineElementManager->notify(m_pID);
  61.     }
  62. }
  64. void 
  65. CSmilTimelinePar::adjustDuration()
  66. {
  67.     BOOL    bReset = FALSE;
  68.     UINT32  ulDuration = 0;
  69.     BOOL    bDurationSet = FALSE;
  70.     BOOL    bEndsyncIdDurationFound = FALSE; // /For endsync="[Some ID]"
  71.     // /Need this for fixing PR 50676 part 6:
  72.     ULONG32 ulPriorPureDuration = m_pSourceElement->getPureDuration();
  74.     if (!m_bDurationSet)
  75.     {
  76. goto cleanup;
  77.     }
  79.     if(m_pChildren)
  80.     {
  81. CHXSimpleList::Iterator i = m_pChildren->Begin();
  82. for(; i != m_pChildren->End(); ++i)
  83. {
  84.     CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  86.     // /Checking this fixes PR 69290: if child duration wasn't set,
  87.     // then for crying out loud don't use it here:
  88.     if (!pElement->m_bDurationSet)
  89.     {
  90. continue;
  91.     }
  92.     HX_ASSERT((UINT32)-1 != pElement->m_pSourceElement->m_ulDuration);
  94.     // /Make sure we take endsync into account here; doing so helps fix
  95.     // PR 50679 (and probably other bugs):
  96.     if (SMILEventSourceFirst == m_pSourceElement->m_nEndsyncEventSourceTag)
  97.     {
  98. if (!bDurationSet)
  99. {
  100.     ulDuration = pElement->m_pSourceElement->m_ulDuration;
  101. }
  102. else
  103. {
  104.          ulDuration = (ulDuration < pElement->m_pSourceElement->m_ulDuration) ?
  105.     ulDuration : pElement->m_pSourceElement->m_ulDuration;
  106. }
  107. bDurationSet = TRUE;
  108.     }
  109.     else if (SMILEventSourceID == m_pSourceElement->m_nEndsyncEventSourceTag)
  110.     {
  111. if (pElement->m_pSourceElement->m_pNode  &&
  112. m_pSourceElement->m_EndsyncEventSourceID ==
  113. pElement->m_pSourceElement->m_pNode->m_id)
  114. {
  115.     ulDuration = pElement->m_pSourceElement->m_ulDuration;
  116.     bEndsyncIdDurationFound = TRUE;
  117.     bDurationSet = TRUE;
  118. }
  119.     }
  120.     // /This else-if block fixes problem in PR 62688 repro case where
  121.     // restarting a child, prior to all children playing, caused excl
  122.     // to resolve its dur as if it were endsync="last":
  123.     else if (SMILEventSourceAll ==
  124.     m_pSourceElement->m_nEndsyncEventSourceTag)
  125.     {
  126. if (m_pChildren  &&
  127. m_nDurationAdded >= m_pChildren->GetCount())
  128. {
  129.          ulDuration = (ulDuration > pElement->m_pSourceElement->m_ulDuration) ?
  130.     ulDuration : pElement->m_pSourceElement->m_ulDuration;
  131.     bDurationSet = TRUE;
  132. }
  133. else
  134. {
  135.     // /Don't adjust duration until all child durs are in:
  136.     goto cleanup;
  137. }
  138.     }
  139.     else // /For "last", use the largest child duration:
  140.     {
  141. ulDuration = (ulDuration > pElement->m_pSourceElement->m_ulDuration) ?
  142. ulDuration : pElement->m_pSourceElement->m_ulDuration;
  143. bDurationSet = TRUE;
  144.     }
  146.     // /Fixes PR 50806 (original par version, INTEROP Timing #23.6 as
  147.     // well as par version 2 (endsync="last")): if this has a "min"
  148.     // attribute set, ulDuration shouldn't be less regardless of endSync:
  149.     if (m_pSourceElement->m_ulMinActiveDur > ulDuration)
  150.     {
  151. ulDuration = m_pSourceElement->m_ulMinActiveDur;
  152.     }
  153. }
  155. // /!bDurationSet happens in PR 50588 (case 2: begin="x.end"), when
  156. // child has begun playing but has not yet resolved its duration:
  157. if (!bDurationSet)
  158. {
  159.     goto cleanup;
  160. }
  162. if (SMILEventSourceID == m_pSourceElement->m_nEndsyncEventSourceTag)
  163. {
  164.     if (!bEndsyncIdDurationFound)
  165.     {
  166. goto cleanup; // /That id'd child not added to timeline yet.
  167.     }
  168. }
  169. //check m_ulAuthoredDur here:
  170. if (!m_pSourceElement->m_bHasExplicitEnd  &&
  171. !m_pSourceElement->m_bHasExplicitDur)
  172. {
  173.     m_pSourceElement->m_ulDuration = ulDuration;
  174. }
  175.     
  176. // /Moved this out of the above if() so it gets called every time, to
  177. // fix PR 6XXX? and re-fix PR 55117: we should always give our parents
  178. // a chance to set the outer-time-container duration so it can (re)-
  179. // state to the core what the group duration should be:
  180. if(m_pParent)
  181. {
  182.     m_pParent->adjustDuration();
  183. }
  185. // /Moved this out to happen all the time, too:
  186. if (m_pDependent)
  187. {
  188. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  189.     ULONG32 ulTotalDelay = 0;
  190.     if (HXR_OK !=
  191.     m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  192.     {
  193. goto doneSettingDependent;
  194.     }
  195. #else
  196.     ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  197.     m_pSourceElement->m_ulDuration;
  198.     if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  199.     {
  200. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  201. /*OK[]*/     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase !=(UINT32)-1)
  202. {
  203.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  204.     ulTotalDelay);
  205.     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  206.     ulTotalDelay)
  207.     {
  208. ulTotalDelay -=
  209. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  210.     }
  211. }
  212.     }
  213. #endif
  214.     if (WAY_IN_THE_FUTURE < ulTotalDelay)
  215.     {
  216. // /XXXEH- If delay is greater than this, I want to know:
  217. HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay);
  218. ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  219.     }
  221. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  222. {
  223.     FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  224.     ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  225.     ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  226.     ::fprintf(f1, "nt%s:CSmilTimelinePar::adjustDuration();tresetting dependent (%s)'s delay to %lun",
  227.     (const char*)m_pID, (const char*)m_pDependent->m_pID, ulTotalDelay);
  228.     ::fclose(f1);
  229.     bFirstTimeAddDurDebugout = FALSE;
  230. }
  231. #endif
  232.     m_pDependent->resetDelay(ulTotalDelay);
  233. }
  234. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  235. doneSettingDependent:
  236. ;
  237. #endif
  239.     }
  241.     // /Fixes PR 69410 (with outer par): do this no matter what, even if
  242.     // prior < ulDur; resumed element in excl descendant should extend that
  243.     // excl but we've already told the core to limit the presentation
  244.     // duration, so extend it here as needed:
  245.     // /Helps fix PR 50676 part 6: if our duration got reduced, we need to
  246.     // possibly constrain our children:
  247.     {
  248. // /For PR 62688 & PR 59584: remove check for ulPriorDuration being
  249. // WAY_IN_THE_FUTURE since PR 50676 works without it and there are
  250. // cases where our dur may re-resolve, & updating children is needed.
  252. // /For PR 59584: the group's outer time container needs to set the
  253. // duration if its dur is longer than its group's so far:
  254. if (m_pSourceElement->m_pNode  &&  m_pSourceElement->m_pHandler)
  255. {
  256.     if (m_pSourceElement->m_pNode->m_pParent  &&  (SMILBody == 
  257.     m_pSourceElement->m_pNode->m_pParent->m_tag  ||
  258.     m_pSourceElement->m_pNode->
  259.     m_pParent->m_bIsOuterWrapperTimeContainer) )
  260.     {
  261. BOOL bDoResolveGroupDur = TRUE;
  262. UINT32 ulGroup = m_pSourceElement->m_pNode->m_nGroup;
  263. if (m_pSourceElement->m_pNode->m_bIsOuterWrapperTimeContainer)
  264. {
  265.     ulGroup = 0;
  266.     // /If we're outer wrapper around multiple groups
  267.     // (or "clips"), then let each group outer time container
  268.     // resolve its group duration:
  269.     if (m_pChildren->GetCount() > 1)
  270.     {
  271. bDoResolveGroupDur = FALSE;
  272.     }
  273. }
  274. if (bDoResolveGroupDur)
  275. {
  276.     // /The group duration should be the duration of this
  277.     // outer-most time container:
  278.     HX_RESULT pnrs = m_pSourceElement->m_pHandler->
  279.     resolveGroupDurToOuterTimeContainerDur(
  280.     ulGroup, m_pSourceElement->m_ulDuration);
  281. }
  282.     }
  283. }
  284. if(m_pChildren)
  285. {
  286.     // /Accounting for begin offset of this helps fix PR 65741(par)
  287.     // where excl w/begin="5s' was including that 5s in dur passed
  288.     // to children, thus children were playing 5s too long:
  289.     ULONG32 ulSyncBaseDurationForChildren =
  290.     m_pSourceElement->m_ulDuration;
  291.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  292.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  293.     {
  294. HX_ASSERT(ulSyncBaseDurationForChildren >=
  295. m_pSourceElement->m_ulBeginOffsetFromSyncBase);
  296. if (ulSyncBaseDurationForChildren >=
  297. m_pSourceElement->m_ulBeginOffsetFromSyncBase)
  298. {
  299.     ulSyncBaseDurationForChildren -=
  300.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  301. }
  302.     }
  304.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  305.     for(; i != m_pChildren->End(); ++i)
  306.     {
  307. CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  308. if (pElement->m_pSourceElement  &&
  309. pElement->m_pSourceElement->m_ulDuration >
  310. m_pSourceElement->m_ulDuration)
  311. {
  312.     pElement->setDuration(ulSyncBaseDurationForChildren, TRUE);
  313. }
  314.     }
  315. }
  316.     }
  318. cleanup:
  320.     m_pParser->m_pTimelineElementManager->notify(m_pID);
  322.     return;
  323. }
  325. void 
  326. CSmilTimelinePar::addDuration(UINT32 ulDuration,
  327.       UINT32 ulDelay,
  328.       UINT32 ulChildDelayBeyondStartOfThis, 
  329.       const char* pElementID)
  330. {
  331.     BOOL bHandled = FALSE;
  333.     UINT32 ulPriorPureDuration = m_pSourceElement->getPureDuration();
  335. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  336.     {
  337. FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  338. ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  339. ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  340. ::fprintf(f1, "CSmilTimelinePar{%s}::addDuration(dur=%lu, delay=%lu, "
  341. "childDelayBeyondThis=%lu, id=%s) m_bDurationSet=%sEn",
  342. (const char*)m_pID, ulDuration, ulDelay,
  343. ulChildDelayBeyondStartOfThis, pElementID,
  344. m_bDurationSet?"TRU":"FALS");
  345. ::fclose(f1);
  346. bFirstTimeAddDurDebugout = FALSE;
  347.     }
  348. #endif
  350.     // /If we're inside a seq, our true "sync base" is not the seq but rather
  351.     // the prievious seq sibling (if any).  We need to adjust the ulDelay, if
  352.     // we're in a seq, down to just ulChildDelayBeyondStartOfThis, which is
  353.     // the delay from the prior sibling, not from the seq:
  354.     ULONG32 ulDelayBeyondSyncBase = 0;
  355.     SMILNode* pSyncBaseNode = NULL;
  356.     if (m_pSourceElement->m_pNode)
  357.     {
  358. pSyncBaseNode = m_pParser->getSyncAncestor(
  359.     m_pSourceElement->m_pNode);
  360.     }
  361.     if (!pSyncBaseNode  ||  !pSyncBaseNode->m_pElement)
  362.     {
  363. HX_ASSERT(pSyncBaseNode  &&  pSyncBaseNode->m_pElement);
  364.     }
  365.     // /Do this for all time containers (for part of PR52110 post-fix-delay-
  366.     // offset-bug):
  367.     else
  368.     {
  369. ulDelayBeyondSyncBase = ulChildDelayBeyondStartOfThis;
  370.     }
  372.     BOOL bSetChildCurEndClippedByParent = FALSE;
  373.     BOOL bSetCompletelyRemovedFromTimeline = FALSE;
  374.     BOOL bIsCurChildsFirstAddDuration = FALSE;
  375.     ULONG32 ulCurChildPriorAddedDuration = (UINT32)-1;
  376.     if (!(*m_pChildDurAddedMap)[pElementID])
  377.     {
  378. bIsCurChildsFirstAddDuration = TRUE;
  379.     }
  380.     else
  381.     {
  382. ulCurChildPriorAddedDuration =
  383. (ULONG32)((*m_pChildDurAddedMap)[pElementID]);
  384.     }
  386.     ULONG32 ulActualDurBeyondSyncBase =
  387.     ulDuration + ulDelayBeyondSyncBase - ulChildDelayBeyondStartOfThis;
  389. // /XXXEH-20020106-test:    HX_ASSERT(WAY_IN_THE_FUTURE >= ulActualDurBeyondSyncBase);
  391.     // /Start of fix for PR 55117: explicit dur or end on par should not be
  392.     // overridden by some punk child's dur; if this has an explicit
  393.     // end or dur, don't do anything to its duration based on children durs:
  394.     // /XXXEH- TODO: determine what wins between endsync VS either end or dur
  395.     // if both are specified; here, I assume end|dur wins over endsync:
  396.     if (m_pSourceElement->m_bHasExplicitDur  ||
  397.     m_pSourceElement->m_bHasExplicitEnd)
  398.     {
  399. if ((UINT32)-1 != m_pSourceElement->m_ulDuration  &&
  400. (!m_bDurationSet  ||
  401. !m_pSourceElement->m_bAddDurationAlreadyDone) )
  402. {
  403.     HX_ASSERT((UINT32)-1 != m_pSourceElement->m_ulDelay);
  404.     HX_ASSERT(m_pSourceElement->m_ulDuration ==
  405.     m_pSourceElement->getPureDuration());
  406.     durationResolved(m_pSourceElement->m_ulDuration, FALSE);
  407. }
  408. // /Helps fix PR 6XXXZ (PR 55117 revisited): par in seq where par has explicit dur and
  409. // children all have smaller durations, we need to give outer time
  410. // container a chance to hold the presentation open; this is needed
  411. // when this par is last one in presentation.  (Note: body doesn't set
  412. // the presentation time during createElements() phase because it
  413. // doesn't have m_pHandler yet then):
  414. adjustDuration();
  415. bHandled = TRUE;
  416.     }
  417.     // /Fixes SMIL 1.0's endsync="id(xyz)" and enables SMIL 2.0's
  418.     // id-based endsync: endsync="xyz":
  419.     else if (m_pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceID)
  420.     {
  421. if (!m_pSourceElement->m_EndsyncEventSourceID.IsEmpty()  &&
  422.         !strcmp(m_pSourceElement->m_EndsyncEventSourceID,pElementID))
  423. {
  424.     HX_ASSERT(m_pSourceElement->m_ulDuration ==
  425.     m_pSourceElement->getPureDuration());
  426.     // /Don't just use ulDuration in case child has a begin offset
  427.     // or otherwise has a delay beyond this's delay.
  428.     m_pSourceElement->m_ulDuration = ulActualDurBeyondSyncBase;
  429.     durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  430.     bHandled = TRUE;
  431. }
  432. // /Fixes endsync="[ID]" part of PR 59584 where addDuration of X (!=ID)
  433. // happens after that of lower-duration [ID] sibling and 'X' needs to
  434. // be restricted to ID's duration:
  435. else if (!m_pSourceElement->m_EndsyncEventSourceID.IsEmpty()  &&
  436.         m_pSourceElement->m_ulDuration < ulActualDurBeyondSyncBase)
  437. {
  438.     // /Adjust for offset from parent, if any:
  439.     bSetChildCurEndClippedByParent = TRUE;
  440.     if (m_pSourceElement->m_ulDuration >
  441.     ulChildDelayBeyondStartOfThis)
  442.     {
  443. m_pParser->resetTimelineElementDuration(pElementID,
  444. m_pSourceElement->getPureDuration(),
  445. // /Changed to *child* prior dur while fixing PR 66391:
  446. ulActualDurBeyondSyncBase -
  447. ulChildDelayBeyondStartOfThis);
  448. m_pParser->m_pTimelineElementManager->notify(pElementID);
  449.     }
  450.     else // /Begin offset is beyond parent's end, so remove it:
  451.     // /Fixes PR 64158 (endsync="[ID]" version)
  452.     {
  453. bSetCompletelyRemovedFromTimeline = TRUE;
  454. HX_RESULT retval2 = m_pSourceElement->m_pHandler->
  455. handleTrackRemoval((const char*)pElementID,
  456. (INT32)m_pSourceElement->m_pNode->m_nGroup);
  457.     }
  458. }
  459.     }
  460.     else if(m_pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceAll)
  461.     {
  462. // /Hold par open until all children have had a chance to begin;
  463. // leave the par's duration unresolved awaiting the final child's
  464. // call to "addDuration" (which may never come if child's begin
  465. // never resolves):
  467. // /Helps fix PR 62688(par version): first, check if all children
  468. // have resolved already; if so, then duration is set so we can't
  469. // extend it if begin is after parent par ended:
  470. if (m_nDurationAdded >= m_pChildren->GetCount()  &&
  471. m_pSourceElement->m_ulDuration < ulActualDurBeyondSyncBase)
  472. {
  473.     bSetChildCurEndClippedByParent = TRUE;
  474.     HX_ASSERT(m_ulLastDuration == m_pSourceElement->m_ulDuration);
  475.     if (m_ulLastDuration > ulChildDelayBeyondStartOfThis)
  476.     {
  477. // /Helps fix PR 50660 by removing PR 62688-fix code here that
  478. // turned out to be unnecessary since code elsewhere completely
  479. // fixes PR 62688.  Child should be allowed to extend its
  480. // parent's duration except if it begins *after* its parent has
  481. // already ended, which is how we got here, so do nothing.
  482.     }
  483.     else // /Begin offset is beyond parent's end, so remove it:
  484.     // helps fix PR 62688(par) (endsync="all" version of PR 64158)
  485.     {
  486. bSetCompletelyRemovedFromTimeline = TRUE;
  487. HX_RESULT retval2 = m_pSourceElement->m_pHandler->
  488. handleTrackRemoval((const char*)pElementID,
  489. (INT32)m_pSourceElement->m_pNode->m_nGroup);
  490.     }
  491. }
  493. if(ulActualDurBeyondSyncBase < m_ulFirstDuration  ||
  494. !m_bFirstDurationHasBeenSet)
  495. {
  496.     m_ulFirstDuration = ulActualDurBeyondSyncBase;
  497.     m_bFirstDurationHasBeenSet = TRUE;
  498. }
  499. if(ulActualDurBeyondSyncBase > m_ulLastDuration)
  500. {
  501.     m_ulLastDuration = ulActualDurBeyondSyncBase;
  502. }
  503. // /This helps fix PR 62688(par version): this is used to see if
  504. // we've already resolved our duration (because all children have
  505. // weighed in):
  506. INT32 lTotalDurationsAddedIncludingThisOne = (INT32)m_nDurationAdded;
  507. if (bIsCurChildsFirstAddDuration)
  508. {
  509.     lTotalDurationsAddedIncludingThisOne++;
  510. }
  511. if (lTotalDurationsAddedIncludingThisOne < m_pChildren->GetCount()  &&
  512. // /To help fix PR 59584(par version), only do this once:
  513. WAY_IN_THE_FUTURE != m_pSourceElement->m_ulDuration)
  514. {
  515.     // /XXXEH- need a better way, but for now let's say it's
  516.     // resolved to a very big number until all children have
  517.     // resolved begins:
  518.     durationResolved(WAY_IN_THE_FUTURE, TRUE);
  519. }
  520.     }
  521.     else if(m_pSourceElement->m_ulDuration == (UINT32)-1)
  522.     {
  523. // /Added delay to duration which works in:
  524. // "BUG-20010430_endHappening2sTooEarlyForExclThatHas"...
  525. // ..."2.7sBeginAndDurBasedOnChild(totalPresentationDur5.7s).smil":
  526. m_pSourceElement->m_ulDuration = ulDuration + ulDelayBeyondSyncBase -
  527. // /Added this to fix when par child of seq has child w/begin
  528. // offset, as in the following smil file:
  529. // "BUG-20010501_(broke20010501earlyAMCheckin)beginOnFirst"...
  530. ulChildDelayBeyondStartOfThis;
  532. m_ulFirstDuration = ulActualDurBeyondSyncBase;
  533. m_bFirstDurationHasBeenSet = TRUE;
  534. m_ulLastDuration = ulActualDurBeyondSyncBase;
  535.     }
  536.     else
  537.     {
  538. m_pSourceElement->m_ulDuration = 
  539.     (ulActualDurBeyondSyncBase > m_pSourceElement->m_ulDuration) ?
  540.     ulActualDurBeyondSyncBase : m_pSourceElement->m_ulDuration;
  541. if(ulActualDurBeyondSyncBase < m_ulFirstDuration  ||
  542. // /Fixes several PRs related to endsync="first"; m_ulFirstDuration
  543. // gets init'd to 0, so we need to see if it's been set or not:
  544. !m_bFirstDurationHasBeenSet)
  545. {
  546.     m_ulFirstDuration = ulActualDurBeyondSyncBase;
  547.     m_bFirstDurationHasBeenSet = TRUE;
  548. }
  549. if(ulActualDurBeyondSyncBase > m_ulLastDuration)
  550. {
  551.     m_ulLastDuration = ulActualDurBeyondSyncBase;
  552. }
  553.     }
  555.     ULONG32 ulRevisedActualDurBeyondSyncBase = ulActualDurBeyondSyncBase;
  556.     if (m_pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceFirst)
  557.     {
  558. // /Helps fix PR 66391: if child is time container, make sure this's
  559. // duration is set to shortest child's duration:
  560. m_pSourceElement->m_ulDuration = m_ulFirstDuration;
  562. // /Fixes endsync="first" version of PR 64157 where addDuration
  563. // of longer vid happens after that of lower-duration sibling and
  564. // longer one needs to be clipped to that lower duration (or completely
  565. // removed if begin offset is beyond parent's end (PR 64158)):
  566. if (m_bFirstDurationHasBeenSet  &&
  567. m_ulFirstDuration < ulActualDurBeyondSyncBase)
  568. {
  569.     bSetChildCurEndClippedByParent = TRUE;
  570.     if (m_ulFirstDuration > ulChildDelayBeyondStartOfThis)
  571.     {
  572. m_pParser->resetTimelineElementDuration(pElementID,
  573. m_ulFirstDuration -
  574. // /Fixes PR 64160 (ensync="first" version):
  575. ulChildDelayBeyondStartOfThis,
  576. // /Changed to *child* prior dur while fixing PR 66391:
  577. ulActualDurBeyondSyncBase -
  578. ulChildDelayBeyondStartOfThis);
  580. // /Update dur to be used:
  581. ulRevisedActualDurBeyondSyncBase = m_ulFirstDuration -
  582. ulChildDelayBeyondStartOfThis;
  583. m_pParser->m_pTimelineElementManager->notify(pElementID);
  584.     }
  585.     else // /Begin offset is beyond parent's end, so remove it:
  586.     // /Fixes PR 64158 (endsync="first" version)
  587.     {
  588. bSetCompletelyRemovedFromTimeline = TRUE;
  589. HX_RESULT retval2 = m_pSourceElement->m_pHandler->
  590. handleTrackRemoval((const char*)pElementID,
  591. (INT32)m_pSourceElement->m_pNode->m_nGroup);
  592.     }
  593. }
  594.     }
  596.     if (!(*m_pChildDurAddedMap)[pElementID])
  597.     {
  598. m_nDurationAdded++;
  599. (*m_pChildDurAddedMap)[pElementID] = (void*)ulRevisedActualDurBeyondSyncBase;
  600.     }
  601.     ULONG32 ulChildrenCount = m_pChildren->GetCount();
  602.     // /Fixes PR 56481 find children of this par that don't have a scheduled
  603.     // begin, i.e., are awaiting an event to begin.  endsync="last" says to
  604.     // ignore any children that never play, and we don't know if those
  605.     // event-based begin children will play or not so ignore them for now,
  606.     // and if they ever do begin, *then* re-compute this par's duration:
  607.     ULONG32 ulNonEventBasedBeginChildCount = 0;
  608.     CSmilElement* pCurChildElem = NULL;
  609.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  610.     for(i; i != m_pChildren->End(); ++i)
  611.     {
  612. CSmilTimelineElement* pTmlnElement =
  613. (CSmilTimelineElement*)(*i);
  614. if (pTmlnElement  &&  pTmlnElement->m_pSourceElement)
  615. {
  616.     BOOL isCurAddDurElem = FALSE;
  617.     if (!strcmp(pTmlnElement->m_pSourceElement->m_pNode->m_id,
  618.     pElementID))
  619.     {
  620. isCurAddDurElem = TRUE;
  621. pCurChildElem = pTmlnElement->m_pSourceElement;
  622. if (bSetChildCurEndClippedByParent  &&  pCurChildElem)
  623. {
  624.     pCurChildElem->m_bCurEndClippedByParent = TRUE;
  625. }
  626. if (bSetCompletelyRemovedFromTimeline  &&  pCurChildElem)
  627. {
  628.     pCurChildElem->m_bInsertedIntoTimeline = FALSE;
  629. }
  630.     }
  631.     if ((pTmlnElement->m_pSourceElement->
  632.     m_bHasAtLeastOneNonEventBasedBegin  ||
  633.     // /Do this so this par can re-resolve its duration if &
  634.     // when an event-based-begin child gets added (and thus
  635.     // technically now is a child with a clock-valued begin):
  636.     isCurAddDurElem) )
  637.     {
  638. ulNonEventBasedBeginChildCount++;
  639.     }
  640. }
  641.     }
  642.     
  643.     if (!bHandled  &&
  644.     (m_nDurationAdded >= ulNonEventBasedBeginChildCount  &&
  645.     // /If endsync is all, we need to wait for *all* to be added:
  646.     (SMILEventSourceAll!=m_pSourceElement->m_nEndsyncEventSourceTag  ||
  647.     m_nDurationAdded == ulChildrenCount) )  &&
  648.     !m_bDurationEvent)
  649.     {
  650. BOOL bUpdateDurMightBeNeeded = FALSE;
  651. // /Helps fix PR 62688(par): if duration was set before, but only to
  652. // hold the timeline open until all (or a particular) child duration
  653. // became known, then we want to ignore the durationSet flag so that
  654. // we call duartionResolved() instead of adjustDuration();
  655. BOOL bIgnoreDurationSetFlag = bIsCurChildsFirstAddDuration  &&
  656. (WAY_IN_THE_FUTURE <= m_pSourceElement->m_ulDelay +
  657. m_pSourceElement->m_ulDuration);
  658. // /First, if duration has already been set, then pElement must be an
  659. // event-based-begin child that just resolved, so we need to reset
  660. // our duration appropriately:
  661. if (m_bDurationSet  &&  pCurChildElem  &&  !bIgnoreDurationSetFlag  &&
  662. !pCurChildElem->m_bHasAtLeastOneNonEventBasedBegin)
  663. {
  664.     bUpdateDurMightBeNeeded = TRUE;  // /(PR 59851 hits this line.)
  665. }
  667.         // Switch on different endsync values
  668. if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  669.     SMILEventSourceFirst)
  670. {
  671.     if (bUpdateDurMightBeNeeded)
  672.     {
  673. if (ulActualDurBeyondSyncBase == m_ulFirstDuration)
  674. {
  675.     // /XXXEH- revisit now that addDuration accts for endsync:
  676.     ULONG32 ulOldDur = m_pSourceElement->m_ulDuration;
  677.     adjustDuration();
  678.     HX_ASSERT(m_pSourceElement->m_ulDuration == m_ulFirstDuration);
  679.     // /Other half of fix for PR 50679: if updated duration
  680.     // is less than prior dur, then update timeline element:
  681.     if (ulOldDur > m_pSourceElement->m_ulDuration)
  682.     {
  683. // /Reset duration-set flag to FALSE since we want to
  684. // override (reset) the dur now that this last child
  685. // has been resolved (presumably after playback of
  686. // this par began):
  687. m_bDurationSet = FALSE;
  688. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  689. m_pSourceElement->getPureDuration());
  690. durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  691.     }
  692. }
  693.     }
  694.     else
  695.     {
  696. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  697. m_pSourceElement->getPureDuration());
  698. durationResolved(m_ulFirstDuration, TRUE);
  699.     }
  700. }
  701. else if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  702.     SMILEventSourceLast)
  703. {
  704.     if (bUpdateDurMightBeNeeded)
  705.     {
  706. if (ulActualDurBeyondSyncBase == m_ulLastDuration)
  707. {
  708.     adjustDuration();
  709. }
  710.     }
  711.     else
  712.     {
  713. // /Helps fix PR 62688(par version when endsync="last" is
  714. // explicitly declared): if we previously resolved our
  715. // duration to "unresolved" to hold timeline open, then we
  716. // need to adjust our duration down from WAY_IN_THE_FUTURE:
  717. if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  ||
  718. WAY_IN_THE_FUTURE == m_ulLastDuration  ||
  719. m_pSourceElement->m_ulDuration != m_ulLastDuration)
  720. {
  721.     // /Fixes part 3 of PR 79699 (explicit endsync=last version)
  722.     // where it plays as indefinite because outer par wasn't
  723.     // adjusting for new non-indef dur:
  724.     if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  &&
  725.     bIsCurChildsFirstAddDuration)
  726.     {
  727. HX_ASSERT(WAY_IN_THE_FUTURE == m_ulLastDuration  ||  m_bDurationSet);
  728. // /Trick adjustDuration() into doing its thing
  729. // since this is last child being added for 1st time:
  730. m_bDurationSet = TRUE;
  731.     }
  732.     adjustDuration();
  733.     m_bDurationSet = FALSE;
  734. }
  735. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  736. m_pSourceElement->getPureDuration());
  737. // /To fix PR 59584(par w/event-ended child), w/"last"), use
  738. // m_pSourceE.'s dur, not m_ulLastDuration since latter may
  739. // be wrong if some elements stopped early
  740. durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  741.     }
  742. }
  743. else if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  744.     SMILEventSourceAll)
  745. {
  746.     if (bUpdateDurMightBeNeeded)
  747.     {
  748. if (ulActualDurBeyondSyncBase == m_ulLastDuration)
  749. {
  750.     // /adjustDuration() assumes endsync=last which is OK
  751.     // since we've got all durations:
  752.     adjustDuration();
  753. }
  754.     }
  755.     else
  756.     {
  757. // /Helps fix PR 59584(simplified): if we previously resolved
  758. // our duration to "unresolved" to hold timeline open, then we
  759. // need to adjust our duration down from WAY_IN_THE_FUTURE:
  760. if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  ||
  761. WAY_IN_THE_FUTURE == m_ulLastDuration  ||
  762. m_pSourceElement->m_ulDuration != m_ulLastDuration)
  763. {
  764.     if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  &&
  765.     bIsCurChildsFirstAddDuration)
  766.     {
  767. HX_ASSERT(WAY_IN_THE_FUTURE == m_ulLastDuration  ||  m_bDurationSet);
  768. // /See "part 2 of PR 79699" below; don't want to mess
  769. // with this unless there's content that asserts here:
  770. HX_ASSERT(m_bDurationSet);
  771.     }
  772.     adjustDuration();
  773. }
  774. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  775. m_pSourceElement->getPureDuration());
  776. // /Reset duration-set flag to FALSE since we want to
  777. // override (reset) the dur now that this last child has been
  778. // resolved (presumably after playback of this par began):
  779. m_bDurationSet = FALSE;
  780. // /To fix PR 59584(par w/event-ended child), w/"all"), use
  781. // m_pSourceE.'s dur, not m_ulLastDuration since latter may
  782. // be wrong if some elements stopped early
  783. durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  784.     }
  785. }
  786. else
  787. {
  788.     if (bUpdateDurMightBeNeeded)
  789.     {
  790. if (ulActualDurBeyondSyncBase == m_pSourceElement->m_ulDuration)
  791. {
  792.     adjustDuration();
  793. }
  794.     }
  795.     else
  796.     {
  797. // /Helps fix PR 62688(par version): if we previously resolved
  798. // our duration to "unresolved" to hold timeline open, then we
  799. // need to adjust our duration down from WAY_IN_THE_FUTURE:
  800. if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  ||
  801. WAY_IN_THE_FUTURE == m_ulLastDuration  ||
  802. m_pSourceElement->m_ulDuration != m_ulLastDuration)
  803. {
  804.     // /Fixes part 2 of PR 79699 (imlicit endsync=last version)
  805.     // where it plays as indefinite because outer par wasn't
  806.     // adjusting for new non-indef dur:
  807.     if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  &&
  808.     bIsCurChildsFirstAddDuration)
  809.     {
  810. HX_ASSERT(WAY_IN_THE_FUTURE == m_ulLastDuration  ||  m_bDurationSet);
  811. // /Trick adjustDuration() into doing its thing
  812. // since this is last child being added for 1st time:
  813. m_bDurationSet = TRUE;
  814.     }
  815.     adjustDuration();
  816.     m_bDurationSet = FALSE;
  817. }
  818. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  819. m_pSourceElement->getPureDuration());
  820. durationResolved(m_pSourceElement->m_ulDuration, FALSE);
  821.     }
  822. }
  824. // /This if() block fixes PR 56686 (version 3) and
  825. // PR 61174 (version 3): if time container has longer dur than its
  826. // children and it is not a time-child of the <body>, then its dur
  827. // was never getting accounted for, but now the outer time container
  828. // sets the duration if its dur is longer than its group's so far;
  829. // outer time contnr can only be a par if body has multiple children:
  830. if (m_pSourceElement->m_pNode  &&  m_pSourceElement->m_pHandler)
  831. {
  832.     // /XXXEH- handle <body><switch><par> and <body><a><par>
  833.     if (m_pSourceElement->m_pNode->m_pParent  &&  (SMILBody == 
  834.     m_pSourceElement->m_pNode->m_pParent->m_tag  ||
  835.     m_pSourceElement->m_pNode->
  836.     m_pParent->m_bIsOuterWrapperTimeContainer) )
  837.     {
  838. UINT32 ulGroup = m_pSourceElement->m_pNode->m_nGroup;
  839. // /The group duration should be the duration of this
  840. // outer-most time container:
  841. HX_RESULT pnrs = m_pSourceElement->m_pHandler->
  842. resolveGroupDurToOuterTimeContainerDur(
  843. ulGroup, m_pSourceElement->m_ulDuration);
  844.     }
  845. }
  846.     }
  847. }
  849. void
  850. CSmilTimelinePar::elementResolved(CSmilTimelineElement* pEventElement)
  851. {
  852.     parExclElementResolved(pEventElement);
  853. }
  855. void
  856. CSmilTimelinePar::durationResolved(UINT32 ulDuration, BOOL bUpdateChildren)
  857. {
  858.     parExclDurationResolved(ulDuration, bUpdateChildren);
  859. }
  861. #if 0
  863. #error: **HEY: if this code ever gets enabled, handle CSmilTimelineExcl as well:
  865. void 
  866. CSmilTimelinePar::setEndsync(EndsyncType eType, 
  867.      const char* pEndsyncID,
  868.      UINT32 ulEndsyncClockValue)
  869. {
  870.     m_eEndsyncType = eType;
  871.     m_ulEndsyncClockValue = ulEndsyncClockValue;
  872.     if(pEndsyncID)
  873.     {
  874. m_pEndsyncID = new char[strlen(pEndsyncID)+1];
  875. strcpy(m_pEndsyncID, pEndsyncID); /* Flawfinder: ignore */
  876.     }
  877. }
  878. #endif
  880. /***************************************************************************/
  882. /*
  883.  * CSmilTimelineSeq methods
  884.  */
  885. CSmilTimelineSeq::CSmilTimelineSeq(CSmilElement* pSourceElement,
  886.    CSmilParser* pParser):
  887.     CSmilTimelineElement(pSourceElement, pParser),
  888.     m_nDurationAdded(0)
  889. {
  890. }
  892. void 
  893. CSmilTimelineSeq::addDuration(UINT32 ulDuration, 
  894.       UINT32 ulDelay,
  895.       UINT32 ulChildDelayBeyondStartOfItsSyncBase, 
  896.       const char* pID)
  897. {
  898.     HX_ASSERT(m_pChildren);
  900. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  901.     {
  902. FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  903. ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  904. ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  905. ::fprintf(f1, "CSmilTimelineSeq{%s}::addDuration(dur=%lu, delay=%lu, "
  906. "childDelayBeyondThis=%lu, id=%s) m_bDurationSet=%sEn",
  907. (const char*)m_pID, ulDuration, ulDelay,
  908. ulChildDelayBeyondStartOfItsSyncBase, pID,
  909. m_bDurationSet?"TRU":"FALS");
  910. ::fclose(f1);
  911. bFirstTimeAddDurDebugout = FALSE;
  912.     }
  913. #endif
  915.     // /I don't think we want to/need to use ulChildDelay; it is > 0 in
  916.     // "BUG-20010502_repeatedElementWithBeginOf3sAndEndOf15s.smil" but
  917.     // that works (offset-wise) so no need to use ulChildDelay...:
  919.     ULONG32 ulActualDurBeyondSyncBase = ulDuration;
  920.     // /Fixes case where this seq has a begin offset from its parent and
  921.     // doesn't have an explicit end or dur; the child being added here
  922.     // ended up playing too short by the amount of this's begin offset:
  923.     BOOL bDurationIncludesDelayBeyondSyncbase = FALSE;
  924.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase)
  925.     {
  926. ulActualDurBeyondSyncBase +=
  927. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  928. bDurationIncludesDelayBeyondSyncbase = TRUE;
  929.     }
  931.     if (ulChildDelayBeyondStartOfItsSyncBase > 0)
  932.     {
  933. // /Helps fix PR 6XXXX: be sure to account for child's delay beyond
  934. // its prior sibling in this seq, or the seq itself if no prior sib:
  935. ulActualDurBeyondSyncBase -= ulChildDelayBeyondStartOfItsSyncBase;
  936.     }
  937.     else
  938.     {
  939. HX_ASSERT(0 == ulChildDelayBeyondStartOfItsSyncBase  &&
  940. "ehodge: negative delay in seq!?");
  941.     }
  943.     BOOL bIsCurChildsFirstAddDuration = FALSE;
  944.     ULONG32 ulCurChildPriorAddedDuration = (UINT32)-1;
  945.     if (!(*m_pChildDurAddedMap)[pID])
  946.     {
  947. bIsCurChildsFirstAddDuration = TRUE;
  948.     }
  949.     else
  950.     {
  951. ulCurChildPriorAddedDuration =
  952. (ULONG32)((*m_pChildDurAddedMap)[pID]);
  953.     }
  955.     if(!m_bDurationSet)
  956.     {
  957. if(m_pSourceElement->m_ulDuration == (UINT32)-1)
  958. {
  959.     m_pSourceElement->m_ulDuration = ulActualDurBeyondSyncBase;
  960.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase =
  961.     bDurationIncludesDelayBeyondSyncbase;
  962. }
  963. // /Helps fix PR 62688 and PR 59584: never go higher duration than
  964. // WAY_IN_THE_FUTURE so overall timeline doesn't further extend:
  965. else if (WAY_IN_THE_FUTURE == ulActualDurBeyondSyncBase  ||
  966. WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration)
  967. {
  968.     m_pSourceElement->m_ulDuration = WAY_IN_THE_FUTURE;
  969.     if (m_pSourceElement->m_ulDelay > 0)
  970.     {
  971. if (m_pSourceElement->m_ulDuration >=
  972. m_pSourceElement->m_ulDelay)
  973. {
  974.     m_pSourceElement->m_ulDuration -=
  975.     m_pSourceElement->m_ulDelay;
  976. }
  977. else
  978. {
  979.     m_pSourceElement->m_ulDuration = 0;
  980. }
  981.     }
  982.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase =
  983.     bDurationIncludesDelayBeyondSyncbase;
  984. }
  985. else
  986. {
  987.     m_pSourceElement->m_ulDuration += ulActualDurBeyondSyncBase;
  988.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase =
  989.     bDurationIncludesDelayBeyondSyncbase;
  990. }
  991.     }
  992.     // /Fixes unfiled(?) bug found when PR 52110 was fixed: seq with begin
  993.     // offset>0 and explicit dur was not accounting for this offset in its
  994.     // duration, but parent's addDuration() counts on that being done:
  995.     else if (m_pSourceElement->m_bHasExplicitDur  &&
  996.     !m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  997.     {
  998. if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase)
  999. {
  1000.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase =
  1001.     bDurationIncludesDelayBeyondSyncbase;
  1002.     m_pSourceElement->m_ulDuration +=
  1003.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1004. }
  1005.     }
  1007.     if (!(*m_pChildDurAddedMap)[pID])
  1008.     {
  1009. m_nDurationAdded++;
  1010. (*m_pChildDurAddedMap)[pID] = (void*)ulActualDurBeyondSyncBase;
  1011.     }
  1012.     if(m_nDurationAdded == m_pChildren->GetCount()  ||
  1013.     // /Helps fix PR 59584: if our dur is unresolved, then we need to
  1014.     // notify our parent (and on up the chain) that there is an
  1015.     // currently-indefinite-duration element in the presentation:
  1016.     WAY_IN_THE_FUTURE <= m_pSourceElement->m_ulDuration +
  1017.     m_pSourceElement->m_ulDelay)
  1018.     {
  1019. m_bDurationSet = TRUE;
  1020. if (m_nDurationAdded == m_pChildren->GetCount())
  1021. {
  1022.     // /We need to adjust our duration in case it was temporarily set
  1023.     // to indefinite; now that we have all children accounted for, we
  1024.     // can correctly calculate it:  (fixes PR 59584 overall duration)
  1025.     adjustDuration();
  1026. }
  1027.         // Add our duration to our parent
  1028. if(m_pParent)
  1029. {
  1030.     ULONG32 ulDelayFromSyncBaseBegin = 0;
  1031.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase)
  1032.     {
  1033. ulDelayFromSyncBaseBegin =
  1034. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1035. // /Fixes PR 68875: be sure to add offset from syncbase if
  1036. // not already included:
  1037. if ((UINT32)-1 != ulDelayFromSyncBaseBegin
  1038. &&  ulDelayFromSyncBaseBegin > 0  &&
  1039. !m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1040. {
  1041.     m_pSourceElement->m_ulDuration += ulDelayFromSyncBaseBegin;
  1042.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase = TRUE;
  1043. }
  1044.     }
  1045.     m_pParent->addDuration( 
  1046.     m_pSourceElement->m_ulDuration, 
  1047.     m_pSourceElement->m_ulDelay,
  1048.     ulDelayFromSyncBaseBegin, m_pID);
  1049.     m_pSourceElement->m_bAddDurationAlreadyDone = TRUE;
  1050. }
  1052. // /This if() block fixes PR 56686 (version 2) and
  1053. // PR 61174 (version 2): if time container has longer dur than its
  1054. // children and it is not a time-child of the <body>, then its dur
  1055. // was never getting accounted for, but now the outer time container
  1056. // sets the duration if its dur is longer than its group's so far:
  1057. if (m_pSourceElement->m_pNode  &&  m_pSourceElement->m_pHandler)
  1058. {
  1059.     if (m_pSourceElement->m_pNode->m_pParent  &&  (SMILBody == 
  1060.     m_pSourceElement->m_pNode->m_pParent->m_tag  ||
  1061.     m_pSourceElement->m_pNode->
  1062.     m_pParent->m_bIsOuterWrapperTimeContainer) )
  1063.     {
  1064. BOOL bDoResolveGroupDur = TRUE;
  1065. UINT32 ulGroup = m_pSourceElement->m_pNode->m_nGroup;
  1066. if (m_pSourceElement->m_pNode->m_bIsOuterWrapperTimeContainer)
  1067. {
  1068.     ulGroup = 0;
  1069.     // /If we're outer seq wrapper around multiple groups
  1070.     // (or "clips"), then let each group outer time container
  1071.     // resolve its group duration:
  1072.     if (m_pChildren->GetCount() > 1)
  1073.     {
  1074. bDoResolveGroupDur = FALSE;
  1075.     }
  1076. }
  1077. if (bDoResolveGroupDur)
  1078. {
  1079.     // /The group duration should be the duration of this
  1080.     // outer-most time container:
  1081.     HX_RESULT pnrs = m_pSourceElement->m_pHandler->
  1082.     resolveGroupDurToOuterTimeContainerDur(
  1083.     ulGroup, m_pSourceElement->m_ulDuration);
  1084. }
  1085.     }
  1086. }
  1090.         // Now we know the duration of this <seq>, so 
  1091.         // we need to check the fill behavior of all our
  1092.         // children
  1093.         checkChildrenFillBehavior();
  1094. if(m_pDependent)
  1095. {
  1096.     HX_ASSERT(m_bDurationSet);
  1097.     adjustDependentDuration(m_pDependent);
  1099. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1100.     ULONG32 ulTotalDelay = 0;
  1101.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  1102.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1103.     {
  1104. HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  1105.     }
  1107.     if (HXR_OK !=
  1108.     m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  1109.     {
  1110. goto doneSettingDependent;
  1111.     }
  1112. #else
  1113.     ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  1114.     m_pSourceElement->m_ulDuration;
  1115.     // /Helps fix PR 6XXXX(seq version): if delay is already packed
  1116.     // into the duration, then don't count it twice (as can happen in
  1117.     // <seq><seq begin="1s">...</seq><seq begin="1s" ...):
  1118.     if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1119.     {
  1120. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  1121. /*OK[]*/ if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  1122. {
  1123.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1124.     ulTotalDelay);
  1125.     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1126.     ulTotalDelay)
  1127.     {
  1128. ulTotalDelay -=
  1129. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1130.     }
  1131. }
  1132.     }
  1133. #endif
  1135.     if (WAY_IN_THE_FUTURE < ulTotalDelay)
  1136.     {
  1137. HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  1138. ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  1139.     }
  1141.     // /XXXEH- TODO: figure out if we need to claim this is being set
  1142.     // by "parent" (which is really time base) so clip-begin-like
  1143.     // action can occur; I don't think so, however:
  1144.     m_pDependent->setDelay(ulTotalDelay, FALSE);     
  1145. }
  1146. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1147. doneSettingDependent:
  1148. #endif
  1150. // /[SMIL 1.0 Compliance] Fixes PR 23779:
  1151. // if a source has event-based timing based on this seq's
  1152. // duration, then we need to notify that source that we've
  1153. // resolved this value:
  1154. m_pParser->m_pTimelineElementManager->notify(m_pID);
  1155.     }
  1156. }
  1158. void 
  1159. CSmilTimelineSeq::setDelay(UINT32 ulDelay,
  1160.    // /NOTE: we ignore this in time containers that aren't media:
  1161.    BOOL bSetByParent)
  1162. {
  1163. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  1164.     {
  1165. FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  1166. ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  1167. ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  1168. ::fprintf(f1, "CSmilTimelineSeq{%s}::setDelay(delay=%lu, "
  1169. "bSetByParent=%sE) m_bDelaySet=%sEn",
  1170. (const char*)m_pID, ulDelay,
  1171. bSetByParent?"TRU":"FALS",
  1172. m_bDelaySet?"TRU":"FALS");
  1173. ::fclose(f1);
  1174. bFirstTimeAddDurDebugout = FALSE;
  1175.     }
  1176. #endif
  1178.     if(m_pSourceElement->m_bBeginOffsetSet)
  1179.     {
  1180. m_pSourceElement->m_ulDelay = (
  1181. ((INT32)ulDelay+m_pSourceElement->m_lBeginOffset > 0) ?
  1182. (UINT32)((INT32)ulDelay+m_pSourceElement->m_lBeginOffset):0);
  1183.     }
  1184.     else
  1185.     {
  1186. m_pSourceElement->m_ulDelay = ulDelay;
  1187.     }
  1188.     //XXXJHUG - we need to prevent overwriting the delay when
  1189.     // setInitalDelay is called on THIS element, changing this
  1190.     // bool causes initialDelaySet to return TRUE.
  1191.     m_bDelaySet = TRUE;
  1192.     if(m_pChildren && m_pChildren->GetCount() > 0)
  1193.     {
  1194. // set delay on first child of seq
  1195. CSmilTimelineElement* pElement = 
  1196.     (CSmilTimelineElement*)m_pChildren->GetHead();
  1197. pElement->setDelay(m_pSourceElement->m_ulDelay, TRUE);
  1199. // /To fix it so second group plays (PR6XXX5) after fix for (PR6XXX4),
  1200. // need to set the delay of all children since each is not dependent
  1201. // on the prior; problem is that a child 'n' with an explicit dur will
  1202. // (now) tell its parent its dur during the above setDelay() call and
  1203. // that will end up with this->setDuration() call happening too early,
  1204. // farther below, resulting in all groups > n getting a 0 duration:
  1205. SMILNode* pSyncAncestor = m_pParser? m_pParser->getSyncAncestor(
  1206. m_pSourceElement->m_pNode) : NULL;
  1208. if (!pSyncAncestor  ||  (SMILBody == pSyncAncestor->m_tag  &&
  1209. m_pSourceElement->m_pNode->m_bIsOuterWrapperTimeContainer) )
  1210. {
  1211.     // /Need to set the delays of all children to 0 since each starts its
  1212.     // own "clip" (group):
  1213.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  1214.     ++i;  // /Already done for group 0, above.
  1215.     for(; i != m_pChildren->End(); ++i)
  1216.     {
  1217. pElement = (CSmilTimelineElement*)(*i);
  1218. // /If 0 != this's delay, then body must have begin="x" on it
  1219. // and subsequent groups should not include that delay:
  1220. HX_ASSERT(0 == m_pSourceElement->m_ulDelay);
  1221. pElement->setDelay(0, TRUE);
  1222.     }
  1223. }
  1224.     }
  1226.     // /Fixes PR 24046 (SMIL 2+ seq version): if there are no children,
  1227.     // then the seq's duration is zero, so set it to 0:
  1228.     else if (m_pSourceElement->m_ulDuration == (UINT32)-1)
  1229.     {
  1230. m_pSourceElement->m_ulDuration = 0;
  1231.     }
  1233.     if (m_pSourceElement->m_ulDuration != (UINT32)-1)
  1234.     {
  1235. setDuration(m_pSourceElement->m_ulDuration);
  1237. #if 0 /* 20011024 */
  1238. // /Fixes seq version of PR 61174(version1) and PR 56686
  1239. // (version1): we know our duration already, so let's declare it
  1240. // resolved so we get added to our parent (in case none of our
  1242. // XXXNH: for some reason, despite being if-zeroed-out, this causes a compiler
  1243. // error on linux!
  1244. //#error: DUDE!?!: children of seq can't have unresolved begins!:
  1246.         // children have scheduled begin times in which case our
  1247. // ::addDuration() would not get called up front and the overall
  1248. // presentation would not include our duration at first):
  1249. if (m_pSourceElement->m_bHasExplicitDur  ||
  1250. m_pSourceElement->m_bHasExplicitEnd)
  1251. {
  1252.     // /Be sure not to override a shorter duration that may have
  1253.     // been imposed on us by our parent:
  1254.     if (!m_bDurationSet  ||
  1255.     !m_pSourceElement->m_bAddDurationAlreadyDone)
  1256.     {
  1257. HX_ASSERT((UINT32)-1 != m_pSourceElement->m_ulDelay);
  1259. m_bDurationSet = TRUE;
  1260. if (m_pParent)
  1261. {
  1262.     ULONG32 ulDelayFromSyncBaseBegin = 0;
  1263.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase)
  1264.     {
  1265. ulDelayFromSyncBaseBegin =
  1266. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1267. if (ulDelayFromSyncBaseBegin > 0  &&
  1268. !m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1269. {
  1270.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase =
  1271.     TRUE; // /=TRUE,not ULONG32. Helps fix PR 68190.
  1272.     m_pSourceElement->m_ulDuration += ulDelayFromSyncBaseBegin;
  1273. }
  1274.     }
  1275.     m_pParent->addDuration(m_pSourceElement->m_ulDuration,
  1276.     m_pSourceElement->m_ulDelay,
  1277.     ulDelayFromSyncBaseBegin, m_pID);
  1278.     m_pSourceElement->m_bAddDurationAlreadyDone = TRUE;
  1279. }
  1280.     }
  1281.     HX_ASSERT(m_bDurationSet  &&  m_pSourceElement->m_bAddDurationAlreadyDone);
  1282. }
  1283. #endif
  1284.     }
  1286.     //[SMIL 1.0 Compliance] Helps fix PR 14420 and 23025:
  1287.     // if a source has event-based timing based on this seq's
  1288.     // begin time (delay) then we need to notify that source
  1289.     // that we've resolved this value:
  1290.     m_pParser->m_pTimelineElementManager->notify(m_pID);
  1291. }
  1293. void
  1294. CSmilTimelineSeq::setDuration(UINT32 ulDuration, BOOL bSetFromParent,
  1295.   BOOL bDurationExtendingDueToPause)
  1296. {
  1297.     ASSERT(m_pChildren  ||  0==ulDuration);
  1299.     if (bDurationExtendingDueToPause)
  1300.     {
  1301. // /Need to handle this case:
  1302. HX_ASSERT(!bDurationExtendingDueToPause);
  1303.     }
  1305.     if(!m_bDurationSet  ||
  1306.     // /Adding this fixes PR 27644 and other cases where explicit
  1307.     // dur|end of parent was being ignored by explicit (and larger)
  1308.     // dur|end of child seq.  This allows repeatDur to work when
  1309.     // parent has explicit dur|end since repeatDur creates a seq
  1310.     // with an explicit dur:
  1311.     bSetFromParent)
  1312.     {
  1313. m_pSourceElement->m_ulDuration = ulDuration;
  1314. m_bDurationSet = TRUE;
  1315.     }
  1317.     UINT32 ulDurationLeft = m_pSourceElement->m_ulDuration;
  1318.     RepeatTag repeatTag = RepeatUnknown;
  1320.     if (m_pChildren) // /Fixes crash in case of a "<seq></seq>" (PR 65069).
  1321.     { 
  1322. CHXSimpleList::Iterator i = m_pChildren->Begin(); 
  1323. for(; i != m_pChildren->End(); ++i) 
  1324. { 
  1325.     CSmilTimelineElement* pTmLnElement = (CSmilTimelineElement*)(*i); 
  1326.     CSmilElement* pElement = pTmLnElement->m_pSourceElement;
  1327.     if (!setElementDuration(ulDurationLeft, pTmLnElement))
  1328.     {
  1329. break;
  1330.     }
  1332.     // /Fixes PR 99498: make sure m_pSourceElement's time values are
  1333.     // in same time-coords as pElement's before comparing the two;
  1334.     // in this bug, a seq that began at 15s (15000 delay) had a
  1335.     // duration that did not include that delay so the below PR 66391
  1336.     // fix's if() was erroneously evaluating to true, thus ending
  1337.     // this's children early.  Use this's soureElement's dur+delay,
  1338.     // not its m_ulDuration (which may or may not include delay):
  1339.     UINT32 ulDurationPlusDelayOfThisSeq =
  1340.     m_pSourceElement->getPureDuration() +
  1341.     m_pSourceElement->m_ulDelay;
  1343.     // /Helps fix PR 66391: if this's m_ulDuration has shortened and
  1344.     // its child(ren)'s duration is shortened to zero as a result,
  1345.     // then remove child track if it begins too late to ever play:
  1346.     if (pElement  &&  pElement->m_pHandler  &&
  1347.     pElement->m_ulDelay > ulDurationPlusDelayOfThisSeq  &&
  1348.     pElement->m_bInsertedIntoTimeline)
  1349.     {
  1350. pElement->m_bCurEndClippedByParent = TRUE;
  1352. HX_ASSERT(0 == ulDurationLeft);
  1353. BOOL bCurElementIsTimeContainer =
  1354. m_pParser->isTimeContainerObject(pElement->m_pNode);
  1355. HX_ASSERT(!bCurElementIsTimeContainer  &&  "ehodge:handle_removing_grandkids");
  1357. HX_RESULT retvl = pElement->m_pHandler->handleTrackRemoval(
  1358. (const char*)pElement->m_pNode->m_id,
  1359. (INT32)pElement->m_pNode->m_nGroup);
  1360. if (HXR_OK == retvl)
  1361. {
  1362.     // /Notify syncArc dependents that it ended early:
  1363.     m_pParser->m_pTimelineElementManager->notify((const char*)pElement->m_pNode->m_id);
  1364. }
  1365.     }
  1366. } 
  1367.     } 
  1369.     if(m_pDependent)
  1370.     {
  1371. HX_ASSERT(m_bDurationSet);
  1373. adjustDependentDuration(m_pDependent);
  1375. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1376. ULONG32 ulTotalDelay = 0;
  1377.         if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  1378. m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1379. {
  1380.     HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  1381. }
  1383. if (HXR_OK !=
  1384. m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  1385. {
  1386.     goto doneSettingDependent;
  1387. }
  1388. #else
  1389. ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  1390. m_pSourceElement->m_ulDuration;
  1391. // /Helps fix PR 6XXXX(seq version): if delay is already packed
  1392. // into the duration, then don't count it twice (as can happen in
  1393. // <seq><seq begin="1s">...</seq><seq begin="1s" ...):
  1394. if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1395. {
  1396.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  1397. /*OK[]*/     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  1398.     {
  1399. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1400. ulTotalDelay);
  1401. if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1402. ulTotalDelay)
  1403. {
  1404.     ulTotalDelay -=
  1405.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1406. }
  1407.     }
  1408. }
  1409. #endif
  1411. if (WAY_IN_THE_FUTURE < ulTotalDelay)
  1412. {
  1413.     HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  1414.     ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  1415. }
  1417. // /XXXEH- TODO: figure out if we need to claim this is being set
  1418. // by "parent" (which is really time base) so clip-begin-like
  1419. // action can occur; I don't think so, however:
  1420. m_pDependent->setDelay(ulTotalDelay, FALSE);
  1421.     }
  1422. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1423. doneSettingDependent:
  1424. #endif
  1426.     //[SMIL 1.0 comliance] Helps fix PR 14420 and 23025:
  1427.     m_pParser->m_pTimelineElementManager->notify(m_pID);
  1428. }
  1430. void
  1431. CSmilTimelineSeq::setMaxDuration(UINT32 ulMaxDuration)
  1432. {
  1433.     HX_ASSERT(m_pChildren);
  1434.     m_bMaxDurationSet = TRUE;
  1435.     m_pSourceElement->m_ulMaxDuration = ulMaxDuration;
  1437.     if (m_pChildren  &&  m_bDelaySet)
  1438.     {
  1439. HX_ASSERT((UINT32)-1 != m_pSourceElement->m_ulDelay);
  1441. CSmilTimelineElement* pElement = (CSmilTimelineElement*)m_pChildren->GetHead();
  1442. pElement->setMaxDuration(ulMaxDuration);
  1443.     }
  1444. }
  1446. void 
  1447. CSmilTimelineSeq::adjustDependentDuration(CSmilTimelineElement* pDependent)
  1448. {
  1449.     if(m_bDurationSet || m_bMaxDurationSet)
  1450.     {
  1451. UINT32     ulDurationLeft = m_bDurationSet?m_pSourceElement->m_ulDuration:
  1452.     m_pSourceElement->m_ulMaxDuration;
  1453. UINT32 ulOriginalDurationLeft = ulDurationLeft;
  1454. if (m_pSourceElement->m_ulMinActiveDur>ulDurationLeft)
  1455. {
  1456.     ulDurationLeft = m_pSourceElement->m_ulMinActiveDur;
  1457. }
  1458. BOOL     bAdjusted = FALSE;
  1459. RepeatTag   repeatTag = RepeatUnknown;
  1461. if (m_pChildren) // /Fixes crash in case of a "<seq></seq>" (PR 65069).
  1462. { 
  1463.     CHXSimpleList::Iterator i = m_pChildren->Begin(); 
  1464.     for(; i != m_pChildren->End(); ++i) 
  1465.     { 
  1466. CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i); 
  1467. UINT32 ulChildDuration = pElement->getDuration(); 
  1468.  
  1469. if (pElement == pDependent) 
  1470. { 
  1471.     bAdjusted = TRUE; 
  1472. } 
  1473.  
  1474. if (bAdjusted) 
  1475. { 
  1476.     if (pElement->getDelay() != (UINT32)-1)
  1477.     {
  1478. HX_ASSERT(pElement->getDelay() < WAY_IN_THE_FUTURE  &&
  1479.     "need to reset delay b4 dur!");
  1480.     }
  1481.     // /Fixes PR 59584(parFollowsPar version):  If seq has
  1482.     // unresolved-dur child, don't set dur of next sibling
  1483.     // if it doesn't have delay set yet:
  1484.     else if (0 == ulDurationLeft  &&  WAY_IN_THE_FUTURE ==
  1485.     ulOriginalDurationLeft)
  1486.     {
  1487. break; // /Don't do anything.
  1488.     }
  1489.     // /Helps fix full repro case of PR 59584: second par
  1490.     // in seq will have delay>0 and interim duration
  1491.     // of WAY_IN_THE_FUTURE *minus* delay:
  1492.     if (WAY_IN_THE_FUTURE <= ulOriginalDurationLeft)
  1493.     {
  1494. ulDurationLeft = WAY_IN_THE_FUTURE;
  1495. setElementDuration(ulDurationLeft, pElement);
  1496. break; // /Go no further for now.
  1497.     }
  1498.     if (!setElementDuration(ulDurationLeft, pElement)) 
  1499.     { 
  1500. break; 
  1501.     } 
  1502. } 
  1503. else 
  1504. { 
  1505.     if(ulDurationLeft >= ulChildDuration) 
  1506.     { 
  1507. ulDurationLeft -= ulChildDuration; 
  1508.     } 
  1509.     else 
  1510.     { 
  1511. ulDurationLeft = 0; 
  1512.     } 
  1513. } 
  1514.     } 
  1515. } 
  1517. if (!bAdjusted && m_pParent)
  1518. {
  1519.     m_pParent->adjustDependentDuration(pDependent);
  1520. }
  1521.     }
  1522. }
  1524. void 
  1525. CSmilTimelineSeq::resetDelay(UINT32 ulDelay)
  1526. {
  1527.     INT32 lAdjustedDelay = 0;
  1529.     UINT32 ulPriorDelay = m_pSourceElement->m_ulDelay;
  1531.     if(m_pSourceElement->m_bBeginOffsetSet)
  1532.     {
  1533. lAdjustedDelay = (INT32)ulDelay + m_pSourceElement->m_lBeginOffset;
  1534. m_pSourceElement->m_ulDelay = lAdjustedDelay > 0?lAdjustedDelay:0;
  1535.     }
  1536.     else
  1537.     {
  1538. m_pSourceElement->m_ulDelay = ulDelay;
  1539.     }
  1541.     if(m_pChildren && m_pChildren->GetCount() > 0)
  1542.     {
  1543. // set delay on first child of seq
  1544. CSmilTimelineElement* pElement = 
  1545.     (CSmilTimelineElement*)m_pChildren->GetHead();
  1546. #if 200110241
  1547. if (m_pSourceElement->m_ulDelay !=
  1548. pElement->m_pSourceElement->m_ulDelay)
  1549. {
  1550.     pElement->resetDelay(m_pSourceElement->m_ulDelay);
  1551. }
  1552. #else
  1553. pElement->resetDelay(m_pSourceElement->m_ulDelay);
  1554. #endif
  1555.     }
  1557.     // /To fix PR 59851(seq of seqs), we need to update our next-in-seq
  1558.     // (m_pDependent) as well as make sure sync-arc listeners know we've
  1559.     // changed our overall time bounds delay as well;
  1560.     if (m_pDependent && m_bDurationSet  &&
  1561.     ulPriorDelay != m_pSourceElement->m_ulDelay)
  1562.     {
  1563. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1564. ULONG32 ulTotalDelay = 0;
  1565.         if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  1566. m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1567. {
  1568.     HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  1569. }
  1571. if (HXR_OK !=
  1572. m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  1573. {
  1574.     goto doneSettingDependent;
  1575. }
  1576. #else
  1577. ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  1578. m_pSourceElement->m_ulDuration;
  1579. if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1580. {
  1581.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  1582. /*OK[]*/ if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  1583.     {
  1584. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1585. ulTotalDelay);
  1586. if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1587. ulTotalDelay)
  1588. {
  1589.     ulTotalDelay -=
  1590.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1591. }
  1592.     }
  1593. }
  1594. #endif
  1595. if (WAY_IN_THE_FUTURE < ulTotalDelay)
  1596. {
  1597.     HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  1598.     ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  1599. }
  1600.  
  1601. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION) 
  1602. { 
  1603.     FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout? 
  1604.     ADDDURATION_DEBUGOUT_STR_NEW_FILE : 
  1605.     ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE ); 
  1606.     ::fprintf(f1, "nt%s:CSmilTimelineSeq::resetDelay(%lu):from %lu to %lu;"
  1607.     "tresetting dependent (%s)'s delay to %lun", (const char*)m_pID,
  1608.     ulDelay, ulPriorDelay, m_pSourceElement->m_ulDelay,
  1609.     (const char*)m_pDependent->m_pID, ulTotalDelay);
  1610.     ::fclose(f1); 
  1611.     bFirstTimeAddDurDebugout = FALSE; 
  1612. } 
  1613. #endif 
  1614.  
  1615. m_pDependent->resetDelay(ulTotalDelay);
  1616. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1617. doneSettingDependent:
  1618. #endif
  1620. // /(Added while fixing PR 59851) Let others know our begin time changed:
  1621. m_pParser->m_pTimelineElementManager->notify(m_pID);
  1622.     }
  1623. }
  1625. void 
  1626. CSmilTimelineSeq::adjustDuration()
  1627. {
  1628.     UINT32  ulDuration = 0;
  1630.     // /Fixes seq version of PR 50676 (Added during fix for PR 59584):
  1631.     ULONG32 ulPriorPureDuration = m_pSourceElement->getPureDuration();
  1633.     if (m_pChildren)
  1634.     {
  1635. CHXSimpleList::Iterator i = m_pChildren->Begin();
  1636. for(; i != m_pChildren->End(); ++i)
  1637. {
  1638.     CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  1639.     if ((UINT32)-1 == pElement->m_pSourceElement->m_ulDuration)
  1640.     {
  1641. // /Helps fix PR 59584 (parFollowsPar version): if child dur
  1642. // is not resolved yet, then we're unresolved:
  1643. ulDuration = WAY_IN_THE_FUTURE;
  1644. break;
  1645.     }
  1646.     ulDuration += pElement->m_pSourceElement->m_ulDuration;
  1647.     // /For PR 59584: don't go past "unresolved" dur value:
  1648.     if (ulDuration >= WAY_IN_THE_FUTURE)
  1649.     {
  1650. ulDuration = WAY_IN_THE_FUTURE;
  1651. break;
  1652.     }
  1653. }
  1655. if (!m_pSourceElement->m_bHasExplicitEnd  &&
  1656. !m_pSourceElement->m_bHasExplicitDur)
  1657. {
  1658.     // /Use child durs only if seq doesn't have explicit end or dur;
  1659.     // This helps fix PR 6XXXY:
  1660.     m_pSourceElement->m_ulDuration = ulDuration;
  1661. }
  1663. if(m_pParent)
  1664. {
  1665.     m_pParent->adjustDuration();
  1666. }
  1668. // /Fixes PR 69410: need to do this no matter what, even if prior <
  1669. // ulDur; resumed element in excl descendent should extend that excl
  1670. // but we've already told the core to limit the presentation duration,
  1671. // so extend it here as needed (also fixes part of PR 50660):
  1672. // /(Added while fixing PR 59584): if our duration got reduced, we need to
  1673. // possibly constrain the group's duration:
  1674. {
  1675.     // This group's outer time container, if this is one, needs
  1676.     // to set the duration if its dur is longer than its group's so far
  1677.     // or if its previous duration was unresolved and now is resolved:
  1678.     if (m_pSourceElement->m_pNode  &&  m_pSourceElement->m_pHandler)
  1679.     {
  1680. if (m_pSourceElement->m_pNode->m_pParent  &&  (SMILBody == 
  1681. m_pSourceElement->m_pNode->m_pParent->m_tag  ||
  1682. m_pSourceElement->m_pNode->
  1683. m_pParent->m_bIsOuterWrapperTimeContainer) )
  1684. {
  1685.     BOOL bDoResolveGroupDur = TRUE;
  1686.     UINT32 ulGroup = m_pSourceElement->m_pNode->m_nGroup;
  1687.     if (m_pSourceElement->m_pNode->m_bIsOuterWrapperTimeContainer)
  1688.     {
  1689. ulGroup = 0;
  1690. // /If we're outer wrapper around multiple groups
  1691. // (or "clips"), then let each group outer time container
  1692. // resolve its group duration:
  1693. if (m_pChildren->GetCount() > 1)
  1694. {
  1695.     bDoResolveGroupDur = FALSE;
  1696. }
  1697.     }
  1698.     if (bDoResolveGroupDur)
  1699.     {
  1700. // /The group duration should be the duration of this
  1701. // outer-most time container:
  1702. HX_RESULT pnrs = m_pSourceElement->m_pHandler->
  1703. resolveGroupDurToOuterTimeContainerDur(
  1704. ulGroup, m_pSourceElement->m_ulDuration);
  1705.     }
  1706. }
  1707.     }
  1708. }
  1710. if(m_pDependent)
  1711. {
  1712. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1713.     ULONG32 ulTotalDelay = 0;
  1714.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  1715.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1716.     {
  1717. HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  1718.     }
  1720.     if (HXR_OK !=
  1721.     m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  1722.     {
  1723. goto doneSettingDependent;
  1724.     }
  1725. #else
  1726.     ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  1727.     m_pSourceElement->m_ulDuration;
  1728.     if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  1729.     {
  1730. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  1731. /*OK[]*/ if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  1732. {
  1733.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1734.     ulTotalDelay);
  1735.     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  1736.     ulTotalDelay)
  1737.     {
  1738. ulTotalDelay -=
  1739. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  1740.     }
  1741. }
  1742.     }
  1743. #endif
  1744.     if (WAY_IN_THE_FUTURE < ulTotalDelay)
  1745.     {
  1746. HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  1747. ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  1748.     }
  1750. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  1751. {
  1752.     FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  1753.     ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  1754.     ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  1755.     ::fprintf(f1, "nt%s:CSmilTimelineSeq::adjustDuration();tresetting dependent (%s)'s delay to %lun",
  1756.     (const char*)m_pID, (const char*)m_pDependent->m_pID,
  1757.     ulTotalDelay);
  1758.     ::fclose(f1);
  1759.     bFirstTimeAddDurDebugout = FALSE;
  1760. }
  1761. #endif
  1763.     m_pDependent->resetDelay(ulTotalDelay);
  1764. }
  1765. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  1766. doneSettingDependent:
  1767. ;
  1768. #endif
  1770.     }
  1771. }
  1773. BOOL
  1774. CSmilTimelineSeq::setElementDuration(UINT32& ulDurationLeft, CSmilTimelineElement* pElement)
  1775. {
  1776.     BOOL bContinue = TRUE;
  1777.     UINT32 ulChildDuration = pElement->getDuration();
  1778.     RepeatTag   repeatTag = pElement->m_pSourceElement->m_pNode->m_repeatTag;
  1780.     if (repeatTag == RepeatIndefiniteOnMe)
  1781.     {
  1782. pElement->setMaxDuration(ulDurationLeft);
  1783. ulDurationLeft = 0;
  1784. goto cleanup;
  1785.     }
  1786.     else if (repeatTag == RepeatIndefiniteOnGroup)
  1787.     {
  1788. pElement->setMaxDuration(ulDurationLeft);
  1789. bContinue = FALSE;
  1790. goto cleanup;
  1791.     }
  1793.     // no more duration left, take care of the duration of the rest of 
  1794.     // the elements
  1795.     if (0 == ulDurationLeft)
  1796.     {
  1797. pElement->setDuration(ulDurationLeft, TRUE);
  1798.     }
  1799.     // if this is the last child, then enforce the duration whatever
  1800.     // left
  1801.     else if (pElement == m_pChildren->GetTail())
  1802.     {
  1803. if (ulChildDuration == (UINT32)-1  &&
  1804. ulDurationLeft >= WAY_IN_THE_FUTURE)
  1805. {
  1806.     // /Doing this instead of setDuration() fixes PR 65741 when outer
  1807.     // seq gets held open due to tracks' durations setting in a
  1808.     // certain order.  In this case, don't override possible child
  1809.     // explicit dur or end:
  1810.     pElement->setMaxDuration(ulDurationLeft);
  1811. }
  1812. else
  1813. {
  1814.     pElement->setDuration(ulDurationLeft, TRUE);
  1815. }
  1816. bContinue = FALSE;
  1817.     }
  1818.     // unknown duration, so we apply max. duration here
  1819.     else if (ulChildDuration == (UINT32)-1)
  1820.     {
  1821. pElement->setMaxDuration(ulDurationLeft);
  1822. bContinue = FALSE;
  1823.     }
  1824.     else
  1825.     {
  1826. if(ulDurationLeft >= ulChildDuration)
  1827. {
  1828.     ulDurationLeft -= ulChildDuration;
  1829. }
  1830. else
  1831. {
  1832.     pElement->setDuration(ulDurationLeft, TRUE);
  1833.     ulDurationLeft = 0;
  1834. }
  1835.     }
  1837. cleanup:
  1839.     return bContinue;
  1840. }
  1842. /***************************************************************************/
  1844. // /XXXEH- see if any or all of the following can be combined with
  1845. // CSmilTimelinePar methods, above (with added params for dealing
  1846. // with Excl in minor places):
  1847. /*
  1848.  * CSmilTimelineExcl methods
  1849.  */
  1851. CSmilTimelineExcl::CSmilTimelineExcl(CSmilElement* pSourceElement,
  1852.    CSmilParser* pParser):
  1853.     CSmilTimelineElement(pSourceElement, pParser),
  1854.     m_nDurationAdded(0),
  1855.     m_ulFirstDuration(0),
  1856.     m_bFirstDurationHasBeenSet(FALSE),
  1857.     m_ulLastDuration(0)
  1858. {
  1859. }
  1861. CSmilTimelineExcl::~CSmilTimelineExcl()
  1862. {
  1863. }
  1865. void 
  1866. CSmilTimelineExcl::setDelay(UINT32 ulDelay,
  1867.    // /NOTE: we ignore this in time containers that aren't media:
  1868.    BOOL bSetByParent)
  1869. {
  1870. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  1871.     {
  1872. FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  1873. ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  1874. ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  1875. ::fprintf(f1, "CSmilTimelineExcl{%s}::setDelay(delay=%lu, "
  1876. "bSetByParent=%sE) m_bDelaySet=%sEn",
  1877. (const char*)m_pID, ulDelay,
  1878. bSetByParent?"TRU":"FALS",
  1879. m_bDelaySet?"TRU":"FALS");
  1880. ::fclose(f1);
  1881. bFirstTimeAddDurDebugout = FALSE;
  1882.     }
  1883. #endif
  1885.     if(m_pSourceElement->m_bBeginOffsetSet)
  1886.     {
  1887. m_pSourceElement->m_ulDelay = (
  1888. ((INT32)ulDelay+m_pSourceElement->m_lBeginOffset > 0) ?
  1889. (UINT32)((INT32)ulDelay+m_pSourceElement->m_lBeginOffset):0);
  1890.     }
  1891.     else
  1892.     {
  1893. m_pSourceElement->m_ulDelay = ulDelay;
  1894.     }
  1895.     if (!m_bDelayEvent)
  1896.     {
  1897. m_bDelaySet = TRUE;
  1898. ULONG32 ulNumChildrenWithNonEventBasedBegins = 0;
  1899. if(m_pChildren)
  1900. {
  1901.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  1902.     for(; i != m_pChildren->End(); ++i)
  1903.     {
  1904. CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  1905. // /Don't set delay of children with no valid begin time; the
  1906. // default begin of an excl child is "indefinite".  Note that
  1907. // sync-arc begins of elements that are skipped during this
  1908. // delay-setting-by-parent operation will be OK when they
  1909. // resolve because the resolved time has the delay built in:
  1910. // /Note: tested this with <a> child and it works fine,
  1911. if (pElement->m_pSourceElement  &&
  1912. (pElement->m_pSourceElement->m_bBeginOffsetSet
  1913. #if defined(XXXEH_HANDLE_MULTIPLE_EXCL_CHILD_SCHEDULED_BEGINS)
  1914.  /*can't do this fix yet because excl child w/beginOffset>0 must wait*/
  1915. // /If parent excl begins on event, child with non-
  1916. // event begin time won't yet have beginOffsetSet;
  1917. // fixes PR 56686(version 7 and 8):
  1918. || pElement->m_pSourceElement->
  1919. m_bHasAtLeastOneNonEventBasedBegin) )
  1920. #else
  1921. ) )
  1922. #endif
  1923. {
  1924.     pElement->setDelay(m_pSourceElement->m_ulDelay, TRUE);
  1925. }
  1926. // /else leave delay unresolved.
  1927. // /However, we need to go ahead and see which children have
  1928. // non-event-based begins (see PR 24046 fix, below, which
  1929. // this part of fix for PR 62688 broke by putting the
  1930. // following code inside the if(), above (which never got hit
  1931. // in an excl):
  1932. // /This helps fix PR 62688(excl version):
  1933. if (pElement->m_pSourceElement  &&
  1934. pElement->m_pSourceElement->
  1935. m_bHasAtLeastOneNonEventBasedBegin)
  1936. {
  1937.     ulNumChildrenWithNonEventBasedBegins++;
  1938. }
  1939.     }
  1940. }
  1941. // /Fixes PR 24046 (SMIL 2+ excl version): if there are no children,
  1942. // then the excl's duration is zero, so set it to 0:
  1943. if ((!m_pChildren  &&  m_pSourceElement->m_ulDuration == (UINT32)-1)  ||
  1944. 0 == ulNumChildrenWithNonEventBasedBegins)
  1945. {
  1946.     // /Checking 1st for explicit end or dur re-fixes PR 57150(excl)
  1947.     // which was broken by fix for PR 24046 (note: PR 57150 has dur=x
  1948.     // *and* endsync="all" which is a strange thing to author):
  1949.     if (!m_pSourceElement->m_bHasExplicitDur  &&
  1950.     !m_pSourceElement->m_bHasExplicitEnd)
  1951.     {
  1952. m_pSourceElement->m_ulDuration = 0;
  1953.     }
  1954.     // /Helps fix PR 62688(excl version): if all children are
  1955.     // event-begun and there is at least one child, and endsync="all",
  1956.     // then we have an indefinite duration until all child ends resolve:
  1957.     if (m_pChildren  &&  SMILEventSourceAll ==
  1958.     m_pSourceElement->m_nEndsyncEventSourceTag  &&
  1959.     // /Ignore endsync if it has explicit end or dur:
  1960.     !m_pSourceElement->m_bHasExplicitDur  &&
  1961.     !m_pSourceElement->m_bHasExplicitEnd)
  1962.     {
  1963. m_pSourceElement->m_ulDuration = WAY_IN_THE_FUTURE;
  1964.     }
  1965. }
  1967. if (m_pSourceElement->m_ulDuration != (UINT32)-1)
  1968. {
  1969.     setDuration(m_pSourceElement->m_ulDuration);
  1971. #if 20011024
  1972.     // /Fixes PR 61174(version1) and excl version of PR 56686
  1973.     // (version1): we know our duration already, so let's declare it
  1974.     // resolved so we get added to our parent (in case none of our
  1975.     // children have scheduled begin times in which case our
  1976.     // ::addDuration() would not get called up front and the overall
  1977.     // presentation would not include our duration at first):
  1978.     if (m_pSourceElement->m_bHasExplicitDur  ||
  1979.     m_pSourceElement->m_bHasExplicitEnd  ||
  1980.     // /For PR 62688(excl version) and other endsync="all" bugs:
  1981.     SMILEventSourceAll ==
  1982.     m_pSourceElement->m_nEndsyncEventSourceTag)
  1983.     {
  1984. // /Be sure not to override a shorter duration that may have
  1985. // been imposed on us by our parent:
  1986. if (!m_bDurationSet  ||
  1987. !m_pSourceElement->m_bAddDurationAlreadyDone)
  1988. {
  1989.     HX_ASSERT(m_pSourceElement->m_ulDuration ==
  1990.     m_pSourceElement->getPureDuration());
  1991.     HX_ASSERT((UINT32)-1 != m_pSourceElement->m_ulDelay);
  1992.     durationResolved(m_pSourceElement->m_ulDuration, FALSE);
  1993. }
  1994. HX_ASSERT(m_bDurationSet  &&  m_pSourceElement->m_bAddDurationAlreadyDone);
  1995.     }
  1996. #endif
  1997. }
  1998.     }
  1999.     else 
  2000. // /Let's not claim that the delay is set when we still
  2001. // are awaiting a delay (begin) event; we *do* need to
  2002. // add the delay of this to the event's begin offset.
  2003. // This is done by setting the new "m_bNonEventDelaySet"
  2004. // variable to TRUE and leaving m_bDelaySet to FALSE
  2005. // until the ElementResolved() call sets it to true:
  2006.     {
  2007. // /Parent calls setDelay before we get to ElementResolved,
  2008. // thus m_bDelaySet should never be TRUE if we have a
  2009. // delay event:
  2010. HX_ASSERT(!m_bDelaySet);
  2011. m_bNonEventDelaySet = TRUE; //ElementResolved will look at this.
  2012. m_ulNonEventDelay = ulDelay;
  2013.     }
  2014.     
  2015.     if(m_pDependent && m_bDurationSet)
  2016.     {
  2017. adjustDependentDuration(m_pDependent);
  2019. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  2020. ULONG32 ulTotalDelay = 0;
  2021. if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  2022. m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2023. {
  2024.     HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  2025. }
  2027. if (HXR_OK !=
  2028. m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  2029. {
  2030.     goto doneSettingDependent;
  2031. }
  2032. #else
  2033. ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  2034. m_pSourceElement->m_ulDuration;
  2035. // /Helps fix PR 6XXXX(excl version): if delay is already packed
  2036. // into the duration, then don't count it twice (as can happen in
  2037. // <seq><excl begin="1s">...</excl><excl begin="1s" ...):
  2038. if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2039. {
  2040.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  2041. /*OK[]*/     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  2042.     {
  2043. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  2044. ulTotalDelay);
  2045. if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  2046. ulTotalDelay)
  2047. {
  2048.     ulTotalDelay -=
  2049.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  2050. }
  2051.     }
  2052. }
  2053. #endif
  2055. if (WAY_IN_THE_FUTURE < ulTotalDelay)
  2056. {
  2057.     HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  2058.     ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  2059. }
  2061. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION) 
  2062. { 
  2063.     FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout? 
  2064.     ADDDURATION_DEBUGOUT_STR_NEW_FILE : 
  2065.     ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE ); 
  2066.     ::fprintf(f1, "nt%s:CSmilTimelineExcl::setDelay(%lu): to %lu;"
  2067.     "tresetting dependent (%s)'s delay to %lun", (const char*)m_pID,
  2068.     ulDelay, m_pSourceElement->m_ulDelay,
  2069.     (const char*)m_pDependent->m_pID, ulTotalDelay);
  2070.     ::fclose(f1); 
  2071.     bFirstTimeAddDurDebugout = FALSE; 
  2072. } 
  2073. #endif 
  2074.  
  2075. // /XXXEH- TODO: figure out if we need to claim this is being set
  2076. // by "parent" (which is really time base) so clip-begin-like
  2077. // action can occur; I don't think so, however:
  2078. m_pDependent->setDelay(ulTotalDelay, FALSE);
  2079.     }
  2080. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  2081. doneSettingDependent:
  2082. #endif
  2084.     m_pParser->m_pTimelineElementManager->notify(m_pID);
  2085. }
  2087. void
  2088. CSmilTimelineExcl::setDuration(UINT32 ulDuration, BOOL bSetFromParent,
  2089.   BOOL bDurationExtendingDueToPause)
  2090. {
  2091.     if (bDurationExtendingDueToPause)
  2092.     {
  2093. // /Need to handle this case:
  2094. HX_ASSERT(!bDurationExtendingDueToPause);
  2095.     }
  2097.     setParExclDuration(ulDuration, bSetFromParent);
  2098. }
  2100. void
  2101. CSmilTimelineExcl::setMaxDuration(UINT32 ulMaxDuration)
  2102. {
  2103.     setParExclMaxDuration(ulMaxDuration);
  2104. }
  2106. void 
  2107. CSmilTimelineExcl::resetDelay(UINT32 ulDelay)
  2108. {
  2109.     INT32 lAdjustedDelay = 0;
  2111.     UINT32 ulPriorDelay = m_pSourceElement->m_ulDelay;
  2113.     if(m_pSourceElement->m_bBeginOffsetSet)
  2114.     {
  2115. lAdjustedDelay = (INT32)ulDelay + m_pSourceElement->m_lBeginOffset;
  2116. m_pSourceElement->m_ulDelay = lAdjustedDelay > 0?lAdjustedDelay:0;
  2117.     }
  2118.     else
  2119.     {
  2120. m_pSourceElement->m_ulDelay = ulDelay;
  2121.     }
  2123.     if(m_pChildren)
  2124.     {
  2125. CHXSimpleList::Iterator i = m_pChildren->Begin();
  2126. for(; i != m_pChildren->End(); ++i)
  2127. {
  2128.     CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  2130.     // /Don't set delay of children with no valid begin time; the
  2131.     // default begin of an excl child is "indefinite".  Note that
  2132.     // sync-arc begins of elements that are skipped during this
  2133.     // delay-setting-by-parent operation will be OK when they
  2134.     // resolve because the resolved time has the delay built in:
  2135.     // /Note: tested this with <a> child and it works fine,
  2136.     if (pElement->m_pSourceElement  &&
  2137.     (pElement->m_pSourceElement->m_bBeginOffsetSet
  2138. #if defined(XXXEH_HANDLE_MULTIPLE_EXCL_CHILD_SCHEDULED_BEGINS)
  2139.  /*can't do this fix yet because excl child w/beginOffset>0 must wait*/
  2140. // /If parent excl begins on event, child with non-
  2141. // event begin time won't yet have beginOffsetSet;
  2142. // fixes PR 56686(version 7 and 8):
  2143. || pElement->m_pSourceElement->
  2144. m_bHasAtLeastOneNonEventBasedBegin) )
  2145. #else
  2146. // Fixes PR 86106(version2): if this excl is in
  2147. // 2nd or subsequent child of seq then any updates to
  2148. // any prior sibling's duration wasn't causing this
  2149. // excl to adjust its children's delays accordingly.
  2150. // Now, we do so if and only if m_bDelaySet and has
  2151. // a non-event-based begin:
  2152. ||  pElement->m_bDelaySet  &&
  2153. pElement->m_pSourceElement->
  2154. m_bHasAtLeastOneNonEventBasedBegin 
  2155. ) )
  2156. #endif
  2157.     {
  2158. pElement->resetDelay(m_pSourceElement->m_ulDelay);
  2159.     }
  2160.     // /else leave delay unresolved.
  2161. }
  2162.     }
  2164.     // /To fix PR 59851(seq of excls), we need to update our next-in-seq
  2165.     // (m_pDependent) as well as make sure sync-arc listeners know we've
  2166.     // changed our overall time bounds delay as well;
  2167.     if (m_pDependent && m_bDurationSet  &&
  2168.     ulPriorDelay != m_pSourceElement->m_ulDelay)
  2169.     {
  2170. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  2171. ULONG32 ulTotalDelay = 0;
  2172. if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  2173. m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2174. {
  2175.     HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  2176. }
  2178. if (HXR_OK !=
  2179. m_pSourceElement->getCurrentScheduledStopTime(ulTotalDelay))
  2180. {
  2181.     goto doneSettingDependent;
  2182. }
  2183. #else
  2184. ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  2185. m_pSourceElement->m_ulDuration;
  2186. if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2187. {
  2188.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  2189. /*OK[]*/ if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  2190.     {
  2191. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  2192. ulTotalDelay);
  2193. if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  2194. ulTotalDelay)
  2195. {
  2196.     ulTotalDelay -=
  2197.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  2198. }
  2199.     }
  2200. }
  2201. #endif
  2202. if (WAY_IN_THE_FUTURE < ulTotalDelay)
  2203. {
  2204.     HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  2205.     ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  2206. }
  2207.  
  2208. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION) 
  2209. { 
  2210.     FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout? 
  2211.     ADDDURATION_DEBUGOUT_STR_NEW_FILE : 
  2212.     ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE ); 
  2213.     ::fprintf(f1, "nt%s:CSmilTimelineExcl::resetDelay(%lu):from %lu to %lu;"
  2214.     "tresetting dependent (%s)'s delay to %lun", (const char*)m_pID,
  2215.     ulDelay, ulPriorDelay, m_pSourceElement->m_ulDelay,
  2216.     (const char*)m_pDependent->m_pID, ulTotalDelay);
  2217.     ::fclose(f1); 
  2218.     bFirstTimeAddDurDebugout = FALSE; 
  2219. } 
  2220. #endif 
  2222. m_pDependent->resetDelay(ulTotalDelay);
  2223. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  2224. doneSettingDependent:
  2225. #endif
  2227. // /(Added while fixing PR 59851) Let others know our begin time changed:
  2228. m_pParser->m_pTimelineElementManager->notify(m_pID);
  2229.     }
  2230. }
  2232. void 
  2233. CSmilTimelineExcl::adjustDuration()
  2234. {
  2235.     BOOL    bReset = FALSE;
  2236.     UINT32  ulDuration = 0;
  2237.     BOOL    bDurationSet = FALSE;
  2238.     BOOL    bEndsyncIdDurationFound = FALSE; // /For endsync="[Some ID]"
  2239.     // /Fixes excl version of PR 50676 (Added during fix for PR 59584):
  2240.     ULONG32 ulPriorPureDuration = m_pSourceElement->getPureDuration();
  2242.     if (!m_bDurationSet)
  2243.     {
  2244. // /NOTE: If this has children who have not yet resolved their begin
  2245. // times (which is why we're in this if(), then other children whose
  2246. // durations have extended due to pausing will have no effect on
  2247. // this parent.  We need to let this parent update its duration
  2248. // accordingly (and its parents' durs as well).
  2249. goto cleanup;
  2250.     }
  2252.     if(m_pChildren)
  2253.     {
  2254. CHXSimpleList::Iterator i = m_pChildren->Begin();
  2255. for(; i != m_pChildren->End(); ++i)
  2256. {
  2257.     CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  2259.     // /Checking this fixes excl version of PR 69290: if child duration
  2260.     // isn't set yet, don't use it here:
  2261.     if (!pElement->m_bDurationSet)
  2262.     {
  2263. continue;
  2264.     }
  2265.     HX_ASSERT((UINT32)-1 != pElement->m_pSourceElement->m_ulDuration);
  2268.     // /Make sure we take endsync into account here:
  2269.     if (SMILEventSourceFirst == m_pSourceElement->m_nEndsyncEventSourceTag)
  2270.     {
  2271. if (!bDurationSet)
  2272. {
  2273.     ulDuration = pElement->m_pSourceElement->m_ulDuration;
  2274. }
  2275. else
  2276. {
  2277.          ulDuration = (ulDuration < pElement->m_pSourceElement->m_ulDuration) ?
  2278.     ulDuration : pElement->m_pSourceElement->m_ulDuration;
  2279. }
  2280. bDurationSet = TRUE;
  2281.     }
  2282.     else if (SMILEventSourceID == m_pSourceElement->m_nEndsyncEventSourceTag)
  2283.     {
  2284. if (pElement->m_pSourceElement->m_pNode  &&
  2285. m_pSourceElement->m_EndsyncEventSourceID ==
  2286. pElement->m_pSourceElement->m_pNode->m_id)
  2287. {
  2288.     ulDuration = pElement->m_pSourceElement->m_ulDuration;
  2289.     bEndsyncIdDurationFound = TRUE;
  2290.     bDurationSet = TRUE;
  2291. }
  2292.     }
  2293.     // /This else-if block fixes problem in PR 62688 repro case where
  2294.     // restarting a child, prior to all children playing, caused excl
  2295.     // to resolve its dur as if it were endsync="last":
  2296.     else if (SMILEventSourceAll ==
  2297.     m_pSourceElement->m_nEndsyncEventSourceTag)
  2298.     {
  2299. if (m_pChildren  &&
  2300. m_nDurationAdded >= m_pChildren->GetCount())
  2301. {
  2302.          ulDuration = (ulDuration > pElement->m_pSourceElement->m_ulDuration) ?
  2303.     ulDuration : pElement->m_pSourceElement->m_ulDuration;
  2304.     bDurationSet = TRUE;
  2305. }
  2306. else
  2307. {
  2308.     // /Don't adjust duration until all child durs are in:
  2309.     goto cleanup;
  2310. }
  2311.     }
  2312.     else // /For "last", use the largest child duration:
  2313.     {
  2314. ulDuration = (ulDuration > pElement->m_pSourceElement->m_ulDuration) ?
  2315. ulDuration : pElement->m_pSourceElement->m_ulDuration;
  2316. bDurationSet = TRUE;
  2317.     }
  2319.     // /Fixes PR 50806 (excl versions 1 & 2): if this has "min"
  2320.     // attribute set, ulDuration shouldn't be less regardless
  2321.     // of endSync:
  2322.     if (m_pSourceElement->m_ulMinActiveDur > ulDuration)
  2323.     {
  2324. ulDuration = m_pSourceElement->m_ulMinActiveDur;
  2325.     }
  2326. }
  2328. // /!bDurationSet happens in PR 50588 (case 2: begin="x.end"), when
  2329. // child has begun playing but has not yet resolved its duration:
  2330. if (!bDurationSet)
  2331. {   HX_ASSERT(bDurationSet  &&  "contact-ehodge");
  2332.     goto cleanup;
  2333. }
  2335. if (SMILEventSourceID == m_pSourceElement->m_nEndsyncEventSourceTag)
  2336. { 
  2337.     if (!bEndsyncIdDurationFound)
  2338.     {
  2339. goto cleanup; // /That id'd child not added to timeline yet.
  2340.     }
  2341. } 
  2342. //check m_ulAuthoredDur here:
  2343. if (!m_pSourceElement->m_bHasExplicitEnd  &&
  2344. !m_pSourceElement->m_bHasExplicitDur)
  2345. { 
  2346.     m_pSourceElement->m_ulDuration = ulDuration;
  2347. }
  2348.     
  2349. // /Moved this out of the above if() so it gets called every time, to
  2350. // fix PR 6XXX? and re-fix PR 55117: we should always give our parents
  2351. // a chance to set the outer-time-container duration so it can (re)-
  2352. // state to the core what the group duration should be:
  2353. if(m_pParent)
  2354. {
  2355.     m_pParent->adjustDuration();
  2356. }
  2358. // /Moved this out to happen all the time, too:
  2359. if (m_pDependent)
  2360. {
  2361. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  2362.     ULONG32 ulTotalDelay = 0;
  2363.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  2364.   m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2365.     {
  2366. HX_ASSERT(0  &&  "ehodge: CHANGE NOT TESTED!");
  2367.     }
  2369.     if (HXR_OK != m_pSourceElement->getCurrentScheduledStopTime(
  2370.     ulTotalDelay))
  2371.     {
  2372. goto doneSettingDependent;
  2373.     }
  2374. #else
  2375.     ULONG32 ulTotalDelay = m_pSourceElement->m_ulDelay +
  2376.     m_pSourceElement->m_ulDuration;
  2377.     if (m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2378.     {
  2379. HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1);
  2380. /*OK[]*/ if (m_pSourceElement->m_ulBeginOffsetFromSyncBase != (UINT32)-1)
  2381. {
  2382.     HX_ASSERT(m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  2383.     ulTotalDelay);
  2384.     if (m_pSourceElement->m_ulBeginOffsetFromSyncBase <
  2385.     ulTotalDelay)
  2386.     {
  2387. ulTotalDelay -=
  2388. m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  2389.     }
  2390. }
  2391.     }
  2392. #endif
  2393.     if (WAY_IN_THE_FUTURE < ulTotalDelay)
  2394.     {
  2395. // /XXXEH- If delay is greater than this, I want to know:
  2396. HX_ASSERT(WAY_IN_THE_FUTURE == ulTotalDelay  &&  "PR 59584");
  2397. ulTotalDelay = WAY_IN_THE_FUTURE; // /For PR 59584.
  2398.     }
  2400. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  2401. {
  2402. FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  2403. ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  2404. ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  2405. ::fprintf(f1, "nt%s:CSmilTimelineExcl::adjustDuration();tresetting dependent (%s)'s delay to %lun",
  2406. (const char*)m_pID, (const char*)m_pDependent->m_pID, ulTotalDelay);
  2407. ::fclose(f1);
  2408. bFirstTimeAddDurDebugout = FALSE;
  2409. }
  2410. #endif
  2412.     m_pDependent->resetDelay(ulTotalDelay);
  2413. }
  2414. #if defined(XXXEH_WAIT_UNTIL_getCurrentScheduledStopTime_IS_FIXED_WHEN_BEGINOFFSETSET_20011022)
  2415. doneSettingDependent:
  2416. ;
  2417. #endif
  2418.     }
  2420.     // /Fixes PR 69410 (with outer excl): do this no matter what, even if
  2421.     // prior < ulDur; resumed element in excl should extend this excl but
  2422.     // we've already told the core to limit the presentation duration,
  2423.     // so extend it here as needed:
  2424.     // /(Added while fixing PR 59584): if our duration got reduced, we need to
  2425.     // possibly constrain our children:
  2426.     {
  2427. // /For PR 62688 & PR 59584: remove check for ulPriorDuration being
  2428. // WAY_IN_THE_FUTURE since PR 50676 works without it and there are
  2429. // cases where our dur may re-resolve, & updating children is needed:
  2431. // This group's outer time container, if this is one, needs
  2432. // to set the duration if its dur is longer than its group's so far
  2433. // or if its previous duration was unresolved and now is resolved:
  2434. if (m_pSourceElement->m_pNode  &&  m_pSourceElement->m_pHandler)
  2435. {
  2436.     if (m_pSourceElement->m_pNode->m_pParent  &&  (SMILBody == 
  2437.     m_pSourceElement->m_pNode->m_pParent->m_tag  ||
  2438.     m_pSourceElement->m_pNode->
  2439. /*OK[]*/     m_pParent->m_bIsOuterWrapperTimeContainer) )
  2440.     {
  2441. // /The group duration should be the duration of this
  2442. // outer-most time container:
  2443. HX_RESULT pnrs = m_pSourceElement->m_pHandler->
  2444. resolveGroupDurToOuterTimeContainerDur(
  2445. m_pSourceElement->m_pNode->m_nGroup,
  2446. m_pSourceElement->m_ulDuration);
  2447.     }
  2448. }
  2450. if(m_pChildren)
  2451. {
  2452.     // /Accounting for begin offset of this helps fix PR 65741(excl)
  2453.     // where excl w/begin="5s' was including that 5s in dur passed
  2454.     // to children, thus children were playing 5s too long:
  2455.     ULONG32 ulSyncBaseDurationForChildren =
  2456.     m_pSourceElement->m_ulDuration;
  2457.     if (m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase  &&
  2458.     m_pSourceElement->m_bDurationIncludesDelayBeyondSyncbase)
  2459.     {
  2460. HX_ASSERT(ulSyncBaseDurationForChildren >=
  2461. m_pSourceElement->m_ulBeginOffsetFromSyncBase);
  2462. if (ulSyncBaseDurationForChildren >=
  2463. m_pSourceElement->m_ulBeginOffsetFromSyncBase)
  2464. {
  2465.     ulSyncBaseDurationForChildren -=
  2466.     m_pSourceElement->m_ulBeginOffsetFromSyncBase;
  2467. }
  2468.     }
  2470.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  2471.     for(; i != m_pChildren->End(); ++i)
  2472.     {
  2473. CSmilTimelineElement* pElement = (CSmilTimelineElement*)(*i);
  2474. if (pElement->m_pSourceElement  &&
  2475. pElement->m_pSourceElement->m_ulDuration >
  2476. m_pSourceElement->m_ulDuration)
  2477. {
  2478.     pElement->setDuration(ulSyncBaseDurationForChildren, TRUE);
  2479. }
  2480.     }
  2481. }
  2482.     }
  2484. cleanup:
  2486.     m_pParser->m_pTimelineElementManager->notify(m_pID);
  2488.     return;
  2489. }
  2491. void 
  2492. CSmilTimelineExcl::addDuration(UINT32 ulDuration,
  2493.       UINT32 ulDelay,
  2494.       UINT32 ulChildDelayBeyondStartOfThis, 
  2495.       const char* pElementID)
  2496. {
  2497.     BOOL bHandled = FALSE;
  2499.     UINT32 ulPriorPureDuration = m_pSourceElement->getPureDuration();
  2501. #if defined(_DEBUG)  &&  defined(XXXEH_DEBUGOUT_ADDDURATION)
  2502.     {
  2503. FILE* f1 = ::fopen("c:\smil2AddDuration.txt", bFirstTimeAddDurDebugout?
  2504. ADDDURATION_DEBUGOUT_STR_NEW_FILE :
  2505. ADDDURATION_DEBUGOUT_STR_APPEND_TO_FILE );
  2506. ::fprintf(f1, "CSmilTimelineExcl{%s}::addDuration(dur=%lu, delay=%lu, "
  2507. "childDelayBeyondThis=%lu, id=%s) m_bDurationSet=%sEn",
  2508. (const char*)m_pID, ulDuration, ulDelay,
  2509. ulChildDelayBeyondStartOfThis, pElementID,
  2510. m_bDurationSet?"TRU":"FALS");
  2511. ::fclose(f1);
  2512. bFirstTimeAddDurDebugout = FALSE;
  2513.     }
  2514. #endif
  2516.     // /If we're inside a seq, our true "sync base" is not the seq but rather
  2517.     // the prievious seq sibling (if any).  We need to adjust the ulDelay, if
  2518.     // we're in a seq, down to just ulChildDelayBeyondStartOfThis, which is
  2519.     // the delay from the prior sibling, not from the seq:
  2520.     ULONG32 ulDelayBeyondSyncBase = 0;
  2521.     SMILNode* pSyncBaseNode = NULL;
  2522.     if (m_pSourceElement->m_pNode)
  2523.     {
  2524. pSyncBaseNode = m_pParser->getSyncAncestor(
  2525.     m_pSourceElement->m_pNode);
  2526.     }
  2527.     if (!pSyncBaseNode  ||  !pSyncBaseNode->m_pElement)
  2528.     {
  2529. HX_ASSERT(pSyncBaseNode  &&  pSyncBaseNode->m_pElement);
  2530.     }
  2531.     // /Do this for all time containers (for part of PR52110 post-fix-delay-
  2532.     // offset-bug):
  2533.     else
  2534.     {
  2535. ulDelayBeyondSyncBase = ulChildDelayBeyondStartOfThis;
  2536.     }
  2538.     BOOL bSetChildCurEndClippedByParent = FALSE;
  2539.     BOOL bSetCompletelyRemovedFromTimeline = FALSE;
  2540.     BOOL bIsCurChildsFirstAddDuration = FALSE;
  2541.     ULONG32 ulCurChildPriorAddedDuration = (UINT32)-1;
  2542.     if (!(*m_pChildDurAddedMap)[pElementID])
  2543.     {
  2544. bIsCurChildsFirstAddDuration = TRUE;
  2545.     }
  2546.     else
  2547.     {
  2548. ulCurChildPriorAddedDuration =
  2549. (ULONG32)((*m_pChildDurAddedMap)[pElementID]);
  2550.     }
  2552.     ULONG32 ulActualDurBeyondSyncBase =
  2553.     ulDuration + ulDelayBeyondSyncBase - ulChildDelayBeyondStartOfThis;
  2555. // /XXXEH-20020106-test:    HX_ASSERT(WAY_IN_THE_FUTURE >= ulActualDurBeyondSyncBase);
  2557.     // /Start of fix for PR 55117: explicit dur or end on par should not be
  2558.     // overridden by some punk child's dur; if this has an explicit
  2559.     // end or dur, don't do anything to its duration based on children durs:
  2560.     // /XXXEH- TODO: determine what wins between endsync VS either end or dur
  2561.     // if both are specified; here, I assume end|dur wins over endsync:
  2562.     if (m_pSourceElement->m_bHasExplicitDur  ||
  2563.     m_pSourceElement->m_bHasExplicitEnd)
  2564.     {
  2565. if ((UINT32)-1 != m_pSourceElement->m_ulDuration  &&
  2566. (!m_bDurationSet  ||
  2567. !m_pSourceElement->m_bAddDurationAlreadyDone) )
  2568. {
  2569.     HX_ASSERT((UINT32)-1 != m_pSourceElement->m_ulDelay);
  2570.     HX_ASSERT(m_pSourceElement->m_ulDuration ==
  2571.     m_pSourceElement->getPureDuration());
  2572.     durationResolved(m_pSourceElement->m_ulDuration, FALSE);
  2573. }
  2574. // /Helps fix PR 6XXXZ (PR 55117 revisited): par in seq where par has explicit dur and
  2575. // children all have smaller durations, we need to give outer time
  2576. // container a chance to hold the presentation open; this is needed
  2577. // when this par is last one in presentation.  (Note: body doesn't set
  2578. // the presentation time during createElements() phase because it
  2579. // doesn't have m_pHandler yet then):
  2580. adjustDuration();
  2581. bHandled = TRUE;
  2582.     }
  2583.     // /Fixes SMIL 1.0's endsync="id(xyz)" and enables SMIL 2.0's
  2584.     // id-based endsync: endsync="xyz":
  2585.     else if (m_pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceID)
  2586.     {
  2587. if (!m_pSourceElement->m_EndsyncEventSourceID.IsEmpty()  &&
  2588.         !strcmp(m_pSourceElement->m_EndsyncEventSourceID,pElementID))
  2589. {
  2590.     // /Don't just use ulDuration in case child has a begin offset
  2591.     // or otherwise has a delay beyond this's delay.
  2592.     m_pSourceElement->m_ulDuration = ulActualDurBeyondSyncBase;
  2593.     durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  2594.     bHandled = TRUE;
  2595. }
  2596.     }
  2597.     else if(m_pSourceElement->m_nEndsyncEventSourceTag == SMILEventSourceAll)
  2598.     {
  2599. // /Hold excl open until all children have had a chance to begin;
  2600. // leave the excl's duration unresolved awaiting the final child's
  2601. // call to "addDuration" (which may never come if child's begin
  2602. // never resolves):
  2604. // /Helps fix PR 62688(excl version): first, check if all children
  2605. // have resolved already; if so, then duration is set so we can't
  2606. // extend it if begin is after parent excl ended:
  2607. if (m_nDurationAdded >= m_pChildren->GetCount()  &&
  2608. m_pSourceElement->m_ulDuration < ulActualDurBeyondSyncBase)
  2609. {
  2610.     bSetChildCurEndClippedByParent = TRUE;
  2611.     HX_ASSERT(m_ulLastDuration == m_pSourceElement->m_ulDuration);
  2612.     if (m_ulLastDuration > ulChildDelayBeyondStartOfThis)
  2613.     {
  2614. // /Helps fix PR 50660 by removing PR 62688-fix code here that
  2615. // turned out to be unnecessary since code elsewhere completely
  2616. // fixes PR 62688.  Child should be allowed to extend its
  2617. // parent's duration except if it begins *after* its parent has
  2618. // already ended, which is how we got here, so do nothing.
  2619.     }
  2620.     else // /Begin offset is beyond parent's end, so remove it:
  2621.     // helps fix PR 62688(excl) (endsync="all" version of PR 64158)
  2622.     {
  2623. bSetCompletelyRemovedFromTimeline = TRUE;
  2624. HX_RESULT retval2 = m_pSourceElement->m_pHandler->
  2625. handleTrackRemoval((const char*)pElementID,
  2626. (INT32)m_pSourceElement->m_pNode->m_nGroup);
  2627.     }
  2628. }
  2630. if(ulActualDurBeyondSyncBase < m_ulFirstDuration  ||
  2631. !m_bFirstDurationHasBeenSet)
  2632. {
  2633.     m_ulFirstDuration = ulActualDurBeyondSyncBase;
  2634.     m_bFirstDurationHasBeenSet = TRUE;
  2635. }
  2636. if(ulActualDurBeyondSyncBase > m_ulLastDuration)
  2637. {
  2638.     m_ulLastDuration = ulActualDurBeyondSyncBase;
  2639. }
  2640. // /This helps fix PR 62688(par version): this is used to see if
  2641. // we've already resolved our duration (because all children have
  2642. // weighed in):
  2643. INT32 lTotalDurationsAddedIncludingThisOne = (INT32)m_nDurationAdded;
  2644. if (bIsCurChildsFirstAddDuration)
  2645. {
  2646.     lTotalDurationsAddedIncludingThisOne++;
  2647. }
  2648. if (lTotalDurationsAddedIncludingThisOne < m_pChildren->GetCount()  &&
  2649. // /To help fix PR 59584(excl version), only do this once:
  2650. WAY_IN_THE_FUTURE != m_pSourceElement->m_ulDuration)
  2651. {
  2652.     // /XXXEH- need a better way, but for now let's say it's
  2653.     // resolved to a very big number until all children have
  2654.     // resolved begins:
  2655.     durationResolved(WAY_IN_THE_FUTURE, TRUE);
  2656. }
  2657.     }
  2658.     else if(m_pSourceElement->m_ulDuration == (UINT32)-1)
  2659.     {
  2660. // /Added delay to duration which works in:
  2661. // "BUG-20010430_endHappening2sTooEarlyForExclThatHas"...
  2662. // ..."2.7sBeginAndDurBasedOnChild(totalPresentationDur5.7s).smil":
  2663. m_pSourceElement->m_ulDuration = ulDuration + ulDelayBeyondSyncBase -
  2664. // /Works in excl version of
  2665. // "BUG-20010502(at0700hrs))_firstOu"..."2ndChildIsExcl.smil"
  2666. // /(NOTE: this will be non-zero in the case where the parent
  2667. // excl (this) has endsync="first" and is adding first child
  2668. // due to an event:
  2669. ulChildDelayBeyondStartOfThis;
  2670. m_ulFirstDuration = ulActualDurBeyondSyncBase;
  2671. m_bFirstDurationHasBeenSet = TRUE;
  2672. if (WAY_IN_THE_FUTURE >= m_pSourceElement->m_ulDuration  &&
  2673. !bIsCurChildsFirstAddDuration  &&
  2674. WAY_IN_THE_FUTURE <= ulCurChildPriorAddedDuration)
  2675. {
  2676.     HX_ASSERT(0); // /TESTING! PR 59584.
  2677.     // then don't do the next line (?):
  2678. }
  2679. m_ulLastDuration = ulActualDurBeyondSyncBase;
  2680.     }
  2681.     else
  2682.     // /An excl time container can only have one active track at a time,
  2683.     // but it can know that it will play subsequent ones if they have
  2684.     // resolved delays (which is how we entered this "else" block, so we
  2685.     // need to calculate the excl's duration as the latest that any resolved
  2686.     // element will play as far as we know at this point.  Excl's duration
  2687.     // in many cases will then vary as childrens' delays become resolved
  2688.     // over time:
  2689.     // /XXXEH- test this!!!  I left it the same as for Par, but we should
  2690.     // consider interrupt behavior of the excl's elements since one may
  2691.     // not start while another "uninterruptable" element is playing and
  2692.     // thus may not affect the excl's initial dur:
  2693.     {
  2694. m_pSourceElement->m_ulDuration = 
  2695.     (ulActualDurBeyondSyncBase > m_pSourceElement->m_ulDuration) ?
  2696.     ulActualDurBeyondSyncBase : m_pSourceElement->m_ulDuration;
  2697. // /XXXEH- TODO: handle m_ulFirst...etc. (or make sure they work) now
  2698. // that delay is being added (as it should be) to m_ulDuration, above:
  2699. if(ulActualDurBeyondSyncBase < m_ulFirstDuration  ||
  2700. !m_bFirstDurationHasBeenSet)
  2701. {
  2702.     m_ulFirstDuration = ulActualDurBeyondSyncBase;
  2703.     m_bFirstDurationHasBeenSet = TRUE;
  2704. }
  2705. if(ulActualDurBeyondSyncBase > m_ulLastDuration)
  2706. {
  2707.     m_ulLastDuration = ulActualDurBeyondSyncBase;
  2708. }
  2709.     }
  2711.     if (!(*m_pChildDurAddedMap)[pElementID])
  2712.     {
  2713. m_nDurationAdded++;
  2714. (*m_pChildDurAddedMap)[pElementID] = (void*)ulActualDurBeyondSyncBase;
  2715.     }
  2716.     ULONG32 ulChildrenCount = m_pChildren->GetCount();
  2717.     // /Fixes PR 56481(excl version) find children that don't have a scheduled
  2718.     // begin, i.e., are awaiting an event to begin.  endsync="last" says to
  2719.     // ignore any children that never play, and we don't know if those
  2720.     // event-based begin children will play or not so ignore them for now,
  2721.     // and if they ever do begin, *then* re-compute this excl's duration:
  2722.     ULONG32 ulNonEventBasedBeginChildCount = 0;
  2723.     CSmilElement* pCurChildElem = NULL;
  2724.     CHXSimpleList::Iterator i = m_pChildren->Begin();
  2725.     for(i; i != m_pChildren->End(); ++i)
  2726.     {
  2727. CSmilTimelineElement* pTmlnElement =
  2728. (CSmilTimelineElement*)(*i);
  2729. if (pTmlnElement  &&  pTmlnElement->m_pSourceElement)
  2730. {
  2731.     BOOL isCurAddDurElem = FALSE;
  2732.     if (!strcmp(pTmlnElement->m_pSourceElement->m_pNode->m_id,
  2733.     pElementID))
  2734.     {
  2735. isCurAddDurElem = TRUE;
  2736. pCurChildElem = pTmlnElement->m_pSourceElement;
  2737. if (bSetChildCurEndClippedByParent  &&  pCurChildElem)
  2738. {
  2739.     pCurChildElem->m_bCurEndClippedByParent = TRUE;
  2740. }
  2741. if (bSetCompletelyRemovedFromTimeline  &&  pCurChildElem)
  2742. {
  2743.     pCurChildElem->m_bInsertedIntoTimeline = FALSE;
  2744. }
  2745.     }
  2746.     if ((pTmlnElement->m_pSourceElement->
  2747.     m_bHasAtLeastOneNonEventBasedBegin  ||
  2748.     // /Do this so this par can re-resolve its duration if &
  2749.     // when an event-based-begin child gets added (and thus
  2750.     // technically now is a child with a clock-valued begin):
  2751.     isCurAddDurElem) )
  2752.     {
  2753. ulNonEventBasedBeginChildCount++;
  2754.     }
  2755. }
  2756.     }
  2757.     
  2758.     if (!bHandled  &&
  2759.     (m_nDurationAdded >= ulNonEventBasedBeginChildCount  &&
  2760.     // /If endsync is all, we need to wait for *all* to be added:
  2761.     (SMILEventSourceAll!=m_pSourceElement->m_nEndsyncEventSourceTag  ||
  2762.     m_nDurationAdded == ulChildrenCount) )  &&
  2763.     !m_bDurationEvent)
  2764.     {
  2765. BOOL bUpdateDurMightBeNeeded = FALSE;
  2766. // /Helps fix PR 62688(excl): if duration was set before, but only to
  2767. // hold the timeline open until all (or a particular) child duration
  2768. // became known, then we want to ignore the durationSet flag so that
  2769. // we call duartionResolved() instead of adjustDuration();
  2770. BOOL bIgnoreDurationSetFlag = bIsCurChildsFirstAddDuration  &&
  2771. (WAY_IN_THE_FUTURE <= m_pSourceElement->m_ulDelay +
  2772. m_pSourceElement->m_ulDuration);
  2773. // /First, if duration has already been set, then pElement must be an
  2774. // event-based-begin child that just resolved, so we need to reset
  2775. // our duration appropriately:
  2776. if (m_bDurationSet  &&  pCurChildElem  &&  !bIgnoreDurationSetFlag  &&
  2777. !pCurChildElem->m_bHasAtLeastOneNonEventBasedBegin)
  2778. {
  2779.     bUpdateDurMightBeNeeded = TRUE;
  2780. }
  2782. if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  2783.     SMILEventSourceFirst)
  2784. {
  2785.     if (bUpdateDurMightBeNeeded)
  2786.     {
  2787. if (ulActualDurBeyondSyncBase == m_ulFirstDuration)
  2788. {
  2789.     // /XXXEH- revisit now that addDuration accts for endsync:
  2790.     ULONG32 ulOldDur = m_pSourceElement->m_ulDuration;
  2791.     adjustDuration();
  2792.     HX_ASSERT(m_pSourceElement->m_ulDuration == m_ulFirstDuration);
  2793.     // /Other half of fix for PR 50679: if updated duration
  2794.     // is less than prior dur, then update timeline element:
  2795.     if (ulOldDur > m_pSourceElement->m_ulDuration)
  2796.     {
  2797. // /Reset duration-set flag to FALSE since we want to
  2798. // override (reset) the dur now that this last child
  2799. // has been resolved (presumably after playback of
  2800. // this par began):
  2801. m_bDurationSet = FALSE;
  2802. durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  2803.     }
  2804. }
  2805.     }
  2806.     else
  2807.     {
  2808. durationResolved(m_ulFirstDuration, TRUE);
  2809.     }
  2810. }
  2811. else if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  2812.     SMILEventSourceLast)
  2813. {
  2814.     if (bUpdateDurMightBeNeeded)
  2815.     {
  2816. if (ulActualDurBeyondSyncBase == m_ulLastDuration)
  2817. {
  2818.     adjustDuration();
  2819. }
  2820.     }
  2821.     else
  2822.     {
  2823. // /Helps fix PR 59584(simplified): if we previously resolved
  2824. // our duration to "unresolved" to hold timeline open, then we
  2825. // need to adjust our duration down from WAY_IN_THE_FUTURE:
  2826. if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  ||
  2827. WAY_IN_THE_FUTURE == m_ulLastDuration  ||
  2828. m_pSourceElement->m_ulDuration != m_ulLastDuration)
  2829. {
  2830.     if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  &&
  2831.     bIsCurChildsFirstAddDuration)
  2832.     {
  2833. // /See "part 2 of PR 79699" above; don't want to mess
  2834. // with this unless there's content that asserts here:
  2835. HX_ASSERT(m_bDurationSet);
  2836.     }
  2837.     adjustDuration();
  2838.     m_bDurationSet = FALSE;
  2839. }
  2840. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  2841. m_pSourceElement->getPureDuration());
  2842. // /To fix PR 59584(exclVersionSimplified, w/"last"), use
  2843. // m_pSourceE.'s dur, not m_ulLastDuration since latter may
  2844. // be wrong if some elements stopped early
  2845. durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  2846.     }
  2847. }
  2848. else if(m_pSourceElement->m_nEndsyncEventSourceTag == 
  2849.     SMILEventSourceAll)
  2850. {
  2851.     if (bUpdateDurMightBeNeeded)
  2852.     {
  2853. if (ulActualDurBeyondSyncBase == m_ulLastDuration)
  2854. {
  2855.     // /adjustDuration() assumes endsync=last which is OK
  2856.     // since we've got all durations:
  2857.     adjustDuration();
  2858. }
  2859.     }
  2860.     else
  2861.     {
  2862. // /Helps fix PR 59584(excl, simpl.): if we previously resolved
  2863. // our duration to "unresolved" to hold timeline open, then we
  2864. // need to adjust our duration down from WAY_IN_THE_FUTURE:
  2865. if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  ||
  2866. WAY_IN_THE_FUTURE == m_ulLastDuration  ||
  2867. m_pSourceElement->m_ulDuration != m_ulLastDuration)
  2868. {
  2869.     if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  &&
  2870.     bIsCurChildsFirstAddDuration)
  2871.     {
  2872. // /See "part 2 of PR 79699" above; don't want to mess
  2873. // with this unless there's content that asserts here:
  2874. HX_ASSERT(m_bDurationSet);
  2875.     }
  2876.     adjustDuration();
  2877. }
  2878. HX_ASSERT(m_pSourceElement->m_ulDuration ==
  2879. m_pSourceElement->getPureDuration());
  2880. // /Reset duration-set flag to FALSE since we want to
  2881. // override (reset) the dur now that this last child has been
  2882. // resolved (presumably after playback of this par began):
  2883. m_bDurationSet = FALSE;
  2884. // /To fix PR 59584(exclVersionSimplified), use m_pSourceE.'s
  2885. // duration, not m_ulLastDuration since latter may be wrong
  2886. // if some elements stopped early:
  2887. durationResolved(m_pSourceElement->m_ulDuration, TRUE);
  2888.     }
  2889. }
  2890. else
  2891. {
  2892.     if (bUpdateDurMightBeNeeded)
  2893.     {
  2894. if (ulActualDurBeyondSyncBase == m_pSourceElement->m_ulDuration)
  2895. {
  2896.     adjustDuration();
  2897. }
  2898.     }
  2899.     else
  2900.     {
  2901. // /Helps fix PR 62688(excl version): if we previously resolved
  2902. // our duration to "unresolved" to hold timeline open, then we
  2903. // need to adjust our duration down from WAY_IN_THE_FUTURE:
  2904. if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  ||
  2905. WAY_IN_THE_FUTURE == m_ulLastDuration  ||
  2906. m_pSourceElement->m_ulDuration != m_ulLastDuration)
  2907. {
  2908.     if (WAY_IN_THE_FUTURE == m_pSourceElement->m_ulDuration  &&
  2909.     bIsCurChildsFirstAddDuration)
  2910.     {
  2911. // /See "part 2 of PR 79699" above; don't want to mess
  2912. // with this unless there's content that asserts here:
  2913. HX_ASSERT(m_bDurationSet);
  2914.     }
  2915.     adjustDuration();
  2916.     m_bDurationSet = FALSE;
  2917. }
  2918. HX_ASSERT(m_pSourceElement->m_ulDuration == m_ulLastDuration);
  2919. durationResolved(m_pSourceElement->m_ulDuration, FALSE);
  2920.     }
  2921. }
  2922. // /This if() block fixes PR 56686 (version 4) and
  2923. // PR 61174 (version 4): if time container has longer dur than its
  2924. // children and it is not a time-child of the <body>, then its dur
  2925. // was never getting accounted for, but now the outer time container
  2926. // sets the duration if its dur is longer than its group's so far;
  2927. // outer time contnr can only be a par if body has multiple children:
  2928. if (m_pSourceElement->m_pNode  &&  m_pSourceElement->m_pHandler)
  2929. {
  2930.     // /XXXEH- handle <body><switch><par> and <body><a><par>
  2931.     if (m_pSourceElement->m_pNode->m_pParent  &&  (SMILBody == 
  2932.     m_pSourceElement->m_pNode->m_pParent->m_tag  ||
  2933.     m_pSourceElement->m_pNode->
  2934. /*OK[]*/     m_pParent->m_bIsOuterWrapperTimeContainer) )
  2935.     {
  2936. UINT32 ulGroup = m_pSourceElement->m_pNode->m_nGroup;
  2937. // /The group duration should be the duration of this
  2938. // outer-most time container:
  2939. HX_RESULT pnrs = m_pSourceElement->m_pHandler->
  2940. resolveGroupDurToOuterTimeContainerDur(
  2941. ulGroup, m_pSourceElement->m_ulDuration);
  2942.     }
  2943. }
  2944.     }
  2945. }
  2947. void
  2948. CSmilTimelineExcl::elementResolved(CSmilTimelineElement* pEventElement)
  2949. {
  2950.     parExclElementResolved(pEventElement);
  2951. }
  2953. void
  2954. CSmilTimelineExcl::durationResolved(UINT32 ulDuration, BOOL bUpdateChildren)
  2955. {
  2956.     parExclDurationResolved(ulDuration, bUpdateChildren);
  2957. }
  2959. /***************************************************************************/
  2961. /*
  2962.  * CSmilTimelineAnchor methods
  2963.  */
  2965. CSmilTimelineAnchor::CSmilTimelineAnchor(CSmilElement* pSourceElement,
  2966.    CSmilParser* pParser):
  2967.     CSmilTimelineElement(pSourceElement, pParser)
  2968.     , m_nDurationAdded(0)
  2969. {
  2970. }
  2972. CSmilTimelineAnchor::~CSmilTimelineAnchor()
  2973. {
  2974. }
  2976. void
  2977. CSmilTimelineAnchor::elementResolved(CSmilTimelineElement* pEventElement)
  2978. {
  2979.     //First, let's see if we have a begin event to resolve:
  2980.     if ( (m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceBegin  ||
  2981.     m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceClock)  &&
  2982.     m_pSourceElement->m_BeginEventSourceID == pEventElement->m_pID)
  2983.     {
  2984. if(pEventElement->m_bDelaySet)
  2985. {
  2986.     //[SMIL 1.0 Compliance] Helps fix 14420:
  2987.     if (m_bNonEventDelaySet)
  2988.     {
  2989. //Add non-event delay to syncArc element's delay + clock offset:
  2990. LONG32 lSum =
  2991. (LONG32)pEventElement->m_pSourceElement->m_ulDelay +
  2992. m_pSourceElement->m_lBeginEventClockValue;
  2993. HX_ASSERT(lSum >= 0  &&  "ehodge: handle neg delay propogation");
  2994. lSum = (lSum<0? 0 : lSum);  //clip off negative vals.
  2995. m_pSourceElement->m_ulDelay = m_ulNonEventDelay + (ULONG32)lSum;
  2996.     }
  2997.     else
  2998.     {
  2999. m_ulNonEventDelay = 0;
  3000. //Just set delay to syncArc element's delay:
  3001. //Do the following in case sum is negative; if so, we
  3002. // want to use zero.
  3003. LONG32 lSum =
  3004. (LONG32)pEventElement->m_pSourceElement->m_ulDelay +
  3005. // /Fixes case where anchor/area has begin="foo.begin+5s"
  3006. // we need to account for the 5s here:
  3007. m_pSourceElement->m_lBeginEventClockValue;
  3008. HX_ASSERT(lSum >= 0  &&  "ehodge: handle neg delay propogation");
  3009. lSum = (lSum<0? 0 : lSum);  //clip off negative vals.
  3010. m_pSourceElement->m_ulDelay = (ULONG32)lSum;
  3012. // /Now, we need to set the vars that keep track of our
  3013. // offset from our syncBase element because isCurrentLink
  3014. // uses times relative to our syncBase:
  3015. SMILNode* pSyncNode = (!m_pParser? NULL :
  3016.        m_pParser->getSyncAncestor(m_pSourceElement->m_pNode));
  3017. HX_ASSERT(pSyncNode  &&  pSyncNode->m_pElement);
  3018. if (pSyncNode  &&  pSyncNode->m_pElement)
  3019. { 
  3020.     ULONG32 ulSyncBaseDelay =
  3021.     pSyncNode->m_pElement->m_ulDelay;
  3022.     HX_ASSERT((UINT32)-1 != ulSyncBaseDelay);
  3023.     if ((UINT32)-1 != ulSyncBaseDelay  &&
  3024.     (UINT32)-1 != m_pSourceElement->m_ulDelay )
  3025.     { 
  3026. HX_ASSERT(m_pSourceElement->m_ulDelay >=
  3027. ulSyncBaseDelay);
  3028. m_pSourceElement->m_bCurBeginIsOffsetFromSyncBase =
  3029. TRUE;
  3030. if (m_pSourceElement->m_ulDelay >= ulSyncBaseDelay)
  3031. { 
  3032.     ULONG32 ulEffectiveBeginOffset =
  3033.     m_pSourceElement->m_ulDelay -
  3034.     ulSyncBaseDelay;
  3035.     m_pSourceElement->m_ulBeginOffsetFromSyncBase =
  3036.     ulEffectiveBeginOffset;
  3037. } 
  3038. else
  3039. { 
  3040.     m_pSourceElement->m_ulBeginOffsetFromSyncBase = 0;
  3041. } 
  3042.     } 
  3043. } 
  3044.     }
  3046.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  3047.     if(m_pChildren)
  3048.     {
  3049. CHXSimpleList::Iterator i = m_pChildren->Begin();
  3050. for(; i != m_pChildren->End(); ++i)
  3051. {
  3052.     CSmilTimelineElement* pElement =
  3053.     (CSmilTimelineElement*)(*i);
  3054.     pElement->setDelay(m_pSourceElement->m_ulDelay, TRUE);
  3055. }
  3056.     }
  3057. }
  3058.     }
  3059.     else if(m_pSourceElement->m_nBeginEventSourceTag == SMILEventSourceEnd  &&
  3060.     m_pSourceElement->m_BeginEventSourceID == pEventElement->m_pID)
  3061.     {
  3062. // /If event element's duration is "WAY_IN_THE_FUTURE" then it's
  3063. // essentially an unresolved end time, so we should not resolve
  3064. // based on it:
  3065. if(pEventElement->m_bDurationSet  &&  WAY_IN_THE_FUTURE !=
  3066. pEventElement->m_pSourceElement->m_ulDuration)
  3067. {
  3068.     //[SMIL 1.0 Compliance] Helps fix 14420:
  3069.     if (m_bNonEventDelaySet)
  3070.     {
  3071. //Add non-event delay to syncArc element's delay + clock offset:
  3072. LONG32 lSum =
  3073. (LONG32)pEventElement->m_pSourceElement->m_ulDuration +
  3074. (LONG32)pEventElement->m_pSourceElement->m_ulDelay +
  3075. // /Fixes begin="foo.end+5s"; 5s was being ignored:
  3076. m_pSourceElement->m_lBeginEventClockValue;
  3077. HX_ASSERT(lSum >= 0  &&  "ehodge: handle neg delay propogation");
  3078. lSum = (lSum<0? 0 : lSum);  //clip off negative vals.
  3079. m_pSourceElement->m_ulDelay = m_ulNonEventDelay + (ULONG32)lSum;
  3080.     }
  3081.     else
  3082.     {
  3083. //Add non-event delay to syncArc element's delay + clock offset:
  3084. LONG32 lSum =
  3085. (LONG32)pEventElement->m_pSourceElement->m_ulDuration +
  3086. (LONG32)pEventElement->m_pSourceElement->m_ulDelay +
  3087. // /Fixes PR 68495 begin="foo.end+5s"; 5s was ignored
  3088. // without the following:
  3089. m_pSourceElement->m_lBeginEventClockValue;
  3090. HX_ASSERT(lSum >= 0  &&  "ehodge: handle neg delay propogation");
  3091. lSum = (lSum<0? 0 : lSum);  //clip off negative vals.
  3092. m_ulNonEventDelay = 0;
  3093. m_pSourceElement->m_ulDelay = (ULONG32)lSum;
  3094.     }
  3095.     m_bNonEventDelaySet = m_bDelaySet = TRUE;
  3096.     if(m_pChildren)
  3097.     {
  3098. CHXSimpleList::Iterator i = m_pChildren->Begin();
  3099. for(; i != m_pChildren->End(); ++i)
  3100. {
  3101.     CSmilTimelineElement* pElement =
  3102.     (CSmilTimelineElement*)(*i);
  3103.     pElement->setDelay(m_pSourceElement->m_ulDelay, TRUE);
  3104. }
  3105.     }
  3106. }
  3107.     }
  3109.     
  3110.     //XXXEH-The following cases need to be tested!:
  3111.     if ( (m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceBegin  ||
  3112.     m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceClock)  &&
  3113.     m_pSourceElement->m_EndEventSourceID == pEventElement->m_pID)
  3114.     {
  3115. if(pEventElement->m_bDelaySet)
  3116. {
  3117.     LONG32 lSum =(LONG32)pEventElement->m_pSourceElement->m_ulDelay +
  3118.          m_pSourceElement->m_lEndEventClockValue;
  3119.     HX_ASSERT(lSum >= 0  &&  "ehodge: handle neg delay propogation");
  3120.     lSum = (lSum<0? 0 : lSum);  //clip off negative vals.
  3121.     durationResolved((ULONG32)lSum);
  3122. }
  3123.     }
  3124.     else if(m_pSourceElement->m_nEndEventSourceTag == SMILEventSourceEnd  &&
  3125.     m_pSourceElement->m_EndEventSourceID == pEventElement->m_pID)
  3126.     {
  3127. // /If event element's duration is "WAY_IN_THE_FUTURE" then it's
  3128. // essentially an unresolved end time, so we should not resolve
  3129. // based on it:
  3130. if(pEventElement->m_bDurationSet  &&  WAY_IN_THE_FUTURE !=
  3131. pEventElement->m_pSourceElement->m_ulDuration)
  3132. {
  3133.     LONG32 lSum =(LONG32)pEventElement->getDuration() +
  3134.     m_pSourceElement->m_lEndEventClockValue;
  3135.     // /If the event element has a delay, we need to add that:
  3136.     if(pEventElement->m_bDelaySet)
  3137.     {
  3138. lSum += (LONG32)pEventElement->m_pSourceElement->m_ulDelay;
  3139. if (pEventElement->m_pSourceElement->m_bBeginOffsetSet)
  3140. {
  3141.     lSum -= pEventElement->m_pSourceElement->m_lBeginOffset;
  3142. }
  3143.     }
  3144.     HX_ASSERT(lSum >= 0  &&  "ehodge: handle neg delay propogation");
  3145.     lSum = (lSum<0? 0 : lSum);  //clip off negative vals.
  3146.     durationResolved((ULONG32)lSum);
  3147. }
  3148.     }
  3149. }
  3151. void
  3152. CSmilTimelineAnchor::durationResolved(UINT32 ulDuration)
  3153. {
  3154.     if(!m_bDurationSet)
  3155.     {
  3156. m_bDurationSet = TRUE;
  3157. m_pSourceElement->m_ulDuration = ulDuration;
  3158.     }
  3159. }
  3162. CSmilTimelineAnimate::CSmilTimelineAnimate(CSmilElement* pSourceElement,
  3163.                                            CSmilParser* pParser)
  3164.     : CSmilTimelineElement(pSourceElement, pParser)
  3165. {
  3166. }
  3168. CSmilTimelineAnimate::~CSmilTimelineAnimate()
  3169. {
  3170. }
  3172. void CSmilTimelineAnimate::setDuration(UINT32 ulDuration, BOOL bSetFromParent,
  3173.   BOOL bDurationExtendingDueToPause)
  3174. {
  3175.     if (!bSetFromParent)
  3176.     {
  3177.         CSmilTimelineElement::setDuration(ulDuration, bSetFromParent,
  3178.   bDurationExtendingDueToPause);
  3179.     }
  3180. }