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

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

Symbian

开发平台：

C/C++

smlelem.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include <stdlib.h>
  37. #include <stdio.h>
  38. #include <ctype.h>
  40. #include "hxtypes.h"
  41. #include "hxresult.h"
  42. #include "hxcom.h"
  43. #include "hxcomm.h"
  44. #include "ihxpckts.h"
  45. #include "hxfiles.h"
  46. #include "hxformt.h"
  47. #include "hxengin.h"
  48. #include "hxplugn.h"
  49. #include "hxpends.h"
  50. #include "hxasm.h"
  51. #include "hxassert.h"
  52. #include "chxpckts.h"
  53. #include "nptime.h"
  54. #include "smpte.h"
  55. #include "debug.h"
  56. #include "hxstrutl.h"
  57. #include "hxstring.h"
  58. #include "cbqueue.h"
  59. #include "hxslist.h"
  60. #include "hxmap.h"
  61. #include "hxstack.h"
  62. #include "hxwintyp.h"
  63. #include "chxxtype.h"
  65. #include "hxxml.h"
  66. #include "hxxmlprs.h"
  67. #include "xmlreslt.h"
  69. #include "looseprs.h"
  71. #include "sm1parse.h"
  72. #include "sm1time.h"
  73. #include "sm1elem.h"
  75. #include "debugout.h"
  76.  
  77. /*
  78.  * CSmil1Element methods
  79.  */
  81. CSmil1Element::CSmil1Element(SMIL1Node* pNode):
  82.     m_pNode(pNode),
  83.     m_ulDelay((UINT32)-1),
  84.     m_ulBeginOffset((UINT32)-1),
  85.     m_ulClipBegin((UINT32)-1),
  86.     m_ulClipEnd((UINT32)-1),
  87.     m_ulDuration((UINT32)-1),
  88.     m_ulMaxDuration((UINT32)-1),
  89.     m_ulEndOffset((UINT32)-1),
  90.     m_ulEndSync((UINT32)-1),
  91.     m_ulRepeatValue(1),
  92.     m_ulTimestamp(0),
  93.     m_bInsertedIntoTimeline(FALSE),
  94.     m_bIndefiniteDuration(FALSE),
  95.     m_nBeginEventSourceTag(SMILEventSourceNone),
  96.     m_nEndEventSourceTag(SMILEventSourceNone),
  97.     m_nEndsyncEventSourceTag(SMILEventSourceNone),
  98.     m_pHandler(0),
  99.     m_pTimelineElement(NULL)
  100. {
  101.     m_pHyperlinks = new CHXSimpleList;
  102. }
  104. CSmil1Element::~CSmil1Element()
  105. {
  106.     HX_DELETE(m_pHyperlinks);
  107.     HX_DELETE(m_pTimelineElement);
  108. }
  110. void
  111. CSmil1Element::addDuration(UINT32 ulDuration)
  112. {
  113.     // default add duration just attempts to add it to it's parent
  114.     m_ulDuration = ulDuration;
  115.     if(m_pNode->m_pParent && m_pNode->m_pParent->m_pElement)
  116.     {
  117. m_pNode->m_pParent->m_pElement->addDuration(m_ulDuration);
  118.     }
  119. }
  121. void
  122. CSmil1Element::addElement(CSmil1Element* pElement,
  123.     UINT32& ulBeginOffset, UINT32& ulDuration)
  124. {
  125. }
  128. /*
  129.  * CSmil1RootLayout methods
  130.  */
  131. CSmil1RootLayout::CSmil1RootLayout(SMIL1Node* pNode):
  132.     CSmil1Element(pNode),
  133.     m_ulHeight(0),
  134.     m_ulWidth(0),
  135.     m_bWidthUnspecified(TRUE),
  136.     m_bHeightUnspecified(TRUE),
  137.     m_ulBgColor(0)
  138. {
  139.     m_overflow = "hidden";
  140. }
  142. CSmil1RootLayout::~CSmil1RootLayout()
  143. {
  144. }
  146. HX_RESULT
  147. CSmil1RootLayout::handleElement()
  148. {
  149.     HX_RESULT rc = HXR_OK;
  150.     if(m_pHandler)
  151.     {
  152. rc = m_pHandler->handleRootLayout(this);
  153.     }
  154.     return rc;
  155. }
  158. /*
  159.  * CSmil1Region methods
  160.  */
  162. CSmil1Region::CSmil1Region(SMIL1Node* pNode):
  163.     CSmil1Element(pNode),
  164.     m_zIndex(0),
  165.     m_ulBgColor(0),
  166.     m_bBgColorSet(FALSE)
  167. {
  168.     m_fit = "hidden";
  169. }
  171. CSmil1Region::~CSmil1Region()
  172. {
  173. }
  175. HX_RESULT
  176. CSmil1Region::handleElement()
  177. {
  178.     HX_RESULT rc = HXR_OK;
  179.     if(m_pHandler)
  180.     {
  181. rc = m_pHandler->handleRegion(this);
  182.     }
  183.     return rc;
  184. }
  186. /*
  187.  * CSmil1Meta methods
  188.  */
  189. CSmil1Meta::CSmil1Meta(SMIL1Node* pNode):
  190.     CSmil1Element(pNode)
  191. {
  192. }
  194. CSmil1Meta::~CSmil1Meta()
  195. {
  196. }
  198. HX_RESULT
  199. CSmil1Meta::handleElement()
  200. {
  201.     HX_RESULT rc = HXR_OK;
  202.     if(m_pHandler)
  203.     {
  204. rc = m_pHandler->handleMeta(this);
  205.     }
  206.     return rc;
  207. }
  209. /*
  210.  * CSmil1RendererPreFetch methods
  211.  */
  212. CSmil1RendererPreFetch::CSmil1RendererPreFetch(SMIL1Node* pNode):
  213.     CSmil1Element(pNode)
  214. {
  215. }
  217. CSmil1RendererPreFetch::~CSmil1RendererPreFetch()
  218. {
  219. }
  221. HX_RESULT
  222. CSmil1RendererPreFetch::handleElement()
  223. {
  224.     HX_RESULT rc = HXR_OK;
  225.     if(m_pHandler)
  226.     {
  227. rc = m_pHandler->handleRendererPreFetch(this);
  228.     }
  229.     return rc;
  230. }
  232. /*
  233.  * CSmil1EndLayout methods
  234.  */
  235. CSmil1EndLayout::CSmil1EndLayout():
  236.     CSmil1Element(NULL)
  237. {
  238. }
  240. CSmil1EndLayout::~CSmil1EndLayout()
  241. {
  242. }
  245. HX_RESULT
  246. CSmil1EndLayout::handleElement()
  247. {
  248.     HX_RESULT rc = HXR_OK;
  249.     if(m_pHandler)
  250.     {
  251. rc = m_pHandler->handleEndLayout(this);
  252.     }
  253.     return rc;
  254. }
  256. /*
  257.  * CSmil1MetaValues methods
  258.  */
  259. CSmil1MetaValues::CSmil1MetaValues():
  260.     CSmil1Element(NULL),
  261.     m_pValues(0)
  262. {
  263. }
  265. CSmil1MetaValues::~CSmil1MetaValues()
  266. {
  267.     HX_RELEASE(m_pValues);
  268. }
  270. /*
  271.  * CSmil1Source methods
  272.  */
  274. CSmil1Source::CSmil1Source(SMIL1Node* pNode):
  275.     CSmil1Element(pNode)
  276. {
  277. }
  279. CSmil1Source::~CSmil1Source()
  280. {
  281. }
  283. HX_RESULT
  284. CSmil1Source::handleElement()
  285. {
  286.     HX_RESULT rc = HXR_OK;
  287.     if(m_pHandler)
  288.     {
  289. rc = m_pHandler->handleSource(this);
  290.     }
  291.     return rc;
  292. }
  294. void
  295. CSmil1Source::setRange(const char* pRange)
  296. {
  297.     // parse smpte/npt ranges:
  298.     //    smpte:12:03:14.21-12:15:26.03
  299.     //   npt:3:02.5-4:38.6
  300.     //
  302.     char* pPtr = (char *)strstr(pRange, "npt:");
  303.     if(pPtr)
  304.     {
  305. pPtr += 4; // point to beginning of range
  306. char* pHyphen = (char *)strchr(pRange, '-'); // find '-'
  307. if(pHyphen > pPtr)
  308. {
  309.     NPTime beginTime((const char*)CHXString(pPtr, pHyphen-pPtr));
  310.     m_ulClipBegin = (UINT32)beginTime;
  311.     if(strlen(pHyphen+1) > 0)
  312.     {
  313. NPTime endTime((const char*)CHXString(pHyphen+1));
  314. m_ulClipEnd = (UINT32)endTime;
  315.     }
  316. }
  317. else if(pHyphen)
  318. {
  319.     NPTime endTime((const char*)CHXString(pHyphen+1));
  320.     m_ulClipEnd = (UINT32)endTime;
  321. }
  322.     }
  323.     else
  324.     {
  325. pPtr = (char *)strstr(pRange, "smpte:");
  326. if(pPtr)
  327. {
  328.     pPtr += 6; // point to beginning of range
  329.     char* pHyphen = (char *)strchr(pRange, '-'); // find '-'
  330.     if(pHyphen > pPtr)
  331.     {
  332. SMPTETimeCode beginTime = 
  333.     ((const char*)CHXString(pPtr, pHyphen-pPtr));
  334. m_ulClipBegin = (UINT32)beginTime;
  335. if(strlen(pHyphen+1) > 0)
  336. {
  337.     SMPTETimeCode endTime =
  338. ((const char*)CHXString(pPtr, pHyphen-pPtr));
  339.     m_ulClipEnd = (UINT32)endTime;
  340. }
  341.     }
  342.     else if(pHyphen)
  343.     {
  344. SMPTETimeCode endTime((const char*)CHXString(pHyphen+1));
  345. m_ulClipEnd = (UINT32)endTime;
  346.     }
  347. }
  348.     }
  349. }
  351. /*
  352.  * CSmil1SourceUpdate methods
  353.  */
  355. CSmil1SourceUpdate::CSmil1SourceUpdate():
  356.     CSmil1Element(NULL)
  357. {
  358. }
  360. CSmil1SourceUpdate::~CSmil1SourceUpdate()
  361. {
  362. }
  364. HX_RESULT
  365. CSmil1SourceUpdate::handleElement()
  366. {
  367.     HX_RESULT rc = HXR_OK;
  368.     if(m_pHandler)
  369.     {
  370. rc = m_pHandler->handleSourceUpdate(this);
  371.     }
  372.     return rc;
  373. }
  376. /*
  377.  * CSmil1ParElement methods
  378.  */
  380. CSmil1ParElement::CSmil1ParElement(SMIL1Node* pNode):
  381.     CSmil1Element(pNode)
  382. {
  383. }
  385. CSmil1ParElement::~CSmil1ParElement()
  386. {
  387. }
  389. /*
  390.  * CSmil1SeqElement methods
  391.  */
  392. CSmil1SeqElement::CSmil1SeqElement(SMIL1Node*  pNode):
  393.     CSmil1Element(pNode)
  394. {
  395. }
  397. CSmil1SeqElement::~CSmil1SeqElement()
  398. {
  399. }
  402. /*
  403.  * CSmil1AAnchor methods
  404.  */
  406. CSmil1AAnchorElement::CSmil1AAnchorElement(SMIL1Node* pNode):
  407.     CSmil1Element(pNode),
  408.     m_show("replace")
  409. {
  410. }
  412. CSmil1AAnchorElement::~CSmil1AAnchorElement()
  413. {
  414. }
  416. BOOL
  417. CSmil1AAnchorElement::isCurrentLink(UINT32 ulTimeOffset, 
  418.    UINT32 ulXOffset, UINT32 ulYOffset,
  419.    HXxRect regionRect)
  420. {
  421.     BOOL rc = TRUE;
  423.     // coords only - check for out of bounds region
  424.     UINT32 ulRegionWidth = regionRect.right - regionRect.left;
  425.     UINT32 ulRegionHeight = regionRect.bottom - regionRect.top;
  427.     if(ulXOffset > ulRegionWidth ||
  428. ulYOffset > ulRegionHeight)
  429.     {
  430. rc = FALSE;
  431.     }
  433.     if(m_href.GetLength() == 0)
  434.     {
  435. rc = FALSE;
  436.     }
  438.     return rc;
  439. }
  441. void
  442. CSmil1AAnchorElement::rescale(double dXScale, double dYScale,
  443.      BOOL bResetOriginalCoords)
  444. {
  445.     // nothing to do
  446. }
  448. void CSmil1AAnchorElement::rescaleAbsolute(double dXScale, double dYScale)
  449. {
  450.     // nothing to do
  451. }
  453. /*
  454.  * CSmil1Anchor methods
  455.  */
  457. CSmil1AnchorElement::CSmil1AnchorElement(SMIL1Node* pNode):
  458.     CSmil1AAnchorElement(pNode),
  459.     m_zIndex(0),
  460.     m_bTimeValueSet(FALSE),
  461.     m_bCoordsSet(FALSE),
  462.     m_ulLeftX(0),
  463.     m_ulOriginalLeftX(0),
  464.     m_bLeftXIsPercent(FALSE),
  465.     m_ulTopY(0),
  466.     m_ulOriginalTopY(0),
  467.     m_bTopYIsPercent(FALSE),
  468.     m_ulRightX((UINT32)-1),
  469.     m_ulOriginalRightX((UINT32)-1),
  470.     m_bRightXIsPercent(FALSE),
  471.     m_ulBottomY((UINT32)-1),
  472.     m_ulOriginalBottomY((UINT32)-1),
  473.     m_bBottomYIsPercent(FALSE)
  474. {
  475. }
  477. CSmil1AnchorElement::~CSmil1AnchorElement()
  478. {
  479. }
  481. void
  482. CSmil1AnchorElement::rescale(double dXScale, double dYScale,
  483.      BOOL bResetOriginalCoords)
  484. {
  485.     if(bResetOriginalCoords)
  486.     {
  487. m_ulLeftX = m_ulOriginalLeftX;
  488. m_ulRightX = m_ulOriginalRightX;
  489. m_ulTopY = m_ulOriginalTopY;
  490. m_ulBottomY = m_ulOriginalBottomY;
  491.     }
  492.     else
  493.     {
  494. if(!m_bLeftXIsPercent)
  495. {
  496.     m_ulLeftX = (UINT32)(dXScale * (double)m_ulLeftX);
  497. }
  498. if(!m_bRightXIsPercent)
  499. {
  500.     m_ulRightX = (UINT32)(dXScale * (double)m_ulRightX);
  501. }
  502. if(!m_bTopYIsPercent)
  503. {
  504.     m_ulTopY = (UINT32)(dYScale * (double)m_ulTopY);
  505. }
  506. if(!m_bBottomYIsPercent)
  507. {
  508.     m_ulBottomY = (UINT32)(dYScale * (double)m_ulBottomY);
  509. }
  510.     }
  511. }
  513. void CSmil1AnchorElement::rescaleAbsolute(double dXScale, double dYScale)
  514. {
  515.     if(!m_bLeftXIsPercent)
  516.     {
  517.         m_ulLeftX   = (UINT32) (dXScale * ((double) m_ulOriginalLeftX) + 0.5);
  518.     }
  519.     if(!m_bRightXIsPercent)
  520.     {
  521.         m_ulRightX  = (UINT32) (dXScale * ((double) m_ulOriginalRightX) + 0.5);
  522.     }
  523.     if(!m_bTopYIsPercent)
  524.     {
  525.         m_ulTopY    = (UINT32) (dYScale * ((double) m_ulOriginalTopY) + 0.5);
  526.     }
  527.     if(!m_bBottomYIsPercent)
  528.     {
  529.         m_ulBottomY = (UINT32) (dYScale * ((double) m_ulOriginalBottomY) + 0.5);
  530.     }
  531. }
  533. BOOL
  534. CSmil1AnchorElement::isCurrentLink(UINT32 ulTimeOffset, 
  535.    UINT32 ulXOffset, UINT32 ulYOffset,
  536.    HXxRect regionRect)
  537. {
  538.     UINT32 ulRegionWidth = regionRect.right - regionRect.left;
  539.     UINT32 ulRegionHeight = regionRect.bottom - regionRect.top;
  541.     if(m_href.GetLength() == 0)
  542.     {
  543. return FALSE;
  544.     }
  546.     // first check time offset
  547.     if(m_bTimeValueSet)
  548.     {
  549. BOOL bTimeOffsetValid = FALSE;
  550. BOOL bValidBegin = m_ulBeginOffset != (UINT32)-1;
  551. BOOL bValidEnd = m_ulEndOffset != (UINT32)-1;
  552. //[SMIL 1.0 compliance] the following variable and its use, below,
  553. // helps fix PR 26471.  We may have had only our delay set:
  554. BOOL bValidDelay = m_ulDelay != (UINT32)-1;
  556. if(bValidBegin  ||  bValidDelay)
  557. {
  558.     if(ulTimeOffset >= (bValidBegin?m_ulBeginOffset:m_ulDelay) )
  559.     {
  560. if(bValidEnd)
  561. {
  562.     if(ulTimeOffset <= m_ulEndOffset)
  563.     {
  564. bTimeOffsetValid = TRUE;
  565.     }
  566. }
  567. else
  568. {
  569.     bTimeOffsetValid = TRUE;
  570. }
  571.     }
  572. }
  573. else if(bValidEnd)
  574. {
  575.     if(ulTimeOffset <= m_ulEndOffset)
  576.     {
  577. bTimeOffsetValid = TRUE;
  578.     }
  579. }
  581. if(!bTimeOffsetValid)
  582. {
  583.     return FALSE;
  584. }
  585.     }
  587.     if(m_bCoordsSet)
  588.     {
  589. UINT32 ulLeftX = m_ulLeftX;
  590. UINT32 ulRightX = m_ulRightX;
  591. UINT32 ulTopY = m_ulTopY;
  592. UINT32 ulBottomY = m_ulBottomY;
  595. // normalize to pixel coords
  596. if(m_bLeftXIsPercent)
  597. {
  598.     ulLeftX = (UINT32)(((double)m_ulLeftX/100.0) * ulRegionWidth);
  599. }
  600. if(m_bRightXIsPercent)
  601. {
  602.     ulRightX = (UINT32)(((double)m_ulRightX/100.0) * ulRegionWidth);
  603. }
  604. if(m_bTopYIsPercent)
  605. {
  606.     ulTopY = (UINT32)(((double)m_ulTopY/100.0) * ulRegionHeight);
  607. }
  608. if(m_bBottomYIsPercent)
  609. {
  610.     ulBottomY = (UINT32)(((double)m_ulBottomY/100.0) * ulRegionHeight);
  611. }
  613. if(ulXOffset >= ulLeftX &&
  614.    ulXOffset <= ulRightX &&
  615.    ulYOffset >= ulTopY &&
  616.    ulYOffset <= ulBottomY)
  617. {
  618.     return TRUE;
  619. }
  620. else
  621. {
  622.     return FALSE;
  623. }
  624.     }
  625.     else if(ulXOffset > ulRegionWidth ||
  626.     ulYOffset > ulRegionHeight)     
  627.     // assume time OK, coords OK if within bounds of region
  628.     {
  629. return FALSE;
  630.     }
  632.     return TRUE;
  633. }
  635. /*
  636.  * CSmil1AddGroup methods
  637.  */
  639. CSmil1AddGroup::CSmil1AddGroup():
  640.     CSmil1Element(NULL),
  641.     m_nGroup(0),
  642.     m_pValues(NULL),
  643.     m_nTotalTracks(0),
  644.     m_nInitTracks(0),
  645.     m_ulDuration((UINT32)-1)
  646. {
  647. }
  649. CSmil1AddGroup::~CSmil1AddGroup()
  650. {
  651.     HX_RELEASE(m_pValues);
  652. }
  654. HX_RESULT
  655. CSmil1AddGroup::handleElement()
  656. {
  657.     HX_RESULT rc = HXR_OK;
  658.     if(m_pHandler)
  659.     {
  660. rc = m_pHandler->handleAddGroup(this);
  661.     }
  662.     return rc;
  663. }