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

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

Symbian

开发平台：

Visual C++

smlparse.cpp：源码内容
  2. HX_RESULT
  3. CSmil1Parser::selectSwitchNodes(SMIL1Node* pSwitchNode)
  4. {
  5.     HX_RESULT rc = HXR_OK;
  7.     SMIL1NodeList* pNodeList = pSwitchNode->m_pNodeList;
  8.     if(!pNodeList)
  9.     {
  10. return rc;
  11.     }
  13.     SMIL1Node* pSelectedNode = 0;
  14.     CHXSimpleList* pRejectedNodeList = new CHXSimpleList;
  16.     CHXSimpleList::Iterator i;
  17.     for(i=pNodeList->Begin();i!=pNodeList->End();++i)
  18.     {
  19. SMIL1Node* pNode = (SMIL1Node*)(*i);
  21. if(!pNode->m_bDelete)
  22. {
  23.     if(testAttributeFailed(pNode))
  24.     {
  25. pRejectedNodeList->AddTail(pNode);
  26.     }
  27.     else
  28.     {
  29. pSelectedNode = pNode; 
  30. //[SMIL 1.0 Compliance] Fixes PR 26732:
  31. //Now, update selected node's id to that of the switch so
  32. // that anchors pointing to the switch id will reference
  33. // the node of the switch that was selected.  Note that
  34. // we can't fix this the other way around, namely to rename
  35. // all anchors' id strings to that of the selected node
  36. // since not all of them have been parsed/set yet:
  37. HX_ASSERT(pSelectedNode->m_id.GetLength() > 0  && 
  38.     pSwitchNode->m_id.GetLength() > 0);
  39. if (pSelectedNode->m_id.GetLength() > 0 &&  
  40.     pSwitchNode->m_id.GetLength() > 0)
  41. {
  42.     pSelectedNode->m_id = pSwitchNode->m_id;
  43.     (*m_pIDMap)[(const char*)pSelectedNode->m_id] =
  44.     pSelectedNode;
  45.     pSwitchNode->m_id = assignID("switch");
  46.     (*m_pIDMap)[(const char*)pSwitchNode->m_id] =
  47.     pSwitchNode;
  48. }
  49. break;
  50.     }
  51. }
  52.     }
  54.     HX_DELETE(pRejectedNodeList);
  56.     // delete non-selected nodes
  57.     for(i=pNodeList->Begin();i!=pNodeList->End();++i)
  58.     {
  59. SMIL1Node* pNode = (SMIL1Node*)(*i);
  60. if(pNode != pSelectedNode)
  61. {
  62.     pNode->m_bDelete = TRUE;
  63. }
  64.     }
  66.     return rc;
  67. }
  69. HX_RESULT
  70. CSmil1Parser::markTestAttributeNodes(SMIL1NodeList* pNodeList)
  71. {
  72.     HX_RESULT rc = HXR_OK;
  74.     if(!pNodeList)
  75.     {
  76. return rc;
  77.     }
  79.     CHXSimpleList::Iterator i;
  80.     for(i=pNodeList->Begin();i!=pNodeList->End() && SUCCEEDED(rc);++i)
  81.     {
  82. SMIL1Node* pNode = (SMIL1Node*)(*i);
  84. rc = addToNamespaceScope(pNode);
  85. if (FAILED(rc))
  86. {
  87.     return rc;
  88. }
  90. if(pNode->m_tag == SMILSwitch)
  91. {
  92.     selectSwitchNodes(pNode);
  93. }
  94. else
  95. {
  96.     if(testAttributeFailed(pNode))
  97.     {
  98. pNode->m_bDelete = TRUE;
  99.     }
  100. }
  101. //Fix for PR 21303: we need to keep drilling down
  102. // through the tree even if we've just called
  103. // selectSwitchNodes() to delete all but one
  104. // child of the switch; the descendants of that
  105. // child may have attributes as well that need
  106. // to be checked:
  107. //(For efficiency, only do the following code if
  108. // the node is not already slated for deletion
  109. // because a deletable node's children will be
  110. // deleted anyway):
  111. if (!pNode->m_bDelete)
  112. {
  113.     rc = markTestAttributeNodes(pNode->m_pNodeList);
  114. }
  115. if (SUCCEEDED(rc))
  116. {
  117.     rc = removeFromNamespaceScope(pNode);
  118. }
  119.     }
  120.     return rc;
  121. }
  123. BOOL
  124. CSmil1Parser::firstDependentChild(SMIL1Node* pNode)
  125. {
  126.     if(getFirstNodeChild(pNode->m_pDependency) == pNode)
  127.     {
  128. return TRUE;
  129.     }
  130.     return FALSE;
  131. }
  133. BOOL
  134. CSmil1Parser::hasParParent(SMIL1Node* pNode)
  135. {
  136.     // walk up parent chain until we find a PAR
  137.     BOOL rc = FALSE;
  138.     while(pNode)
  139.     {
  140. pNode = pNode->m_pParent;
  141. if(pNode && pNode->m_tag == SMILPar)
  142. {
  143.     rc = TRUE;
  144.     break;
  145. }
  146.     }
  147.     return rc;
  148. }
  150. SMIL1NodeTag
  151. CSmil1Parser::getSyncTag(SMIL1Node* pNode)
  152. {
  153.     // walk up parent chain until we either find
  154.     // a PAR or a SEQ
  155.     SMIL1NodeTag tag = SMILSeq; // assume a SEQ
  156.     while(pNode)
  157.     {
  158. pNode = pNode->m_pParent;
  159. if(pNode && pNode->m_tag == SMILPar)
  160. {
  161.     tag = SMILPar;
  162.     break;
  163. }
  164. else if(pNode && pNode->m_tag == SMILSeq)
  165. {
  166.     tag = SMILSeq;
  167.     break;
  168. }
  169.     }
  170.     return tag;
  171. }
  173. SMIL1Node*
  174. CSmil1Parser::getSyncParent(SMIL1Node* pNode)
  175. {
  176.     SMIL1Node* pReturnNode = NULL;
  177.     while(pNode)
  178.     {
  179. pNode = pNode->m_pParent;
  180. if(pNode && 
  181.     (pNode->m_tag == SMILPar ||
  182.      pNode->m_tag == SMILSeq))
  183. {
  184.     pReturnNode = pNode;
  185.     break;
  186. }
  187.     }
  188.     return pReturnNode;
  189. }
  191. BOOL
  192. CSmil1Parser::inSeq(SMIL1Node* pNode)
  193. {
  194.     SMIL1NodeTag tag = getSyncTag(pNode);
  195.     return tag == SMILSeq;
  196. }
  198. HX_RESULT
  199. CSmil1Parser::createHeadElements(SMIL1NodeList* pNodeList)
  200. {
  201.     HX_RESULT rc = HXR_OK;
  203.     if(!pNodeList)
  204.     {
  205. return rc;
  206.     }
  208.     CHXSimpleList::Iterator i;
  209.     for(i=pNodeList->Begin();i!=pNodeList->End();++i)
  210.     {
  211. if(HXR_OK != rc)
  212. {
  213.     return rc;
  214. }
  216. SMIL1Node* pNode = (SMIL1Node*)(*i);
  218. if(pNode->m_bDelete) // skip this puppy
  219. {
  220.     continue;
  221. }
  223. rc = addToNamespaceScope(pNode);
  224. if (FAILED(rc))
  225. {
  226.     return rc;
  227. }
  229. switch(pNode->m_tag)
  230. {
  231.     case SMILRegion:
  232.     {
  233. //[SMIL 1.0 compliance] Fixes PR 25798: a region element may
  234. // only be contained inside a layout element:
  235. if (m_bSMIL10FullCompliance  &&  pNode->m_pParent  &&
  236. pNode->m_pParent->m_name.GetLength()  &&
  237. strcmp((const char*)pNode->m_pParent->m_name,
  238. "layout"))
  239. {
  240.     CSmil1SMILSyntaxErrorHandler errHandler(m_pContext);
  241.     errHandler.ReportError(SMILErrorUnexpectedTag,
  242.     (const char*)pNode->m_name,
  243.     pNode->m_ulTagStartLine);
  244.     return HXR_FAIL;
  245. }
  246.     }
  247.     break;
  249.     case SMILMeta:
  250.     {
  251. CSmil1Meta* pMeta = makeMeta(pNode);
  252. if(pMeta)
  253. {
  254.     pNode->m_pElement = pMeta;
  255.     pMeta->m_ulDelay = 0;
  256.     pMeta->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
  257.     insertElementByTimestamp(pMeta);
  258. }
  259. else
  260. {
  261.     return HXR_FAIL;
  262. }
  263.     }
  264.     break;
  266.     case SMILBasicLayout:
  267.     {
  268. const char* pLayoutName = (const char*)pNode->m_id;
  269. BOOL bHasRegions = FALSE;
  270. SMIL1Node* pLayoutNode = pNode->getFirstChild();
  271. while(pLayoutNode && !pLayoutNode->m_bDelete)
  272. {
  273.     switch(pLayoutNode->m_tag)
  274.     {
  275. case SMILRootLayout:
  276. {
  277.     CSmil1RootLayout* pRootLayout = 
  278. makeRootLayout(pLayoutNode);
  279.     if(pRootLayout)
  280.     {
  281. pLayoutNode->m_pElement = pRootLayout;
  282. pRootLayout->m_ulDelay = 0;
  283. pRootLayout->m_ulTimestamp =
  284.     INITIAL_STREAM0_TIMESTAMP;
  285. insertElementByTimestamp(pRootLayout);
  286.     }
  287.     else
  288.     {
  289. return HXR_FAIL;
  290.     }
  291. }
  292. break;
  294. case SMILRegion:
  295. {
  296.     CSmil1Region* pRegion = 
  297. makeRegion(pLayoutNode);
  298.     if(pRegion)
  299.     {
  300. pLayoutNode->m_pElement = pRegion;
  301. bHasRegions = TRUE;
  302. pRegion->m_ulDelay = 0;
  303. pRegion->m_ulTimestamp = 
  304.     INITIAL_STREAM0_TIMESTAMP;
  305. insertElementByTimestamp(pRegion);
  306.     }
  307.     else
  308.     {
  309. return HXR_FAIL;
  310.     }
  311. }
  312. break;
  314. case SMILMeta:
  315. {
  316.     CSmil1Meta* pMeta = makeMeta(pLayoutNode);
  317.     if(pMeta)
  318.     {
  319. pNode->m_pElement = pMeta;
  320. pMeta->m_ulDelay = 0;
  321. pMeta->m_ulTimestamp = 
  322.     INITIAL_STREAM0_TIMESTAMP;
  323. insertElementByTimestamp(pMeta);
  324.     }
  325.     else
  326.     {
  327. return HXR_FAIL;
  328.     }
  329. }
  330. break;
  332. default:
  333. break;
  334.     }
  335.     pLayoutNode = pNode->getNextChild();
  336. }
  337. if(bHasRegions)
  338. {
  339.     // send end-layout packet at TS 0
  340.     m_pEndLayout = new CSmil1EndLayout;
  341.     m_pEndLayout->m_ulDelay = 0;
  342.     m_pEndLayout->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
  343.     insertElementByTimestamp(m_pEndLayout);
  344. }
  345.     }
  346.     break;
  347.     
  348.     case SMILRNRendererList:
  349.     {
  350. SMIL1Node* pRendererNode = pNode->getFirstChild();
  351. while(pRendererNode && 
  352.     pRendererNode->m_tag == SMILRendererPreFetch)
  353. {
  354.     CSmil1RendererPreFetch* pRenderer = 
  355. makeRendererPreFetch(pRendererNode);
  356.     pRendererNode->m_pElement = pRenderer;
  357.     pRenderer->m_ulDelay = 0;
  358.     pRenderer->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
  359.     insertElementByTimestamp(pRenderer);
  361.     pRendererNode = pNode->getNextChild();
  362. }
  363.     }
  364.     break;
  366.     default:
  367.     break;
  368. }
  369. rc = createHeadElements(pNode->m_pNodeList);
  371. if (SUCCEEDED(rc))
  372. {
  373.     rc = removeFromNamespaceScope(pNode);
  374. }
  375.     }
  376.     return rc;
  377. }
  379. HX_RESULT
  380. CSmil1Parser::setInitialDelays(SMIL1NodeList* pNodeList)
  381. {
  382.     HX_RESULT rc = HXR_OK;
  384.     UINT16 nGroup = (UINT16)-1;
  386.     if(!pNodeList)
  387.     {
  388. return rc;
  389.     }
  391.     CHXSimpleList::Iterator i = pNodeList->Begin();
  392.     for(;i!=pNodeList->End();++i)
  393.     {
  394. if(HXR_OK != rc)
  395. {
  396.     return rc;
  397. }
  399. SMIL1Node* pNode = (SMIL1Node*)(*i);
  401. if(pNode->m_bDelete) // skip this puppy
  402. {
  403.     continue;
  404. }
  405. else if(pNode->m_tag == SMILAAnchor ||
  406.         pNode->m_tag == SMILSwitch)
  407. {
  408.     pNode = getTimelineDescendent(pNode);
  409.     if(!pNode)
  410.     {
  411. continue;
  412.     }
  413. }
  415. setInitialDelay(pNode);
  416. switch(pNode->m_tag)
  417. {
  418.     case SMILSeq:
  419.     {
  420. setInitialDelayOnSeq(pNode);
  421.     }
  422.     break;
  423.     case SMILPar:
  424.     {
  425. SMIL1Node* pThisNode =
  426.     getTimelineDescendent(pNode, NULL);
  427. while(pThisNode)
  428. {
  429.     setInitialDelay(pThisNode);
  430.     pThisNode =
  431. getTimelineDescendent(pNode, pThisNode);
  432. }
  433.     }
  434.     break;
  435. }
  436.     }
  437.     return rc;
  438. }
  440. void
  441. CSmil1Parser::setInitialDelay(SMIL1Node* pNode)
  442. {
  443.     if(pNode->m_pElement &&
  444. pNode->m_pElement->m_pTimelineElement &&
  445. !pNode->m_pElement->m_pTimelineElement->initialDelaySet())
  446.     {
  447. pNode->m_pElement->m_pTimelineElement->setDelay(0);
  448.     }
  450.     if(pNode->m_pNodeList)
  451.     {
  452. if(pNode->m_tag == SMILSeq ||
  453.     pNode->m_tag == SMILPar)
  454. {
  455.     if(pNode->m_pElement &&
  456. pNode->m_pElement->m_pTimelineElement &&
  457. pNode->m_pElement->m_ulDuration != (UINT32)-1)
  458.     {
  459. pNode->m_pElement->m_pTimelineElement->setDuration(
  460.     pNode->m_pElement->m_ulDuration);
  461.     }
  462. }
  464. if(pNode->m_tag == SMILSeq)
  465. {
  466.     setInitialDelayOnSeq(pNode);
  467. }
  468. //If the element doesn't exist or it does but the timelineElement
  469. // doesn't exist, or it does but there is no delay event, or there is
  470. // one but the delay is already set, then it's ok to set call
  471. // setInitialDelay():
  472. else if ((!pNode->m_pElement  ||
  473. !pNode->m_pElement->m_pTimelineElement)  ||
  474. //[SMIL 1.0 Compliance] Helps fix PR 14420:
  475. //Don't call this if pNode has an unresolved delay event:
  476. (!pNode->m_pElement->m_pTimelineElement->delayEvent()  ||
  477. pNode->m_pElement->m_pTimelineElement->initialDelaySet() ) )
  478. {
  479.     SMIL1Node* pThisNode = 
  480. getTimelineDescendent(pNode, NULL);
  481.     while(pThisNode)
  482.     {
  483. setInitialDelay(pThisNode);
  484. pThisNode = getTimelineDescendent(pNode, pThisNode);
  485.     }
  486. }
  487.     }
  488. }
  490. void 
  491. CSmil1Parser::setInitialDelayOnSeq(SMIL1Node* pNode)
  492. {
  493.     UINT16 nGroup = (UINT16)-1;
  494.     
  495.     SMIL1Node* pThisNode = getTimelineDescendent(pNode, NULL);
  496.     while(pThisNode)
  497.     {
  498. if(pThisNode->m_nGroup != nGroup)
  499. {
  500.     nGroup = pThisNode->m_nGroup;
  501.     setInitialDelay(pThisNode);
  502. }
  503. pThisNode = getTimelineDescendent(pNode, pThisNode);
  504.     }
  505. }
  507. HX_RESULT
  508. CSmil1Parser::assignGroupIndexes(SMIL1NodeList* pNodeList)
  509. {
  510.     HX_RESULT rc = HXR_OK;
  512.     if(!pNodeList)
  513.     {
  514. return rc;
  515.     }
  517.     UINT16 nGroup = 0;
  518.     CHXSimpleList::Iterator i = pNodeList->Begin();
  519.     for(; i != pNodeList->End(); ++i)
  520.     {
  521. if(HXR_OK != rc)
  522. {
  523.     return rc;
  524. }
  526. SMIL1Node* pNode = (SMIL1Node*)(*i);
  528. if(pNode->m_bDelete) // skip this puppy
  529. {
  530.     continue;
  531. }
  532. else if(pNode->m_tag == SMILAAnchor ||
  533.         pNode->m_tag == SMILSwitch)
  534. {
  535.     pNode = getTimelineDescendent(pNode);
  536.     if(!pNode)
  537.     {
  538. continue;
  539.     }
  540. }
  542. switch(pNode->m_tag)
  543. {
  544.     case SMILSeq:
  545.     {
  546. SMIL1Node* pThisNode =
  547.     getTimelineDescendent(pNode, NULL);
  548. while(pThisNode)
  549. {
  550.     rc = assignGroupIndexOnSeq(pThisNode, nGroup);
  551.     if(HXR_OK == rc)
  552.     {
  553. pThisNode =
  554.     getTimelineDescendent(pNode, pThisNode);
  555. nGroup++;
  556.     }
  557.     else
  558.     {
  559. break;
  560.     }
  561. }
  562.     }
  563.     break;
  565.     case SMILPar:
  566.     {
  567. // top-level par, each child has group 0
  568. SMIL1Node* pThisNode =
  569.     getTimelineDescendent(pNode, NULL);
  570. while(pThisNode)
  571. {
  572.     rc = assignGroupIndexOnPar(pThisNode, nGroup);
  573.     if(HXR_OK == rc)
  574.     {
  575. pThisNode =
  576.     getTimelineDescendent(pNode, pThisNode);
  577.     }
  578.     else
  579.     {
  580. break;
  581.     }
  582. }
  583.     }
  584.     break;
  586.     default:
  587.     break;
  588. }
  589.     }
  591.     return rc;
  592. }
  594. HX_RESULT
  595. CSmil1Parser::assignGroupIndexOnPar(SMIL1Node* pNode,
  596.    UINT16 nGroup)
  597. {
  598.     HX_RESULT rc = HXR_OK;
  600.     if(pNode->m_bDelete)
  601.     {
  602. return rc;
  603.     }
  605.     pNode->m_nGroup = nGroup;
  606.     pNode->m_repeatid.AppendULONG(nGroup);
  608.     if (isMediaObject(pNode))
  609.     {
  610. addGroup(pNode);
  611.     }
  612.     else if (SMILSeq == pNode->m_tag ||
  613.      SMILPar == pNode->m_tag)
  614.     {
  615. // top-level par, each child has group 0
  616. SMIL1Node* pThisNode =
  617.     getTimelineDescendent(pNode, NULL);
  618. while(pThisNode)
  619. {
  620.     rc = assignGroupIndexOnPar(pThisNode, nGroup);
  621.     if(HXR_OK == rc)
  622.     {
  623. pThisNode =
  624.     getTimelineDescendent(pNode, pThisNode);
  625.     }
  626.     else
  627.     {
  628. break;
  629.     }
  630. }
  631.     }
  633.     return rc;
  634. }
  636. HX_RESULT
  637. CSmil1Parser::assignGroupIndexOnSeq(SMIL1Node* pNode,
  638.    UINT16& nGroup)
  639. {
  640.     HX_RESULT rc = HXR_OK;
  642.     if(pNode->m_bDelete)
  643.     {
  644. return rc;
  645.     }
  647.     pNode->m_nGroup = nGroup;
  648.     pNode->m_repeatid.AppendULONG(nGroup);
  650.     if (isMediaObject(pNode))
  651.     {
  652. addGroup(pNode);
  653.     }
  654.     else if (SMILSeq == pNode->m_tag)
  655.     {
  656. SMIL1Node* pThisNode =
  657.     getTimelineDescendent(pNode, NULL);
  658. while(pThisNode)
  659. {
  660.     rc = assignGroupIndexOnSeq(pThisNode, nGroup);
  661.     if(HXR_OK == rc)
  662.     {
  663. pThisNode = getTimelineDescendent(pNode, pThisNode);
  664. if (pThisNode)
  665. {
  666.     if (isMediaObject(pThisNode)    ||
  667. SMILSeq == pThisNode->m_tag ||
  668. SMILPar == pThisNode->m_tag)
  669.     {
  670. nGroup++;
  671.     }
  672. }
  673.     }
  674.     else
  675.     {
  676. break;
  677.     }
  678. }
  679.     }
  680.     else if (SMILPar == pNode->m_tag)
  681.     {
  682. SMIL1Node* pThisNode =
  683.     getTimelineDescendent(pNode, NULL);
  684. while(pThisNode)
  685. {
  686.     rc = assignGroupIndexOnPar(pThisNode, nGroup);
  687.     if(HXR_OK == rc)
  688.     {
  689. pThisNode =
  690.     getTimelineDescendent(pNode, pThisNode);
  691.     }
  692.     else
  693.     {
  694. break;
  695.     }
  696. }
  697.     }
  699.     return rc;
  700. }
  702. BOOL 
  703. CSmil1Parser::isMediaObject(SMIL1Node* pNode)
  704. {
  705.     BOOL bResult = FALSE;
  707.     if (NULL == pNode || pNode->m_bDelete)
  708.     {
  709. goto cleanup;
  710.     }
  712.     switch(pNode->m_tag)
  713.     {
  714. case SMILRef:
  715. case SMILText:
  716. case SMILImg:
  717. case SMILAudio:
  718. case SMILVideo:
  719. case SMILAnimation:
  720. case SMILTextstream:
  721. {
  722.     bResult = TRUE;
  723. }
  724. break;
  726. default:
  727. break;
  728.     }
  730. cleanup:
  732.     return bResult;
  733. }
  735. HX_RESULT
  736. CSmil1Parser::addGroup(SMIL1Node* pNode)
  737. {
  738.     HX_RESULT rc = HXR_OK;
  740.     // set group info information
  741.     CSmil1AddGroup* pAddGroup = 0;
  742.     if(m_pAddGroupMap->Lookup(pNode->m_nGroup, (void*&)pAddGroup))
  743.     {
  744. // we don't count self-replicated elements as they
  745. // share the same track ID
  746. if (pNode->m_repeatTag == RepeatUnknown)
  747. {
  748.     pAddGroup->m_nTotalTracks++;
  749.     if(pNode->m_pElement &&
  750.        pNode->m_pElement->m_ulDelay == 0)
  751.     {
  752. pAddGroup->m_nInitTracks++;
  753.     }
  754. }
  755.     }
  756.     else
  757.     {
  758. CSmil1AddGroup* pAddGroup = new CSmil1AddGroup;
  759. pAddGroup->m_nGroup = pNode->m_nGroup;
  761. // reference PAR properties in group
  762. if(pNode->m_pDependency &&
  763.    pNode->m_pDependency->m_tag == SMILPar &&
  764.    hasParParent(pNode))
  765. {
  766.     IHXValues* pValues = pNode->m_pDependency->m_pValues;
  767.     if(pValues)
  768.     {
  769. pAddGroup->m_pValues = pValues;
  770. pAddGroup->m_pValues->AddRef();
  771.     }
  772.     pAddGroup->m_ulDuration = 
  773. pNode->m_pDependency->m_pElement->m_ulDuration;
  774. }
  776. // XXXJHUG  -- If the group is from a Seq, we still want
  777. // to pass along the Title, author, copyright & abstract from
  778. // the dependant parrent sequence group.
  779. if (pNode->m_pDependency &&
  780.     pNode->m_pDependency->m_tag == SMILSeq)
  781. {
  782.     IHXValues* pValues = pNode->m_pDependency->m_pValues;
  783.     if(pValues)
  784.     {
  785. // XXXJH should use CCF
  786. pAddGroup->m_pValues = new CHXHeader();
  787. IHXBuffer* pBuf = NULL;
  788. const char* name = NULL;
  789. pAddGroup->m_pValues->AddRef();
  790. if (SUCCEEDED(pValues->GetFirstPropertyCString(name, pBuf)))
  791. {
  792.     do
  793.     {
  794. if (strcmp("title",name)==0 ||
  795.     strcmp("author",name)==0 ||
  796.     strcmp("abstract",name)==0 ||
  797.     strcmp("copyright",name)==0)
  798. {
  799.     pAddGroup->m_pValues->SetPropertyCString(name, pBuf);
  800. }
  801. HX_RELEASE(pBuf);
  802.     }
  803.     while(SUCCEEDED(pValues->GetNextPropertyCString(name, pBuf)));
  804. }
  805.     }
  806.     // the duration for a sequence is dependant on the elements
  807.     // within the sequence.
  808. }
  810. (*m_pAddGroupMap)[pNode->m_nGroup] = pAddGroup;
  811. pAddGroup->m_nTotalTracks = 1;
  812. if(pNode->m_pElement &&
  813.     pNode->m_pElement->m_ulDelay == 0)
  814. {
  815.     pAddGroup->m_nInitTracks = 1;
  816. }
  817.     }
  818.     return rc;
  819. }
  821. HX_RESULT
  822. CSmil1Parser::createBodyElements(SMIL1NodeList* pNodeList)
  823. {
  824.     HX_RESULT rc = HXR_OK;
  826.     if(!pNodeList)
  827.     {
  828. return rc;
  829.     }
  831.     if(!m_pNodeDependencies)
  832.     {
  833. m_pNodeDependencies = new CHXStack;
  834.     }
  836.     if(!m_pAnchorStack)
  837.     {
  838. m_pAnchorStack = new CHXStack;
  839.     }
  841.     if(!m_pTrackHintList)
  842.     {
  843. m_pTrackHintList = new CHXSimpleList;
  844.     }
  846.     UINT32 ulTrackHint = 1;
  848.     CHXSimpleList::Iterator i;
  849.     for(i=pNodeList->Begin();i!=pNodeList->End();++i)
  850.     {
  851. if(HXR_OK != rc)
  852. {
  853.     return rc;
  854. }
  856. SMIL1Node* pNode = (SMIL1Node*)(*i);
  858. if(pNode->m_bDelete) // skip this puppy
  859. {
  860.     continue;
  861. }
  863. rc = addToNamespaceScope(pNode);
  864. if (FAILED(rc))
  865. {
  866.     return rc;
  867. }
  869. switch(pNode->m_tag)
  870. {
  871.     case SMILSeq:
  872.     {
  873. CSmil1SeqElement* pElement = makeSeqElement(pNode);
  874. if(!pElement)
  875. {
  876.     return HXR_FAIL;
  877. }
  878. pNode->m_pElement = pElement;
  880. CSmil1TimelineSeq* pTimelineSeq =
  881.     new CSmil1TimelineSeq(pElement, this);
  883. pElement->m_pTimelineElement = pTimelineSeq;
  885. if(!m_pCurrentDependentNode) // at the top
  886. {
  887.     //pNode->m_nGroup = (UINT16)-1;   // top level
  888. }
  889. else
  890. {
  891.     pNode->m_pDependency = m_pCurrentDependentNode;
  893.     if(!hasParParent(pNode))
  894.     {
  895. //pNode->m_nGroup = 
  896. //    m_pCurrentDependentNode->m_nGroup + 1;
  897.     }
  898.     else
  899.     {
  900. //pNode->m_nGroup = 
  901. //    m_pCurrentDependentNode->m_nGroup;
  902.     }
  903. }
  904. m_pCurrentDependentNode = pNode;
  905. m_pNodeDependencies->Push(m_pCurrentDependentNode);
  907. ulTrackHint = 1;
  908. m_pTrackHintList->AddTail((void*)ulTrackHint);
  909.     }
  910.     break;
  912.     case SMILPar:
  913.     {
  914. CSmil1ParElement* pElement = makeParElement(pNode);
  915. if(!pElement)
  916. {
  917.     return HXR_FAIL;
  918. }
  919. pNode->m_pElement = pElement;
  920. CSmil1TimelinePar* pTimelinePar = 
  921.     new CSmil1TimelinePar(pElement, this);
  922. pElement->m_pTimelineElement = pTimelinePar;
  924. if(!m_pCurrentDependentNode) // at the top
  925. {
  926.     // pNode->m_nGroup = 0;
  927. }
  928. else
  929. {
  930.     pNode->m_pDependency = m_pCurrentDependentNode;
  931.     if(!hasParParent(pNode))
  932.     {
  933. //pNode->m_nGroup = 
  934. //    m_pCurrentDependentNode->m_nGroup + 1;
  935.     }
  936.     else
  937.     {
  938. //pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
  939.     }
  940. }
  941. if(firstDependentChild(pNode) || m_pCurrentDependentNode == 0)
  942. {
  943.     ulTrackHint = 1;
  944.     m_pTrackHintList->AddTail((void*)ulTrackHint);
  945. }
  946. else
  947. {
  948.     if(m_pTrackHintList->GetCount() > 0)
  949.     {
  950. ulTrackHint = (UINT32)m_pTrackHintList->RemoveTail();
  951.     }
  952.     m_pTrackHintList->AddTail((void*)++ulTrackHint);
  953. }
  955. m_pCurrentDependentNode = pNode;
  956. m_pNodeDependencies->Push(m_pCurrentDependentNode);
  958.     }
  959.     break;
  961.     case SMILEndSeq:
  962.     {
  963. m_pCurrentDependentNode = 
  964.     (SMIL1Node*)m_pNodeDependencies->Pop();
  966. if(m_pTrackHintList->GetCount() > 0)
  967. {
  968.     m_pTrackHintList->RemoveTail();
  969. }
  970.     }
  971.     break;
  973.     case SMILEndPar:
  974.     {
  975. m_pCurrentDependentNode = 
  976.     (SMIL1Node*)m_pNodeDependencies->Pop();
  978. if(m_pTrackHintList->GetCount() > 0)
  979. {
  980.     m_pTrackHintList->RemoveTail();
  981. }
  982.     }
  983.     break;
  985.     case SMILAAnchor:
  986.     {
  987. CSmil1AAnchorElement* pElement = makeAAnchorElement(pNode);
  988. if(pElement)
  989. {
  990.     pNode->m_pElement = pElement;
  991.     m_pAnchorStack->Push(m_pCurrentAnchor);
  992.     m_pCurrentAnchor = pElement;
  993. }
  994.     }
  995.     break;
  997.     case SMILEndAAnchor:
  998.     {
  999. m_pCurrentAnchor = (CSmil1AAnchorElement*)m_pAnchorStack->Pop();
  1000.     }
  1001.     break;
  1003.     case SMILAnchor:
  1004.     {
  1005. CSmil1AnchorElement* pElement = makeAnchorElement(pNode);
  1006. if(pElement)
  1007. {
  1008.     pNode->m_pElement = pElement;
  1010.     //[SMIL 1.0 compliance] Helps fix PR 26471:
  1011.     // In order to get a notification that we have a resolved
  1012.     // event-based begin time, we need to be a
  1013.     // timeline element:
  1014.     CSmil1TimelineAnchor* pTimelineAnchor = 
  1015. new CSmil1TimelineAnchor(pElement, this);
  1016.     pElement->m_pTimelineElement = pTimelineAnchor;
  1018.     // add link to parent
  1019.     SMIL1Node* pParent = pNode->m_pParent;
  1020.     if(pParent->m_pElement)
  1021.     {
  1022. pParent->m_pElement->m_pHyperlinks->AddTail(pElement);
  1023.     }
  1025.     if(!m_pCurrentDependentNode)
  1026.     { 
  1027. //anchor should NEVER be top element:
  1028. HX_ASSERT(m_pCurrentDependentNode);
  1029.     } 
  1030.     else 
  1031.     { 
  1032. pNode->m_pDependency = m_pCurrentDependentNode;
  1033.     } 
  1034.     if(firstDependentChild(pNode) || m_pCurrentDependentNode == 0)
  1035.     { 
  1036. ulTrackHint = 1;
  1037. m_pTrackHintList->AddTail((void*)ulTrackHint);
  1038.     } 
  1039.     else 
  1040.     { 
  1041. if(m_pTrackHintList->GetCount() > 0)
  1042. {
  1043.     ulTrackHint = (UINT32)m_pTrackHintList->RemoveTail();
  1044. }
  1045. m_pTrackHintList->AddTail((void*)++ulTrackHint);
  1046.     } 
  1047.     m_pCurrentDependentNode = pNode;
  1048.     m_pNodeDependencies->Push(m_pCurrentDependentNode);
  1049.     //end of part of fix for PR 26471.
  1050. }
  1051.     }
  1052.     break;
  1054.     case SMILRef:
  1055.     case SMILText:
  1056.     case SMILImg:
  1057.     case SMILAudio:
  1058.     case SMILVideo:
  1059.     case SMILAnimation:
  1060.     case SMILTextstream:
  1061.     {
  1062. CSmil1Source* pSource = makeSource(pNode);
  1063. if(!pSource)
  1064. {
  1065.     return HXR_FAIL;
  1066. }
  1067. m_bContainsSource = TRUE;
  1068. pNode->m_pElement = pSource;
  1070. CSmil1TimelineElement* pTimelineElement = 
  1071.     new CSmil1TimelineElement(pSource, this);
  1073. pNode->m_pElement->m_pTimelineElement = pTimelineElement;
  1075. // attach any links
  1076. if(m_pCurrentAnchor)
  1077. {
  1078.     pSource->m_pHyperlinks->AddTail(m_pCurrentAnchor);
  1079. }
  1081. if(!m_pCurrentDependentNode)
  1082. {
  1083.     // make it behave like it's in a SEQ
  1084.     pNode->m_pDependency = 0;
  1085.     //pNode->m_nGroup = 0;
  1086.     m_pCurrentDependentNode = pNode;
  1087.     ulTrackHint = 1;
  1088.     m_pTrackHintList->AddTail((void*)ulTrackHint);
  1089. }
  1090. else
  1091. {
  1092.     pNode->m_pDependency = m_pCurrentDependentNode;
  1094.     if(inSeq(pNode))
  1095.     {
  1096. if(firstDependentChild(pNode))
  1097. {
  1098.     ulTrackHint = 1;
  1099.     m_pTrackHintList->AddTail((void*)ulTrackHint);
  1100. }
  1101. else
  1102. {
  1103.     if(m_pTrackHintList->GetCount() > 0)
  1104.     {
  1105. ulTrackHint = 
  1106.     (UINT32)m_pTrackHintList->RemoveTail();
  1107.     }
  1108.     m_pTrackHintList->AddTail((void*)++ulTrackHint);
  1109. }
  1110.     }
  1111.     else
  1112.     {
  1113. if(firstDependentChild(pNode))
  1114. {
  1115.     ulTrackHint = 1;
  1116.     m_pTrackHintList->AddTail((void*)ulTrackHint);
  1117. }
  1118.     }
  1120.     if(inSeq(pNode) && !hasParParent(pNode))
  1121.     {
  1122. if(firstDependentChild(pNode))
  1123. {
  1124.     //pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
  1125. }
  1126. else
  1127. {
  1128.     //pNode->m_nGroup = 
  1129. //m_pCurrentDependentNode->m_nGroup + 1;
  1130. }
  1131. m_pCurrentDependentNode = pNode;
  1132.     }
  1133.     else if(inSeq(pNode))
  1134.     {
  1135. //pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
  1136. m_pCurrentDependentNode = pNode;
  1137.     }
  1138.     else // in PAR
  1139.     {
  1140. // pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
  1141.     }
  1142. }
  1144. // set track hint info
  1145. BOOL bFirstHint = TRUE;
  1146. CHXSimpleList::Iterator hintIter = m_pTrackHintList->Begin();
  1147. for(; hintIter != m_pTrackHintList->End(); ++hintIter)
  1148. {
  1149.     char tmpBuf[20]; /* Flawfinder: ignore */
  1151.     UINT32 ulTrackHint = (UINT32)(*hintIter);
  1152.     if(bFirstHint)
  1153.     {
  1154. sprintf(tmpBuf, "%d", ulTrackHint); /* Flawfinder: ignore */
  1155. bFirstHint = FALSE;
  1156.     }
  1157.     else
  1158.     {
  1159. sprintf(tmpBuf, ".%d", ulTrackHint); /* Flawfinder: ignore */
  1160.     }
  1161.     pNode->m_trackHint += tmpBuf;
  1162. }
  1163.     }
  1164.     break;
  1166.     default:
  1167.     break;
  1168. }
  1169. rc = createBodyElements(pNode->m_pNodeList);
  1171. if (SUCCEEDED(rc))
  1172. {
  1173.     rc = removeFromNamespaceScope(pNode);
  1174. }
  1175.     }
  1176.     return rc;
  1177. }
  1179. HX_RESULT
  1180. CSmil1Parser::expandRepeatElements(SMIL1NodeList* pNodeList)
  1181. {
  1182.     // walk through tree and expand any "repeat" attributes
  1183.     
  1184.     HX_RESULT rc = HXR_OK;
  1185.     if(!pNodeList)
  1186.     {
  1187. return rc;
  1188.     }
  1190.     LISTPOSITION lPos = pNodeList->GetHeadPosition();
  1191.     while (lPos && HXR_OK == rc)
  1192.     {
  1193. SMIL1Node* pNode = (SMIL1Node*)pNodeList->GetAt(lPos);
  1195. if(pNode->m_bDelete) // skip this puppy
  1196. {
  1197.     pNodeList->GetNext(lPos);
  1198.     continue;
  1199. }
  1201. if(pNode->m_pValues)
  1202. {
  1203.     const char* pName = 0;
  1204.     IHXBuffer* pBuf = 0;
  1206.     if (!pNode->m_bRepeatHandled &&
  1207. HXR_OK == pNode->m_pValues->GetPropertyCString("repeat", pBuf))
  1208.     {
  1209. BOOL     bRepeatIndefinite = FALSE;
  1210. const char* pRepeatCount = (const char*)pBuf->GetBuffer();
  1211. if(pRepeatCount)
  1212. {
  1213.     INT32 lRepeatCount = 0;
  1215.     if(strcmp(pRepeatCount, "indefinite") == 0)
  1216.     {
  1217. bRepeatIndefinite = TRUE;
  1218. lRepeatCount = 2;
  1219.     }
  1220.     else
  1221.     {
  1222. lRepeatCount = atol(pRepeatCount);
  1223.     }
  1225.     if(lRepeatCount == 0)
  1226.     {
  1227. pNode->m_bDelete = TRUE;
  1228.     }
  1229.     else if(lRepeatCount > 1)
  1230.     {
  1231. // build a <seq>/</seq> around the repeated element...
  1232. SMIL1Node* pSeqNode = NULL;
  1233. SMIL1Node* pSeqEndNode = NULL;
  1235. createParent(pNode, SMILSeq, pSeqNode, pSeqEndNode);
  1237. SMIL1Node* pNodeCopy = NULL;
  1238. BOOL   bOverWrite = TRUE;
  1239. for(INT32 lCount = 0; lCount < lRepeatCount;
  1240.     ++lCount)
  1241. {
  1242.     // we want to keep the original ids for the
  1243.     // 1st repeat so that we don't break any links
  1244.     if (0 == lCount)
  1245.     {
  1246. pNodeCopy = new SMIL1Node(*pNode, TRUE, this);
  1247. bOverWrite = TRUE;
  1248.     }
  1249.     else
  1250.     {
  1251. pNodeCopy = new SMIL1Node(*pNode, FALSE, this);
  1252. bOverWrite = FALSE;
  1253.     }
  1255.     pNodeCopy->m_pParent = pSeqNode;
  1256.     pNodeCopy->m_pNodeList->m_pParentNode = pNodeCopy;
  1257.     pNodeCopy->m_bRepeatHandled = TRUE;
  1259.     // after the 1st repeat, mark the rest of repeats
  1260.     // as replica(used in counting tracks etc.)
  1261.     if (lCount > 0)
  1262.     {
  1263. if (bRepeatIndefinite)
  1264. {
  1265.     if (pNodeCopy->m_tag == SMILSeq ||
  1266. pNodeCopy->m_tag == SMILPar)
  1267.     {
  1268. // set indefinite repeat tag on seq
  1269. // will be used in constructing timeline elements
  1270. pSeqNode->m_repeatTag = RepeatIndefiniteOnMe;
  1271. pNodeCopy->m_repeatTag = RepeatIndefiniteOnGroup;
  1272. markRepeatReplica(pNodeCopy->m_pNodeList, RepeatIndefiniteOnGroup);
  1273.     }
  1274.     else
  1275.     {
  1276. pNodeCopy->m_repeatTag = RepeatIndefiniteOnMe;
  1277.     }
  1278. }
  1279. else
  1280. {
  1281.     pNodeCopy->m_repeatTag = RepeatReplica;
  1282.     
  1283.     if (pNodeCopy->m_tag == SMILSeq ||
  1284. pNodeCopy->m_tag == SMILPar)
  1285.     {
  1286. markRepeatReplica(pNodeCopy->m_pNodeList, RepeatReplica);
  1287.     }
  1288. }
  1289.     }
  1291.     mapID(pNodeCopy, bOverWrite);
  1292.     //Fix for PR 13119: internal elements (source
  1293.     // elements, especially) of a repeated <seq> or
  1294.     // <par> tag were not getting mapped and thus
  1295.     // never played, so we need to map the IDs of
  1296.     // all in the m_pNodeList of the pNodeCopy:
  1297.     mapChildrenIDs(pNodeCopy->m_pNodeList, bOverWrite);
  1299.     pSeqNode->m_pNodeList->AddTail(pNodeCopy);
  1300. }
  1301. pSeqNode->m_pNodeList->AddTail(pSeqEndNode);
  1303. // special case to ensure all repeated elements
  1304. // are within the same group(share the same timeline)
  1305. if (!hasParParent(pSeqNode))
  1306. {
  1307.     SMIL1Node* pParNode = NULL;
  1308.     SMIL1Node* pParEndNode = NULL;
  1310.     createParent(pSeqNode, SMILPar, pParNode, pParEndNode);
  1312.     pParNode->m_repeatTag = pSeqNode->m_repeatTag;
  1313.     pParNode->m_pNodeList->AddTail(pSeqNode);     
  1314.     pParNode->m_pNodeList->AddTail(pParEndNode);
  1316.     // now add the list to the parent...
  1317.     pNodeList->InsertBefore(lPos, pParNode);
  1318.     pNode->m_bDelete = TRUE; // delete original node
  1319.     pNode = pParNode;
  1320. }
  1321. else
  1322. {
  1323.     // now add the list to the parent...
  1324.     pNodeList->InsertBefore(lPos, pSeqNode);
  1325.     pNode->m_bDelete = TRUE; // delete original node
  1326.     pNode = pSeqNode;
  1327. }
  1328.     }
  1329. }
  1330.     }
  1331. }
  1332. // breadth first
  1333. rc = expandRepeatElements(pNode->m_pNodeList);
  1334. pNodeList->GetNext(lPos);
  1335.     }
  1336.     return rc;
  1337. }
  1339. HX_RESULT
  1340. CSmil1Parser::createParent (SMIL1Node* pChildNode, 
  1341.    SMIL1NodeTag tag,
  1342.    SMIL1Node*& pParent,
  1343.    SMIL1Node*& pParentEnd)
  1344. {
  1345.     HX_RESULT hr = HXR_OK;
  1347.     pParent = NULL;
  1348.     pParentEnd = NULL;
  1350.     if (!pChildNode)
  1351.     {
  1352. hr = HXR_FAILED;
  1353. goto cleanup;
  1354.     }
  1356.     pParent = new SMIL1Node;     
  1357.     pParent->m_pParent = pChildNode->m_pParent;
  1358.     pParent->m_tag = tag;
  1359.     
  1360.     pParent->m_pNodeList = new SMIL1NodeList;
  1361.     pParent->m_pNodeList->m_pParentNode = pParent;
  1362.     
  1363.     pParentEnd = new SMIL1Node;
  1364.     pParentEnd->m_pParent = pParent;
  1366.     if (SMILPar == tag)
  1367.     {
  1368. pParent->m_name = "par";
  1369. pParentEnd->m_name = "par";
  1370. pParentEnd->m_id = assignID("CLOSE-par");
  1371. pParentEnd->m_tag = SMILEndPar;
  1372.     }
  1373.     else if (SMILSeq == tag)
  1374.     {
  1375. pParent->m_name = "seq";
  1376. pParentEnd->m_name = "seq";
  1377. pParentEnd->m_id = assignID("CLOSE-seq");
  1378. pParentEnd->m_tag = SMILEndSeq;
  1379.     }
  1380.     else
  1381.     {
  1382. HX_ASSERT(FALSE);
  1383. hr = HXR_FAILED;
  1384. goto cleanup;
  1385.     }
  1386.     
  1387.     mapID(pParent, TRUE);
  1388.     mapID(pParentEnd, TRUE);
  1390. cleanup:
  1392.     return hr;
  1393. }
  1395. void
  1396. CSmil1Parser::resetTimeline()
  1397. {
  1398.     if (m_pTimelineElementManager)
  1399.     {
  1400.         m_pTimelineElementManager->resetTimeline();
  1401.     }
  1402. }
  1404. SMIL1Node*
  1405. CSmil1Parser::getTimelineDescendent(SMIL1Node* pParentNode)
  1406. {
  1407.     SMIL1Node* pDescendentNode = NULL;
  1409.     CHXSimpleList* pNodeList = pParentNode->m_pNodeList;
  1410.     if(!pNodeList)
  1411.     {
  1412. return pDescendentNode;
  1413.     }
  1415.     CHXSimpleList::Iterator i;
  1416.     for(i=pNodeList->Begin();i!=pNodeList->End();++i)
  1417.     {
  1418. SMIL1Node* pNode = (SMIL1Node*)(*i);
  1419. if(pNode->m_bDelete)
  1420. {
  1421.     continue;
  1422. }
  1423. if(pNode->m_tag == SMILAAnchor ||
  1424.    pNode->m_tag == SMILSwitch)
  1425. {
  1426.     pNode = getTimelineDescendent(pNode);
  1427.     if(pNode)
  1428.     {
  1429. pDescendentNode = pNode;
  1430. break;
  1431.     }
  1432. }
  1433. else
  1434. {
  1435.     if(pNode->m_tag == SMILSeq ||
  1436. pNode->m_tag == SMILPar ||
  1437. pNode->m_tag == SMILRef ||
  1438. pNode->m_tag == SMILText ||
  1439. pNode->m_tag == SMILImg ||
  1440. pNode->m_tag == SMILAudio ||
  1441. pNode->m_tag == SMILVideo ||
  1442. pNode->m_tag == SMILAnimation ||
  1443. pNode->m_tag == SMILTextstream ||
  1444. pNode->m_tag == SMILAnchor)
  1445.     {
  1446. pDescendentNode = pNode;
  1447. break;
  1448.     }
  1449. }
  1450.     }
  1451.     return pDescendentNode;
  1452. }
  1454. SMIL1Node*
  1455. CSmil1Parser::getTimelineDescendent(SMIL1Node* pParentNode, SMIL1Node* pSiblingNode)
  1456. {
  1457.     SMIL1Node* pFirstDescendent = getTimelineDescendent(pParentNode);
  1458.     if(!pSiblingNode)
  1459.     {
  1460. return pFirstDescendent;
  1461.     }
  1463.     // first, find parent of sibling
  1464.     SMIL1Node* pSiblingParent = pSiblingNode->m_pParent;
  1465.     while(pSiblingParent &&
  1466.   pSiblingParent->m_tag != SMILSeq &&
  1467.   pSiblingParent->m_tag != SMILPar)
  1468.     {
  1469. pSiblingParent = pSiblingParent->m_pParent;
  1470.     }
  1472.     if(!pSiblingParent)
  1473.     {
  1474. return NULL;
  1475.     }
  1477.     // now find the sibling, then next sibling will be 
  1478.     // returned. Brain damaged, but what are ya gonna do?
  1479.     BOOL bFoundSibling = FALSE;
  1480.     SMIL1Node* pNewSibling = NULL;
  1481.     CHXSimpleList::Iterator i = pSiblingParent->m_pNodeList->Begin();
  1482.     for(; i != pSiblingParent->m_pNodeList->End() && !pNewSibling; ++i)
  1483.     {
  1484. SMIL1Node* pThisNode = (SMIL1Node*)(*i);
  1486. if(pThisNode->m_bDelete)
  1487. {
  1488.     continue;
  1489. }
  1491. if(pThisNode->m_tag == SMILAAnchor ||
  1492.     pThisNode->m_tag == SMILSwitch)
  1493. {
  1494.     CHXSimpleList::Iterator j = pThisNode->m_pNodeList->Begin();
  1496.     for(; j != pThisNode->m_pNodeList->End(); ++j)
  1497.     {
  1498. SMIL1Node* pChildNode = (SMIL1Node*)(*j);
  1499. if(pChildNode->m_bDelete)
  1500. {
  1501.     continue;
  1502. }
  1503. if(pChildNode == pSiblingNode)
  1504. {
  1505.     bFoundSibling = TRUE;
  1506.     break;
  1507. }
  1508. else if(bFoundSibling)
  1509. {
  1510.     pNewSibling = pChildNode;
  1511.     break;
  1512. }
  1513.     }
  1514. }
  1515. else
  1516. {
  1517.     if(pThisNode == pSiblingNode)
  1518.     {
  1519. bFoundSibling = TRUE;
  1520.     }
  1521.     else if(bFoundSibling)
  1522.     {
  1523. pNewSibling = pThisNode;
  1524. break;
  1525.     }
  1526. }
  1527.     }
  1529.     return pNewSibling;
  1530. }
  1532. HX_RESULT
  1533. CSmil1Parser::constructTimelineElements(SMIL1NodeList* pNodeList)
  1534. {
  1535.     HX_RESULT rc = HXR_OK;
  1537.     if(!pNodeList)
  1538.     {
  1539. return rc;
  1540.     }
  1542.     CHXSimpleList::Iterator i;
  1543.     for(i=pNodeList->Begin();i!=pNodeList->End();++i)
  1544.     {
  1545. if(HXR_OK != rc)
  1546. {
  1547.     return rc;
  1548. }
  1550. SMIL1Node* pNode = (SMIL1Node*)(*i);
  1552. if(pNode->m_bDelete) // skip this puppy
  1553. {
  1554.     continue;
  1555. }
  1557. switch(pNode->m_tag)
  1558. {
  1559.     case SMILSeq:
  1560.     {
  1561. SMIL1Node* pChildNode = getTimelineDescendent(pNode, NULL);
  1562. CSmil1TimelineElement* pPrevElement = NULL;
  1563. UINT16 uPrevGroup = (UINT16)-1;
  1564. while(pChildNode)
  1565. {
  1566.     if (pChildNode->m_pElement &&
  1567. pChildNode->m_pElement->m_pTimelineElement)
  1568.     {
  1569. pNode->m_pElement->m_pTimelineElement->addChild(
  1570. pChildNode->m_pElement->m_pTimelineElement);
  1572. if(pPrevElement &&
  1573.    uPrevGroup == pChildNode->m_nGroup)
  1574. {
  1575.     pPrevElement->setDependent(pChildNode->m_pElement->m_pTimelineElement);
  1576. }
  1578. pPrevElement = pChildNode->m_pElement->m_pTimelineElement;
  1579. uPrevGroup = pChildNode->m_nGroup;
  1580.     }
  1582.     // there is no dependent on pChildNode which would repeat 
  1583.     // itself indefinitely within the same seq
  1584.     if (pChildNode->m_repeatTag == RepeatIndefiniteOnMe)
  1585.     {
  1586. break;
  1587.     }
  1588.     
  1589.     pChildNode = getTimelineDescendent(pNode, pChildNode);
  1590. }
  1591.     }
  1592.     break;
  1594.     case SMILPar:
  1595.     {
  1596. SMIL1Node* pChildNode = getTimelineDescendent(pNode, NULL);
  1597. while(pChildNode)
  1598. {
  1599.     if(pChildNode->m_pElement &&
  1600.        pChildNode->m_pElement->m_pTimelineElement)
  1601.     {
  1602. pNode->m_pElement->m_pTimelineElement->addChild(
  1603.     pChildNode->m_pElement->m_pTimelineElement);
  1604.     }
  1606.     pChildNode = getTimelineDescendent(pNode, pChildNode);
  1607. }
  1608.     }
  1609.     break;
  1611.     default:
  1612.     break;
  1613. }
  1614. rc = constructTimelineElements(pNode->m_pNodeList);
  1615.     }
  1616.     return rc;
  1617. }
  1619. HX_RESULT
  1620. CSmil1Parser::handleNextElement(CSmil1ElementHandler* pHandler)
  1621. {
  1622.     HX_RESULT rc = HXR_OK;
  1623.     if(m_pPacketQueue->GetCount() > 0)
  1624.     {
  1625. CSmil1Element* pElement = (CSmil1Element*)m_pPacketQueue->RemoveHead();
  1626. pElement->m_pHandler = pHandler;
  1627. rc = pElement->handleElement();
  1628.     }
  1629.     else if(m_bTimestampsResolved)
  1630.     {
  1631. rc = HXR_STREAM_DONE;
  1632.     }
  1633.     else
  1634.     {
  1635. rc = HXR_NO_DATA;
  1636.     }
  1638.     return rc;
  1639. }
  1641. void
  1642. CSmil1Parser::initTagAttributes()
  1643. {
  1644.     if(!m_pTagAttributeMap)
  1645.     {
  1646. m_pTagAttributeMap = new CHXMapLongToObj;
  1647.     }
  1648.     CHXMapStringToOb* pStringMap = 0;
  1650.     // SMILSmil
  1651.     pStringMap = new CHXMapStringToOb;
  1652.     (*pStringMap)["id"] = 0;
  1653.     (*m_pTagAttributeMap)[SMILSmil] = pStringMap;
  1655.     // SMILHead
  1656.     pStringMap = new CHXMapStringToOb;
  1657.     (*pStringMap)["id"] = 0;
  1658.     (*m_pTagAttributeMap)[SMILHead] = pStringMap;
  1660.     // SMILBasicLayout
  1661.     pStringMap = new CHXMapStringToOb;
  1662.     (*pStringMap)["id"] = 0;
  1663.     (*pStringMap)["type"] = 0;
  1664.     (*m_pTagAttributeMap)[SMILBasicLayout] = pStringMap;
  1666.     // SMILRegion
  1667.     pStringMap = new CHXMapStringToOb;
  1668.     (*pStringMap)["id"] = 0;
  1669.     (*pStringMap)["title"] = 0;
  1670.     (*pStringMap)["height"] = 0;
  1671.     (*pStringMap)["width"] = 0;
  1672.     (*pStringMap)["background-color"] = 0;
  1673.     (*pStringMap)["left"] = 0;
  1674.     (*pStringMap)["top"] = 0;
  1675.     (*pStringMap)["z-index"] = 0;
  1676.     (*pStringMap)["fit"] = 0;
  1677.     (*pStringMap)["skip-content"] = 0;
  1678.     (*m_pTagAttributeMap)[SMILRegion] = pStringMap;
  1680.     // SMILRootLayout
  1681.     pStringMap = new CHXMapStringToOb;
  1682.     (*pStringMap)["id"] = 0;
  1683.     (*pStringMap)["title"] = 0;
  1684.     (*pStringMap)["height"] = 0;
  1685.     (*pStringMap)["width"] = 0;
  1686.     (*pStringMap)["background-color"] = 0;
  1687.     (*pStringMap)["overflow"] = 0;
  1688.     (*pStringMap)["skip-content"] = 0;
  1689.     (*m_pTagAttributeMap)[SMILRootLayout] = pStringMap;
  1691.     // SMILMeta
  1692.     pStringMap = new CHXMapStringToOb;
  1693.     (*pStringMap)["name"] = 0;
  1694.     (*pStringMap)["content"] = 0;
  1695.     (*pStringMap)["skip-content"] = 0;
  1696.     (*m_pTagAttributeMap)[SMILMeta] = pStringMap;
  1698.     // SMILBody
  1699.     pStringMap = new CHXMapStringToOb;
  1700.     (*pStringMap)["id"] = 0;
  1701.     (*m_pTagAttributeMap)[SMILBody] = pStringMap;
  1703.     // SMILPar
  1704.     pStringMap = new CHXMapStringToOb;
  1705.     (*pStringMap)["id"] = 0;
  1706.     (*pStringMap)["title"] = 0;
  1707.     (*pStringMap)["abstract"] = 0;
  1708.     (*pStringMap)["author"] = 0;
  1709.     (*pStringMap)["copyright"] = 0;
  1710.     (*pStringMap)["endsync"] = 0;
  1711.     (*pStringMap)["dur"] = 0;
  1712.     (*pStringMap)["repeat"] = 0;
  1713.     (*pStringMap)["region"] = 0;
  1714.     (*pStringMap)["begin"] = 0;
  1715.     (*pStringMap)["end"] = 0;
  1716.     (*pStringMap)["system-bitrate"] = 0;
  1717.     (*pStringMap)["system-language"] = 0;
  1718.     (*pStringMap)["system-required"] = 0;
  1719.     (*pStringMap)["system-screen-size"] = 0;
  1720.     (*pStringMap)["system-screen-depth"] = 0;
  1721.     (*pStringMap)["system-captions"] = 0;
  1722.     (*pStringMap)["system-overdub-or-caption"] = 0;
  1723.     (*m_pTagAttributeMap)[SMILPar] = pStringMap;
  1725.     // SMILSeq
  1726.     pStringMap = new CHXMapStringToOb;
  1727.     (*pStringMap)["id"] = 0;
  1728.     (*pStringMap)["title"] = 0;
  1729.     (*pStringMap)["abstract"] = 0;
  1730.     (*pStringMap)["author"] = 0;
  1731.     (*pStringMap)["copyright"] = 0;
  1732.     (*pStringMap)["dur"] = 0;
  1733.     (*pStringMap)["repeat"] = 0;
  1734.     (*pStringMap)["region"] = 0;
  1735.     (*pStringMap)["begin"] = 0;
  1736.     (*pStringMap)["end"] = 0;
  1737.     (*pStringMap)["system-bitrate"] = 0;
  1738.     (*pStringMap)["system-language"] = 0;
  1739.     (*pStringMap)["system-required"] = 0;
  1740.     (*pStringMap)["system-screen-size"] = 0;
  1741.     (*pStringMap)["system-screen-depth"] = 0;
  1742.     (*pStringMap)["system-captions"] = 0;
  1743.     (*pStringMap)["system-overdub-or-caption"] = 0;
  1744.     (*m_pTagAttributeMap)[SMILSeq] = pStringMap;
  1746.     // SMILSwitch
  1747.     pStringMap = new CHXMapStringToOb;
  1748.     (*pStringMap)["id"] = 0;
  1749.     (*pStringMap)["title"] = 0;
  1750.     (*m_pTagAttributeMap)[SMILSwitch] = pStringMap;
  1752.     // SMILRef
  1753.     pStringMap = new CHXMapStringToOb;
  1754.     (*pStringMap)["id"] = 0;
  1755.     (*pStringMap)["title"] = 0;
  1756.     (*pStringMap)["abstract"] = 0;
  1757.     (*pStringMap)["author"] = 0;
  1758.     (*pStringMap)["copyright"] = 0;
  1759.     (*pStringMap)["region"] = 0;
  1760.     (*pStringMap)["alt"] = 0;
  1761.     (*pStringMap)["longdesc"] = 0;
  1762.     (*pStringMap)["src"] = 0;
  1763.     (*pStringMap)["type"] = 0;
  1764.     (*pStringMap)["dur"] = 0;
  1765.     (*pStringMap)["repeat"] = 0;
  1766.     (*pStringMap)["fill"] = 0;
  1767.     (*pStringMap)["begin"] = 0;
  1768.     (*pStringMap)["end"] = 0;
  1769.     (*pStringMap)["clip-begin"] = 0;
  1770.     (*pStringMap)["clip-end"] = 0;
  1771.     (*pStringMap)["skip-content"] = 0;
  1772.     (*pStringMap)["system-bitrate"] = 0;
  1773.     (*pStringMap)["system-language"] = 0;
  1774.     (*pStringMap)["system-required"] = 0;
  1775.     (*pStringMap)["system-screen-size"] = 0;
  1776.     (*pStringMap)["system-screen-depth"] = 0;
  1777.     (*pStringMap)["system-captions"] = 0;
  1778.     (*pStringMap)["system-overdub-or-caption"] = 0;
  1779.     (*m_pTagAttributeMap)[SMILRef] = pStringMap;
  1781.     // SMILAAnchor
  1782.     pStringMap = new CHXMapStringToOb;
  1783.     (*pStringMap)["id"] = 0;
  1784.     (*pStringMap)["title"] = 0;
  1785.     (*pStringMap)["href"] = 0;
  1786.     (*pStringMap)["show"] = 0;
  1787.     (*m_pTagAttributeMap)[SMILAAnchor] = pStringMap;
  1789.     // SMILAnchor
  1790.     pStringMap = new CHXMapStringToOb;
  1791.     (*pStringMap)["id"] = 0;
  1792.     (*pStringMap)["title"] = 0;
  1793.     (*pStringMap)["href"] = 0;
  1794.     (*pStringMap)["show"] = 0;
  1795.     (*pStringMap)["begin"] = 0;
  1796.     (*pStringMap)["end"] = 0;
  1797.     (*pStringMap)["coords"] = 0;
  1798.     (*pStringMap)["fragment-id"] = 0;
  1799.     (*pStringMap)["skip-content"] = 0;
  1800.     (*pStringMap)["z-index"] = 0;
  1801.     (*m_pTagAttributeMap)[SMILAnchor] = pStringMap;
  1803.     // SMILRendererPreFetch
  1804.     pStringMap = new CHXMapStringToOb;
  1805.     (*pStringMap)["type"] = 0;
  1806.     (*m_pTagAttributeMap)[SMILRendererPreFetch] = pStringMap;
  1807. }
  1809. void
  1810. CSmil1Parser::deleteTagAttributes()
  1811. {
  1812.     if(m_pTagAttributeMap)
  1813.     {
  1814.         CHXMapLongToObj::Iterator i = m_pTagAttributeMap->Begin();
  1815. for(; i != m_pTagAttributeMap->End(); ++i)
  1816. {
  1817.     CHXMapStringToOb* pStringMap = (CHXMapStringToOb*)(*i);
  1818.     delete pStringMap;
  1819. }
  1820.     }
  1821.     HX_DELETE(m_pTagAttributeMap);
  1822. }
  1824. BOOL
  1825. CSmil1Parser::isLegalAttribute(SMIL1NodeTag tag, const char* pAttName)
  1826. {
  1827.     // use SMILRef for all media object checks
  1828.     if(tag == SMILText ||
  1829.        tag == SMILImg ||
  1830.        tag == SMILAudio ||
  1831.        tag == SMILVideo ||
  1832.        tag == SMILAnimation ||
  1833.        tag == SMILTextstream)
  1834.     {
  1835. tag = SMILRef;
  1836.     }
  1837.     CHXMapStringToOb* pStringMap = 0;
  1838.     if(m_pTagAttributeMap->Lookup(tag, (void*&)pStringMap))
  1839.     {
  1840. void* pVoid = 0;
  1841. if(pStringMap->Lookup(pAttName, pVoid))
  1842. {
  1843.     return TRUE;
  1844. }
  1845. else if (strcmp(pAttName, "xmlns") == 0 || 
  1846.     strncmp(pAttName, "xmlns:", 6) == 0)
  1847. {
  1848.     // accept any namespace declarations.
  1849.     return TRUE;
  1850. }
  1851. else
  1852. {
  1853.     BOOL bValidAttribute = FALSE;
  1854.     char* pColon = (char *)strchr(pAttName, ':');
  1855.     if(pColon)
  1856.     {
  1857. //check for valid namespace tag we can
  1858. // ignore
  1860. char* pTmpNam = new_string(pAttName);
  1861. char* pNamespace = strtok(pTmpNam, ":");
  1862. if(pNamespace)
  1863. {
  1864.     UINT32 ulTemp = 0;
  1865.     if(m_pActiveNamespaceMap &&
  1866.       (m_pActiveNamespaceMap->Lookup(pNamespace,
  1867.       (void*&)ulTemp)))
  1868.     {
  1869. // OK, we can ignore it...
  1870. bValidAttribute = TRUE;
  1871.     }
  1872. }
  1873. delete[] pTmpNam;
  1874.     }
  1875.     if(bValidAttribute)
  1876.     {
  1877. return TRUE;
  1878.     }
  1879. }
  1880.     }
  1882.     return FALSE;
  1883. }
  1885. BOOL
  1886. CSmil1Parser::isRelativeURL(const char* pURL)
  1887. {
  1888.     BOOL rc = TRUE;
  1890.     CHXURL urlObj(pURL);
  1891.     IHXValues* pHeader = urlObj.GetProperties();
  1892.     if(pHeader)
  1893.     {
  1894.         IHXBuffer* pBuffer = NULL;
  1896. if(HXR_OK == pHeader->GetPropertyBuffer(PROPERTY_SCHEME, pBuffer))
  1897. {
  1898.     // fully qualified URL
  1899.     rc = FALSE;
  1900.     HX_RELEASE(pBuffer);
  1901. }
  1902.     }
  1904.     HX_RELEASE(pHeader);
  1905.     return rc;
  1906. }
  1909. HX_RESULT
  1910. CSmil1Parser::storeNamespaces(SMIL1Node* pNode)
  1911. {
  1912.     HX_RESULT rc = HXR_OK;
  1914.     if (pNode->m_pValues)
  1915.     {
  1916. const char* pName = NULL;
  1917. IHXBuffer* pBuffer = NULL;
  1918. HX_RESULT res = pNode->m_pValues->GetFirstPropertyCString(pName, pBuffer);
  1919. while (SUCCEEDED(rc) && SUCCEEDED(res))
  1920. {
  1921.     if (strcmp(pName, "xmlns") == 0)
  1922.     {
  1923. if (!pNode->m_pNamespaceList)
  1924. {
  1925.     pNode->m_pNamespaceList = new CHXSimpleList;
  1926.     if (!pNode->m_pNamespaceList)
  1927.     {
  1928. rc = HXR_OUTOFMEMORY;
  1929. break;
  1930.     }
  1931. }
  1933. // duplicate atributes should allready be caught...
  1934. SMIL1Namespace* pNS = new SMIL1Namespace("", pBuffer);
  1935. pNode->m_pNamespaceList->AddHead(pNS);
  1936.     }
  1937.     else if (strncmp(pName, "xmlns:", 6) == 0)
  1938.     {
  1939. if (!pNode->m_pNamespaceList)
  1940. {
  1941.     pNode->m_pNamespaceList = new CHXSimpleList;
  1942.     if (!pNode->m_pNamespaceList)
  1943.     {
  1944. rc = HXR_OUTOFMEMORY;
  1945. break;
  1946.     }
  1947. }
  1949. char* nsPrefix = (char *)strchr(pName, ':');
  1950. ++nsPrefix;
  1952. SMIL1Namespace* pNS = new SMIL1Namespace(nsPrefix, pBuffer);
  1953. pNode->m_pNamespaceList->AddHead(pNS);
  1954.     }
  1956.     HX_RELEASE(pBuffer);
  1957.     res = pNode->m_pValues->GetNextPropertyCString(pName, pBuffer);
  1958. }
  1959.     }
  1960.     return rc;
  1961. }
  1963. HX_RESULT
  1964. CSmil1Parser::addToNamespaceScope(SMIL1Node* pNode)
  1965. {
  1966.     HX_RESULT rc = HXR_OK;
  1968.     if (!m_pActiveNamespaceMap)
  1969.     {
  1970. m_pActiveNamespaceMap = new CHXMapStringToOb;
  1971. if (!m_pActiveNamespaceMap)
  1972. {
  1973.     return HXR_OUTOFMEMORY;
  1974. }
  1975.     }
  1977.     if (pNode &&
  1978. pNode->m_pNamespaceList)
  1979.     {
  1980. for (CHXSimpleList::Iterator pIt = pNode->m_pNamespaceList->Begin();
  1981.      pIt != pNode->m_pNamespaceList->End(); ++pIt)
  1982. {
  1983.     SMIL1Namespace* pNS = (SMIL1Namespace*)(*pIt);
  1984.     IHXBuffer* pBuf = (IHXBuffer*)(*m_pActiveNamespaceMap)[pNS->m_name];
  1986.     if (pBuf)
  1987.     {
  1988. if (!m_pNSConflictList)
  1989. {
  1990.     m_pNSConflictList = new CHXSimpleList;
  1991.     if (!m_pNSConflictList)
  1992.     {
  1993. rc = HXR_OUTOFMEMORY;
  1994. break;
  1995.     }
  1996. }
  1998. SMIL1Namespace* pConflict = new SMIL1Namespace(pNS);
  1999. if (!pConflict)
  2000. {
  2001.     rc = HXR_OUTOFMEMORY;
  2002.     break;
  2003. }
  2005. m_pNSConflictList->AddHead(pConflict);
  2007. HX_RELEASE(pBuf);
  2009. (*m_pActiveNamespaceMap)[pNS->m_name] = pNS->m_pValue;
  2010. pNS->m_pValue->AddRef();
  2011.     }
  2012.     else
  2013.     {
  2014. (*m_pActiveNamespaceMap)[pNS->m_name] = pNS->m_pValue;
  2015. pNS->m_pValue->AddRef();
  2016.     }
  2017. }
  2018.     }
  2019.     return rc;
  2020. }
  2022. HX_RESULT
  2023. CSmil1Parser::removeFromNamespaceScope(SMIL1Node* pNode)
  2024. {
  2025.     HX_RESULT rc = HXR_OK;
  2026.     
  2027.     if (pNode->m_pNamespaceList)
  2028.     {
  2029. for (CHXSimpleList::Iterator pIt = pNode->m_pNamespaceList->Begin();
  2030.      pIt != pNode->m_pNamespaceList->End(); ++pIt)
  2031. {
  2032.     SMIL1Namespace* pNS = (SMIL1Namespace*)(*pIt);
  2034.     HX_ASSERT((*m_pActiveNamespaceMap)[pNS->m_name]);
  2035.     IHXBuffer* pBuf = (IHXBuffer*)(*m_pActiveNamespaceMap)[pNS->m_name];
  2037.     if (pBuf != NULL)
  2038.     {
  2039. HX_RELEASE(pBuf);
  2040. m_pActiveNamespaceMap->RemoveKey(pNS->m_name);
  2042. // check for conficts.
  2043. if (m_pNSConflictList)
  2044. {
  2045.     LISTPOSITION pos = m_pNSConflictList->GetHeadPosition();
  2046.     while (pos)
  2047.     {
  2048. SMIL1Namespace* pCon = 
  2049.     (SMIL1Namespace*)m_pNSConflictList->GetAt(pos);
  2051. if (strcmp(pCon->m_name, pNS->m_name) == 0)
  2052. {
  2053.     (*m_pActiveNamespaceMap)[pCon->m_name] = pCon->m_pValue;
  2054.     pCon->m_pValue->AddRef();
  2056.     HX_DELETE(pCon);
  2058.     m_pNSConflictList->RemoveAt(pos);
  2059.     // BREAK at the first found match.
  2060.     break;
  2061. }
  2063. m_pNSConflictList->GetNext(pos);
  2064.     }
  2065. }
  2066.     }
  2067. }
  2068.     }
  2069.     return rc;
  2070. }
  2073. HX_RESULT
  2074. CSmil1Parser::addGlobalNamespace(const char* pNamespace,
  2075.   const char* pPrefix)
  2076. {
  2077.     HX_RESULT rc = HXR_OK;
  2079.     if(m_bNoNamespaces)
  2080.     {
  2081. rc = HXR_FAIL;
  2082. CSmil1SMILSyntaxErrorHandler errHandler(m_pContext);
  2083. errHandler.ReportError(SMILErrorSMIL10Document, NULL, 0);
  2084.     }
  2085.     else if (pNamespace)
  2086.     {
  2087. if(!m_pActiveNamespaceMap)
  2088. {
  2089.     m_pActiveNamespaceMap = new CHXMapStringToOb;
  2090. }
  2092. if (!m_pRequireTagsMap)
  2093. {
  2094.     m_pRequireTagsMap = new CHXMapStringToOb;
  2095. }
  2097. if(pPrefix)
  2098. {
  2099.     // get an IHXBuffer
  2100.     //XXXJEFFA should use CF for this
  2101.     IHXBuffer* pBuffer = (IHXBuffer*) new CHXBuffer;
  2102.     pBuffer->AddRef();
  2103.     pBuffer->Set((UINT8*)pNamespace, strlen(pNamespace) + 1);
  2105.     (*m_pActiveNamespaceMap)[pPrefix] = pBuffer;
  2106.     
  2107.     // add the prefix to the require map so system 
  2108.     // required checks work
  2109.     (*m_pRequireTagsMap)[pPrefix] = 0;
  2111.     if(strcmp(pPrefix, (const char*) RN_PREFIX) == 0)
  2112.     {
  2113. m_bRNNamespace = TRUE;
  2114.     }
  2115. }
  2116. else
  2117. {
  2118.     // empty prefix, 
  2119.     // don't ignore unrecognized elements...
  2120.     m_bIgnoreUnrecognizedElements = FALSE;
  2121. }
  2122.     }
  2124.     return rc;
  2125. }
  2128. HX_RESULT
  2129. CSmil1Parser::storeError(HX_RESULT errCode, const char* pErrorString, 
  2130.  const char* pFrameString, UINT32 ulLineNumber, 
  2131.  UINT32 ulLinePosition, BOOL bXml)
  2132. {
  2133.     // XXXJHUG - this is what the SMIL error hanndler uses 1024....
  2134.     char errorString[1024]; /* Flawfinder: ignore */
  2135.     if (bXml)
  2136.     {
  2137. CSmil1XMLSyntaxErrorHandler errHandler(m_pContext);
  2138.     
  2139. errHandler.GetReportString(errCode, errorString);
  2140.     }
  2141.     else
  2142.     {
  2143. CSmil1SMILSyntaxErrorHandler errHandler(m_pContext);
  2144.     
  2145. errHandler.GetReportString((SMILErrorTag)errCode, errorString);
  2146.     }
  2148.     IHXBuffer* pBuf;
  2149.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pBuf);
  2151.     pBuf->SetSize(strlen(errorString) + strlen(pErrorString) + 10);
  2152.     char* buffer = (char*) pBuf->GetBuffer();
  2153.     sprintf(buffer, errorString, ulLineNumber, pErrorString); /* Flawfinder: ignore */
  2155.     m_pErrors->Add(pBuf);
  2157.     return HXR_OK;
  2158. }
  2161. HX_RESULT
  2162. CSmil1Parser::getErrors(CHXPtrArray** pErrs)
  2163. {
  2164.     *pErrs = m_pErrors;
  2165.     return HXR_OK;
  2166. }
  2168. ElementWithinTag
  2169. CSmil1Parser::GetElementWithin(const char* pID)
  2170. {
  2171.     ElementWithinTag elementWithinTag = WithinUnknown;
  2172.     SMIL1Node* pNode = NULL;
  2173.     SMIL1Node* pParentNode = NULL;
  2175.     if(!m_pIDMap->Lookup(pID, (void*&)pNode))
  2176.     {
  2177. HX_ASSERT(FALSE);
  2178. goto cleanup;
  2179.     }
  2181.     while (pNode->m_pParent)
  2182.     {
  2183. switch (pNode->m_pParent->m_tag)
  2184. {
  2185. case SMILPar:
  2186.     if (elementWithinTag == WithinSeq)
  2187.     {
  2188. elementWithinTag = WithinSeqInPar;
  2189.     }
  2190.     else
  2191.     {
  2192. elementWithinTag = WithinPar;
  2193.     }
  2194.     goto cleanup;
  2195. case SMILSeq:
  2196.     elementWithinTag = WithinSeq;
  2197.     break;
  2198. default:
  2199.     break;
  2200. }
  2202. pNode = pNode->m_pParent;
  2203.     }
  2205. cleanup:
  2207.     return elementWithinTag;
  2208. }
  2210. void
  2211. CSmil1Parser::InitPersistent(UINT32 ulPersistentComponentID, 
  2212.     ElementWithinTag elementWithinTag)
  2213. {
  2214.     m_ulPersistentComponentID = ulPersistentComponentID;
  2215.     m_elementWithinTag = elementWithinTag;
  2216. }
  2218. /*
  2219.  * CSmil1ParserResponse methods
  2220.  */
  2222. CSmil1ParserResponse::CSmil1ParserResponse(CSmil1Parser* pParser)
  2223. :   m_pParser(pParser)
  2224. ,   m_lRefCount(0)
  2225. {
  2226. }
  2228. CSmil1ParserResponse::~CSmil1ParserResponse()
  2229. {
  2230. }
  2232. STDMETHODIMP 
  2233. CSmil1ParserResponse::QueryInterface(REFIID riid, void** ppvObj)
  2234. {
  2235.     if (IsEqualIID(riid, IID_IUnknown))
  2236.     {
  2237. AddRef();
  2238. *ppvObj = this;
  2239. return HXR_OK;
  2240.     }
  2241.     else if (IsEqualIID(riid, IID_IHXXMLParserResponse))
  2242.     {
  2243. AddRef();
  2244. *ppvObj = (IHXXMLParserResponse*)this;
  2245. return HXR_OK;
  2246.     }
  2248.     *ppvObj = NULL;
  2249.     return HXR_NOINTERFACE;
  2250. }
  2252. STDMETHODIMP_(ULONG32) 
  2253. CSmil1ParserResponse::AddRef()
  2254. {
  2255.     return InterlockedIncrement(&m_lRefCount);
  2256. }
  2258. STDMETHODIMP_(ULONG32) 
  2259. CSmil1ParserResponse::Release()
  2260. {
  2261.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2262.     {
  2263.         return m_lRefCount;
  2264.     }
  2266.     delete this;
  2267.     return 0;
  2268. }
  2270. STDMETHODIMP
  2271. CSmil1ParserResponse::HandleStartElement(const char* pName,
  2272.  IHXValues* pAttributes,
  2273.  UINT32 ulLineNumber,
  2274.  UINT32 ulColumnNumber)
  2275. {
  2276.     HX_RESULT rc = HXR_OK;
  2278.     SMIL1Node* pParentNode = 
  2279. (SMIL1Node*)m_pParser->m_pNodeListStack->TopOfStack();
  2280.     HX_ASSERT(pParentNode);
  2282.     SMIL1Node* pNode = new SMIL1Node;
  2283.     pNode->m_name = pName;
  2284.     pNode->m_pParent = pParentNode;
  2286.     pNode->m_pNodeList = new SMIL1NodeList;
  2287.     pNode->m_pNodeList->m_pParentNode = pNode;
  2289.     pNode->m_ulTagStartLine = ulLineNumber;
  2290.     pNode->m_ulTagStartColumn = ulColumnNumber;
  2292.     if(!pNode->m_pParent->m_bSkipContent)
  2293.     {
  2294. IHXBuffer* pBuffer = NULL;
  2295. if(HXR_OK == pAttributes->GetPropertyCString("id", pBuffer))
  2296. {
  2297.     const char* pID = (const char*)pBuffer->GetBuffer();
  2298.     // XXXMEH - 04/27/99 - change this to still throw
  2299.     // an error for isspace(), but not for isdigit()
  2300.     // - not legal SMIL, but we still allowed
  2301.     // it in previous players.
  2302. //     if (isdigit(*pID) || isspace(*pID))
  2303.     if (isspace(*pID))
  2304.     {
  2305. rc = HXR_XML_ILLEGALID;
  2306. CSmil1XMLSyntaxErrorHandler errHandler(m_pParser->m_pContext);
  2307. errHandler.ReportError(rc, pID, ulLineNumber);
  2308. goto exit;
  2309.     }
  2310.     else if (m_pParser->m_bStoreErrors && isdigit(*pID))
  2311.     {
  2312. m_pParser->storeError(HXR_XML_ILLEGALID, pID, 0, 
  2313.     ulLineNumber, ulColumnNumber);
  2314.     }
  2315.     else
  2316.     {
  2317. // append persistent ID to the end of region id
  2318. // to make it unique in nested meta
  2319. if (!strcmp(pNode->m_name, "region"))
  2320. {
  2321.     //char szPersistentComponentID[MAX_DISPLAY_NAME] = {0};
  2322.     //itoa(m_pParser->m_ulPersistentComponentID, szPersistentComponentID, 10);
  2324.     pNode->m_id = pID;
  2325.     //pNode->m_id += "_";
  2326.     //pNode->m_id += szPersistentComponentID;
  2328.     pNode->m_repeatid = pNode->m_id;
  2329. }
  2330. else
  2331. {
  2332.     pNode->m_id = pID;
  2333.     pNode->m_repeatid = pID;
  2334. }
  2335. HX_RELEASE(pBuffer);
  2336.     }
  2337. }
  2338. else
  2339. {
  2340.     //[SMIL 1.0 Compliance] Fixes PR 24034: region tag must have
  2341.     // an id attribute:
  2342.     if (m_pParser->m_bSMIL10FullCompliance  &&
  2343.     !strcmp(pNode->m_name, "region"))
  2344.     {
  2345. rc = HXR_XML_ILLEGALID;
  2346. CSmil1XMLSyntaxErrorHandler errHandler(m_pParser->m_pContext);
  2347. const char* pTmp = "region id=""";
  2348. errHandler.ReportError(rc, pTmp, ulLineNumber);
  2349. goto exit;
  2350.     }
  2351.     else
  2352.     {
  2353. pNode->m_id = m_pParser->assignID(pName);
  2354. pNode->m_repeatid = pNode->m_id;
  2355.     }
  2357.     if (m_pParser->m_bStoreErrors && !strcmp(pNode->m_name, "region"))
  2358.     {
  2359. const char* pTmp = "region id=""";
  2360. m_pParser->storeError(HXR_XML_ILLEGALID, pTmp, 0, 
  2361.     ulLineNumber, ulColumnNumber);
  2362.     }
  2363. }
  2365. if(HXR_OK != m_pParser->mapID(pNode))
  2366. {
  2367.     rc = HXR_XML_ILLEGALID;
  2368.     CSmil1XMLSyntaxErrorHandler errHandler(m_pParser->m_pContext);
  2369.     errHandler.ReportError(rc, pNode->m_id, ulLineNumber);
  2370.     goto exit;
  2371. }
  2373. if(strcmp(pName, "smil") == 0)
  2374. {
  2375.     pNode->m_tag = SMILSmil;
  2376. }
  2377. else if(strcmp(pName, "layout") == 0)
  2378. {
  2379.     pNode->m_tag = SMILBasicLayout;
  2380.     if(HXR_OK == pAttributes->GetPropertyCString("type", pBuffer))
  2381.     {
  2382. const char* pType = (const char*)pBuffer->GetBuffer();
  2383. if(strcmp(pType, "text/smil-basic-layout") != 0)
  2384. {
  2385.     pNode->m_bDelete = TRUE; // only basic layout supported
  2386. }
  2387. HX_RELEASE(pBuffer);
  2388.     }
  2389. }
  2390. else if(strcmp(pName, "meta") == 0)
  2391. {
  2392.     pNode->m_tag = SMILMeta;
  2393.     pNode->m_bSkipContent = TRUE;
  2394. }
  2395. else if(strcmp(pName, "head") == 0)
  2396. {
  2397.     pNode->m_id = "head";
  2398.     pNode->m_tag = SMILHead;
  2399. }
  2400. else if(strcmp(pName, "body") == 0)
  2401. {
  2402.     pNode->m_id = "body";
  2403.     pNode->m_tag = SMILBody;
  2404. }
  2405. else if(strcmp(pName, "region") == 0)
  2406. {
  2407.     pNode->m_tag = SMILRegion;
  2408.     pNode->m_bSkipContent = TRUE;
  2409. }
  2410. else if(strcmp(pName, "root-layout") == 0)
  2411. {
  2412.     pNode->m_tag = SMILRootLayout;
  2413.     pNode->m_bSkipContent = TRUE;
  2414. }
  2415. else if(strcmp(pName, "switch") == 0)
  2416. {
  2417.     pNode->m_tag = SMILSwitch;
  2418. }
  2419. else if(strcmp(pName, "text") == 0)
  2420. {
  2421.     pNode->m_tag = SMILText;
  2422. }
  2423. else if(strcmp(pName, "img") == 0)
  2424. {
  2425.     pNode->m_tag = SMILImg;
  2426. }
  2427. else if(strcmp(pName, "ref") == 0)
  2428. {
  2429.     pNode->m_tag = SMILRef;
  2430. }
  2431. else if(strcmp(pName, "audio") == 0)
  2432. {
  2433.     pNode->m_tag = SMILAudio;
  2434. }
  2435. else if(strcmp(pName, "video") == 0)
  2436. {
  2437.     pNode->m_tag = SMILVideo;
  2438. }
  2439. else if(strcmp(pName, "animation") == 0)
  2440. {
  2441.     pNode->m_tag = SMILAnimation;
  2442. }
  2443. else if(strcmp(pName, "textstream") == 0)
  2444. {
  2445.     pNode->m_tag = SMILTextstream;
  2446. }
  2447. else if(strcmp(pName, "a") == 0)
  2448. {
  2449.     pNode->m_tag = SMILAAnchor;
  2450. }
  2451. else if(strcmp(pName, "anchor") == 0)
  2452. {
  2453.     pNode->m_tag = SMILAnchor;
  2454.     pNode->m_bSkipContent = TRUE;
  2455. }
  2456. else if(strcmp(pName, "par") == 0)
  2457. {
  2458.     pNode->m_tag = SMILPar;
  2459. }
  2460. else if(strcmp(pName, "seq") == 0)
  2461. {
  2462.     pNode->m_tag = SMILSeq;
  2463. }
  2464. else if(m_pParser->m_bRNNamespace && 
  2465.     strcmp(pName, (const char*) RN_TAG_RENDERER_LIST) == 0)
  2466. {
  2467.     pNode->m_id = m_pParser->assignID((const char*) RN_TAG_RENDERER_LIST);
  2468.     pNode->m_tag = SMILRNRendererList;
  2469. }
  2470. else if(strcmp(pName, (const char*) RN_TAG_RENDERER) == 0)
  2471. {
  2472.     pNode->m_tag = SMILRendererPreFetch;
  2473. }
  2474. else 
  2475. {
  2476.     BOOL bValidTag = FALSE;
  2477.     char* pColon = (char *)strchr(pName, ':');
  2478.     if(pColon)
  2479.     {
  2480. //check for valid namespace tag we can
  2481. // ignore
  2483. char* pTmpNam = new_string(pName);
  2484. char* pNamespace = strtok(pTmpNam, ":");
  2485. if(pNamespace)
  2486. {
  2487.     UINT32 ulTemp = 0;
  2488.     if(m_pParser->m_pActiveNamespaceMap &&
  2489.       (m_pParser->m_pActiveNamespaceMap->Lookup(pNamespace,
  2490.       (void*&)ulTemp)))
  2491.     {
  2492. // OK, we can ignore it...
  2493. bValidTag = TRUE;
  2494.     }
  2495. }
  2496. delete[] pTmpNam;
  2497.     }
  2498.     if(!bValidTag && 
  2499. !m_pParser->m_bIgnoreUnrecognizedElements)
  2500.     {
  2501. rc = HXR_FAIL;
  2502. CSmil1SMILSyntaxErrorHandler errHandler(m_pParser->m_pContext);
  2503. errHandler.ReportError(SMILErrorUnrecognizedTag, pName, ulLineNumber);
  2504. goto exit;
  2505.     }
  2506.     else
  2507.     {
  2508. pNode->m_bDelete = TRUE; // don't ask, don't tell...
  2509.     }
  2511.     if (!bValidTag && m_pParser->m_bStoreErrors)
  2512.     {
  2513. m_pParser->storeError(SMILErrorUnrecognizedTag, pName, 0, 
  2514.     ulLineNumber, ulColumnNumber, FALSE);
  2515.     }
  2516. }
  2518. pNode->m_pValues = pAttributes;
  2519. pNode->m_pValues->AddRef();
  2521. rc = m_pParser->storeNamespaces(pNode);
  2522. if (SUCCEEDED(rc))
  2523. {
  2524.     rc = m_pParser->addToNamespaceScope(pNode);
  2525. }
  2527. const char* pName = NULL;
  2528. HX_RESULT res = pAttributes->GetFirstPropertyCString(pName, pBuffer);
  2529. while(HXR_OK == res && SUCCEEDED(rc))
  2530. {
  2531.     const char* pActualValue = (const char*)pBuffer->GetBuffer();
  2533.     if(!m_pParser->isLegalAttribute(pNode->m_tag, pName) )
  2534.     {
  2535. if (!m_pParser->m_bIgnoreUnrecognizedElements)
  2536. {
  2537.     rc = HXR_FAIL;
  2538.     m_pParser->badAttributeError(pNode->m_tag, pName,
  2539. pNode->m_ulTagStartLine, FALSE);
  2540.     break;
  2541. }
  2543. if (m_pParser->m_bStoreErrors)
  2544. {
  2545.     m_pParser->badAttributeError(pNode->m_tag, pName, 
  2546. ulLineNumber, TRUE);
  2547. }
  2549.     }
  2551.     if(strcmp(pName, "skip-content") == 0)
  2552.     {
  2553. if(strcmp(pActualValue, "true") == 0)
  2554. {
  2555.     pNode->m_bSkipContent = TRUE;
  2556. }
  2557. else
  2558. {
  2559.     pNode->m_bSkipContent = FALSE;
  2560. }
  2561.     }
  2562.     HX_RELEASE(pBuffer);
  2563.     res = pAttributes->GetNextPropertyCString(pName, pBuffer);
  2564. }
  2566. m_pParser->m_pNodeListStack->Push(pNode);
  2567.     }
  2569. exit:
  2570.     return rc;
  2571. }
  2573. STDMETHODIMP
  2574. CSmil1ParserResponse::HandleEndElement(const char* pName,
  2575.       UINT32 ulLineNumber,
  2576.       UINT32 ulColumnNumber)
  2577. {
  2578.     HX_RESULT rc = HXR_OK;
  2580.     SMIL1Node* pCurrentNode = (SMIL1Node*)m_pParser->m_pNodeListStack->Pop();
  2581.     SMIL1Node* pParentNode = (SMIL1Node*)m_pParser->m_pNodeListStack->TopOfStack();
  2582.     HX_ASSERT(pCurrentNode);
  2583.     HX_ASSERT(pParentNode);
  2585.     if (pParentNode)
  2586.     {
  2587.         pParentNode->m_pNodeList->AddTail(pCurrentNode);
  2588.     }
  2590.     SMIL1Node* pEndNode = new SMIL1Node;
  2591.     pEndNode->m_name = pName;
  2592.     pEndNode->m_id.Format("CLOSE-%s", pName);
  2593.     pEndNode->m_pParent = pParentNode;
  2594.     pEndNode->m_ulTagStartLine = ulLineNumber;
  2595.     pEndNode->m_ulTagStartColumn = ulColumnNumber;
  2597.     if(strcmp(pName, "seq") == 0)
  2598.     {
  2599. pEndNode->m_tag = SMILEndSeq;
  2600.     }
  2601.     else if(strcmp(pName, "par") == 0)
  2602.     {
  2603. pEndNode->m_tag = SMILEndPar;
  2604.     }
  2605.     else if(strcmp(pName, "a") == 0)
  2606.     {
  2607. pEndNode->m_tag = SMILEndAAnchor;
  2608.     }
  2610.     pCurrentNode->m_pNodeList->AddTail(pEndNode);
  2612.     rc = m_pParser->removeFromNamespaceScope(pCurrentNode);
  2614.     return rc;
  2615. }
  2617. STDMETHODIMP
  2618. CSmil1ParserResponse::HandleCharacterData(IHXBuffer* pBuffer,
  2619.  UINT32 ulLineNumber,
  2620.  UINT32 ulColumnNumber)
  2621. {
  2622.     HX_RESULT rc = HXR_OK;
  2624.     return rc;
  2625. }
  2627. STDMETHODIMP
  2628. CSmil1ParserResponse::HandleProcessingInstruction(const char* pTarget,
  2629.   IHXValues* pAttributes,
  2630.   UINT32 ulLineNumber,
  2631.   UINT32 ulColumnNumber)
  2632. {
  2633.     HX_RESULT rc = HXR_OK;
  2635.     if(strcmp(pTarget, "xml:namespace") == 0)
  2636.     {
  2637. IHXBuffer* pNamespaceBuffer = NULL;
  2638. IHXBuffer* pPrefixBuffer = NULL;
  2639. const char* pNamespace = NULL;
  2640. const char* pPrefix = NULL;
  2641. if(HXR_OK == pAttributes->GetPropertyCString("ns", pNamespaceBuffer))
  2642. {
  2643.     pNamespace = (const char*)pNamespaceBuffer->GetBuffer();
  2644. }
  2645. if(HXR_OK == pAttributes->GetPropertyCString("prefix", pPrefixBuffer))
  2646. {
  2647.     pPrefix = (const char*)pPrefixBuffer->GetBuffer();
  2648. }
  2649. rc = m_pParser->addGlobalNamespace(pNamespace, pPrefix);
  2650. HX_RELEASE(pNamespaceBuffer);
  2651. HX_RELEASE(pPrefixBuffer);
  2652.     }
  2653.     return rc;
  2654. }
  2656. STDMETHODIMP
  2657. CSmil1ParserResponse::HandleUnparsedEntityDecl(const char* /*IN*/  pEntityName,
  2658.       const char* /*IN*/  pSystemID,
  2659.       const char* /*IN*/  pPublicID,
  2660.       const char* /*IN*/  pNotationName,
  2661.       UINT32 ulLineNumber,
  2662.       UINT32 ulColumnNumber)
  2663. {
  2664.     HX_RESULT rc = HXR_OK;
  2666.     return rc;
  2667. }
  2669. STDMETHODIMP
  2670. CSmil1ParserResponse::HandleNotationDecl(const char* /*IN*/  pNotationName,
  2671. const char* /*IN*/  pSystemID,
  2672. const char* /*IN*/  pPublicID,
  2673. UINT32 ulLineNumber,
  2674. UINT32 ulColumnNumber)
  2675. {
  2676.     HX_RESULT rc = HXR_OK;
  2678.     return rc;
  2679. }
  2681. STDMETHODIMP
  2682. CSmil1ParserResponse::HandleUnparsedDoctypeDecl(const char*  /*IN*/ pName, 
  2683.     const char*  /*IN*/ pSystemID,
  2684.     const char*  /*IN*/ pPublicID, 
  2685.     UINT32  /*IN*/ ulLineNumber,
  2686.     UINT32  /*IN*/ ulColumNumber)
  2687. {
  2688.     HX_RESULT rc = HXR_OK;
  2690.     if(strcmp(pName, "smil") == 0 &&
  2691.        strcmp(pSystemID, "http://www.w3.org/TR/REC-smil/SMIL10.dtd") == 0 &&
  2692.        strcmp(pPublicID, "-//W3C//DTD SMIL 1.0//EN") == 0)
  2693.     {
  2694. // only be strict, still allow namespaces...
  2695. //m_pParser->m_bNoNamespaces = TRUE;
  2696. m_pParser->m_bIgnoreUnrecognizedElements = FALSE;
  2697.     }
  2699.     return rc;
  2700. }
  2702. STDMETHODIMP
  2703. CSmil1ParserResponse::HandleComment(const char* /*IN*/  pComment,
  2704.    UINT32 ulLineNumber,
  2705.    UINT32 ulColumnNumber)
  2706. {
  2707.     HX_RESULT rc = HXR_OK;
  2709.     return rc;
  2710. }
  2712. STDMETHODIMP
  2713. CSmil1ParserResponse::HandleDefault(IHXBuffer* /*IN*/ pBuffer,
  2714.    UINT32 ulLineNumber,
  2715.    UINT32 ulColumnNumber)
  2716. {
  2717.     HX_RESULT rc = HXR_OK;
  2719.     return rc;
  2720. }
  2722. HX_RESULT
  2723. CSmil1ParserResponse::ErrorInLastTag(HX_RESULT err, 
  2724.     const char* pErrorString, const char* pFrameString, 
  2725.     UINT32 ulLineNumber, UINT32 ulLinePosition)
  2726. {
  2727.     // XXXJHUG - we could add the error to the actual node...
  2728.     // SMIL1Node* pCurrentNode = (SMIL1Node*)m_pParser->m_pNodeListStack->Pop();
  2729.     // pCurrentNode->m_errs->Add
  2730.     //
  2732.     // If we were going to warn for errors I think the warnings should be
  2733.     // thrown from here.  (modify ReportError to have a warning level.)
  2734.     //
  2735.     // But for dumping the errors there is no benifit for this.
  2736.     // therefore we will just add the error to a ptr array of errors.
  2737.     // this array will also be added to when the SMIL attributes are bad.
  2738.     //
  2739.     // XXX to store in the parse tree you also have to make sure the last
  2740.     // call was a tag, and not a PI or a directive or something that was 
  2741.     // ignored.
  2742.     
  2743.     return m_pParser->storeError(err, pErrorString, pFrameString, 
  2744.     ulLineNumber, ulLinePosition);
  2745. }
  2747. /*
  2748.  * SMIL1Node methods
  2749.  */
  2751. SMIL1Node::SMIL1Node():
  2752.     m_pNodeList(0),
  2753.     m_pParent(0),
  2754.     m_pDependency(0),
  2755.     m_tag(SMILUnknown),
  2756.     m_num(0),
  2757.     m_pValues(0),
  2758.     m_curPosition(0),
  2759.     m_pElement(0),
  2760.     m_nGroup((UINT16)-1),
  2761.     m_bLastInGroup(FALSE),
  2762.     m_bDelete(FALSE),
  2763.     m_bSkipContent(FALSE),
  2764.     m_pNamespaceList(NULL),
  2765.     m_bRepeatHandled(FALSE),
  2766.     m_repeatTag(RepeatUnknown)
  2767. {
  2768. }
  2770. SMIL1Node::SMIL1Node(const SMIL1Node& rhs, BOOL bKeepId, CSmil1Parser* pParser)
  2771. {
  2772.     if (bKeepId)
  2773.     {
  2774. m_id = rhs.m_id;
  2775.     }
  2776.     else
  2777.     {
  2778. // need a unique ID, so make one...
  2779. char* pIDName = new char [256];
  2780.         if (pIDName && pParser)
  2781.         {
  2782.     sprintf(pIDName, "node_copy_%ld", pParser->GetUniqueNumber()); /* Flawfinder: ignore */
  2783.     m_id = pIDName;
  2784.         }
  2785.         HX_VECTOR_DELETE(pIDName);
  2786.     }
  2788.     m_repeatid = rhs.m_repeatid;
  2789.     m_pParent = rhs.m_pParent;
  2790.     m_pDependency = rhs.m_pDependency;
  2791.     m_tag = rhs.m_tag;
  2792.     m_num = rhs.m_num;
  2793.     m_curPosition = rhs.m_curPosition;
  2794.     m_pElement = rhs.m_pElement;
  2795.     m_nGroup = rhs.m_nGroup;
  2796.     m_bLastInGroup = rhs.m_bLastInGroup;
  2797.     m_bDelete = rhs.m_bDelete;
  2798.     m_bSkipContent = rhs.m_bSkipContent;
  2799.     m_bRepeatHandled = FALSE;
  2800.     m_repeatTag = rhs.m_repeatTag;
  2802.     if(rhs.m_pValues)
  2803.     {
  2804. m_pValues = rhs.m_pValues;
  2805. m_pValues->AddRef();
  2806.     }
  2807.     else
  2808.     {
  2809. m_pValues = NULL;
  2810.     }
  2811.     if(rhs.m_pNodeList)
  2812.     {
  2813. m_pNodeList = rhs.m_pNodeList->copy(this, bKeepId, pParser);
  2814.     }
  2815.     else
  2816.     {
  2817. m_pNodeList = NULL;
  2818.     }
  2819.     if (rhs.m_pNamespaceList)
  2820.     {
  2821.      m_pNamespaceList = new CHXSimpleList;
  2822. for (CHXSimpleList::Iterator pIt = rhs.m_pNamespaceList->Begin();
  2823.      pIt != rhs.m_pNamespaceList->End(); ++pIt)
  2824. {
  2825.     SMIL1Namespace* pNS = (SMIL1Namespace*)(*pIt);
  2826.     SMIL1Namespace* pNewNS = new SMIL1Namespace(pNS);
  2827.     m_pNamespaceList->AddHead(pNewNS);
  2828. }
  2829.     }
  2830.     else
  2831.     {
  2832. m_pNamespaceList = NULL;
  2833.     }
  2834. }
  2836. SMIL1Node::~SMIL1Node()
  2837. {
  2838.     HX_DELETE(m_pNodeList);
  2839.     HX_RELEASE(m_pValues);
  2841.     if (m_pNamespaceList) 
  2842.     {
  2843. while (!m_pNamespaceList->IsEmpty())
  2844. {
  2845.     SMIL1Namespace* pNS = (SMIL1Namespace*)m_pNamespaceList->RemoveHead();
  2846.     HX_DELETE(pNS);
  2847. }
  2848.     }
  2849.     HX_DELETE(m_pNamespaceList);
  2850. }
  2852. SMIL1Node*
  2853. SMIL1Node::getFirstChild()
  2854. {
  2855.     if(!m_pNodeList)
  2856.     {
  2857. return 0;
  2858.     }
  2859.     m_curPosition = m_pNodeList->GetHeadPosition();
  2860.     if(m_curPosition)
  2861.     {
  2862. return (SMIL1Node*)m_pNodeList->GetNext(m_curPosition);
  2863.     }
  2864.     return 0;
  2865. }
  2867. SMIL1Node*
  2868. SMIL1Node::getNextChild()
  2869. {
  2870.     if(m_curPosition)
  2871.     {
  2872. return (SMIL1Node*)m_pNodeList->GetNext(m_curPosition);
  2873.     }
  2874.     return 0;
  2875. }
  2877. SMIL1NodeList::SMIL1NodeList():
  2878.     m_pParentNode(0)
  2879. {
  2880. }
  2882. SMIL1NodeList::~SMIL1NodeList()
  2883. {
  2884.     CHXSimpleList::Iterator i;
  2886.     for(i = Begin(); i != End(); ++i)
  2887.     {
  2888. SMIL1Node* pNode = (SMIL1Node*)(*i);
  2889. HX_DELETE(pNode);
  2890.     }
  2891. }
  2893. SMIL1NodeList*
  2894. SMIL1NodeList::copy(SMIL1Node* pParent, BOOL bKeepId, CSmil1Parser* pParser)
  2895. {
  2896.     SMIL1NodeList* pNewList = new SMIL1NodeList;
  2897.     m_pParentNode = pParent;
  2899.     CHXSimpleList::Iterator i = Begin();
  2900.     for(; i != End(); ++i)
  2901.     {
  2902. SMIL1Node* pNode = (SMIL1Node*)(*i);
  2903. SMIL1Node* pNodeCopy = new SMIL1Node(*pNode, bKeepId, pParser);
  2904. pNodeCopy->m_pParent = pParent;
  2905. pNewList->AddTail(pNodeCopy);
  2906.     }
  2907.     return pNewList;
  2908. }