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

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

Symbian

开发平台：

Visual C++

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