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

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

Symbian

开发平台：

C/C++

smlelem.h：源码内容
  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. #ifndef _SMLELEM_H_
  37. #define _SMLELEM_H_
  39. #define WAY_IN_THE_FUTURE  1981342000 /*1981342000 is 22d+22h+22m+22s */
  40. #if !defined(MAX_LONG32)
  41. #define MAX_LONG32  0x7FFFFFFF
  42. #endif
  44. // /This is used for passing invalid coord value for firing a link when an
  45. // accesskey event occurs (and no mouse coords are involved): 
  46. #define ANCHOR_POS_DONTCARE ((UINT16)-1)
  48. // /This is used to simplify event processing since accesskey events have no
  49. // element that raises them, they have no element ID.  The following is used
  50. // for all accesskey events that have no ID, and it starts with a number to
  51. // make sure it's an illegal XML id and thus won't be used in a SMIL file:
  52. #define ACCESSKEY_EVENT_FAKE_ID_STRING  "21yrsOld__accesskey_fake_id"
  55. // Forward declarations
  56. typedef _INTERFACE IHXValues IHXValues;
  57. typedef _INTERFACE IHXBuffer IHXBuffer;
  58. class CSmilElement;
  59. class CSmilAddGroup;
  60. class CSmilRootLayout;
  61. class CSmilRegion;
  62. class CSmilRegPoint;
  63. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  64. class CSmilViewport;
  65. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  66. class CSmilSource;
  67. class CSmilMeta;
  68. class CSmilMetadata;
  69. class CSmilEndLayout;
  70. class CSmilRendererPreFetch;
  71. class CSmilSourceUpdate;
  72. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  73. class CSmilTransition;
  74. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  75. class CSmilAnimateElement;
  76. class CSmilCustomTest;
  77. class SMILNode;
  78. class CSmilParser;
  79. class SmilTimeValue;
  80. class CHXString;
  81. class CSmilTimelineElement;
  82. class CHXSimpleList;
  83. class CAttr;
  84. class CHXStack;
  85. class CSmilElement;
  87. class CSmilElementHandler
  88. {
  89. public:
  90.     virtual HX_RESULT handleAddGroup(CSmilAddGroup* pAddGroup) = 0;
  91.     virtual HX_RESULT handleRootLayout(CSmilRootLayout* pRootLayout) = 0;
  92.     virtual HX_RESULT handleRegion(CSmilRegion* pRegion) = 0;
  93.     virtual HX_RESULT handleRegPoint(CSmilRegPoint* pRegPoint) = 0;
  94. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  95.     virtual HX_RESULT handleViewport(CSmilViewport* pView) = 0;
  96. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  97.     virtual HX_RESULT handleSource(CSmilSource* pSource) = 0;
  98.     virtual HX_RESULT handleMeta(CSmilMeta* pMeta) = 0;
  99.     virtual HX_RESULT handleMetadata(CSmilMetadata* pMetadata) = 0;
  100.     virtual HX_RESULT handleEndLayout(CSmilEndLayout* pEndLayout) = 0;
  101.     virtual HX_RESULT handleRendererPreFetch(CSmilRendererPreFetch* pRend) = 0;
  102.     virtual HX_RESULT handleSourceUpdate(CSmilSourceUpdate* pUpdate) = 0;
  103. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  104.     virtual HX_RESULT handleTransition(CSmilTransition* pTrans) = 0;
  105. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  106.     virtual HX_RESULT handleTrackRemoval(const char* pID, INT32 nGroup) = 0;
  107.     virtual HX_RESULT handleTrackPausing(SMILNode* pNode,
  108. LONG32 lTimeOfPause,
  109. SMILPriorityClassPauseDisplay pauseDisplay,
  110. const char* pIdOfPauser) = 0;
  111.     virtual HX_RESULT handleTrackResuming(const char* pID, INT32 nGroup) = 0;
  112. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  113.     virtual HX_RESULT handleAnimate(CSmilAnimateElement* pAnimate) = 0;
  114. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  115.     virtual HX_RESULT handleRemoveTimeUpdate(CSmilElement* pElement, UINT32 ulRemoveTime) = 0;
  116.     virtual HX_RESULT handleExternalMediaMarkerFile(CSmilElement* pElement,
  117.                                                     const char*   pszID,
  118.                                                     const char*   pszExternalFileName,
  119.                                                     const char*   pszRelativeSource) = 0;
  120.     virtual HX_RESULT resolveGroupDurToOuterTimeContainerDur(UINT32 ulGroupIndex,
  121.      UINT32 ulGroupTimeContainerDuration) = 0;
  122.     virtual HX_RESULT GetCurGroupDuration(REF(UINT32) ulCurGrpDur) = 0;
  123. };
  125. class CSmilElement
  126. {
  127. public:
  128.     CSmilElement(SMILNode* pNode);
  129.     virtual ~CSmilElement();
  131.     virtual void      addDuration(UINT32 ulDuration);
  132.     virtual void      addElement(CSmilElement* pElement,
  133.                                  UINT32&       ulStartTime,
  134.                                  UINT32&       ulDuration);
  135.     virtual HX_RESULT handleElement() { return HXR_OK; }
  136.     virtual HX_RESULT setBeginTime(CSmilParser* pParser);
  137.     virtual HX_RESULT setEndTime(CSmilParser* pParser);
  138.     virtual void      prepForRestart(BOOL bParentIsRestarting, LONG32 lWhen);
  139.     virtual void      prepForPauseInExcl(LONG32 lCurTime);
  140.     virtual void      prepForResumeInExcl();
  141.     virtual void      prepForStopInExcl(LONG32 lCurTime);
  142.     virtual void      prepForDeferralInExcl(UINT32 lCurTime);
  143.     virtual BOOL      isPausedInExcl() { return m_bIsPausedInExcl; }
  144.     virtual BOOL      isDeferredInExcl() { return m_bIsDeferredInExcl; }
  145.     virtual BOOL      isStoppedInExcl() { return m_bIsStoppedInExcl; }
  146.     virtual HX_RESULT getBeginTimeValue(REF(SmilTimeValue*) pValue);
  147.     virtual HX_RESULT getEndTimeValue(REF(SmilTimeValue*) pValue);
  149.     // /These were added in order to easily calculate when an already-
  150.     // inserted-into-the-timeline element *actually* begins and ends so
  151.     // that doing such things as freezing and holding can be done:
  152.     virtual HX_RESULT getCurrentScheduledStartTime(
  153.     REF(ULONG32) ulActualStartTime);
  154.     virtual HX_RESULT getCurrentScheduledStopTime(
  155.     REF(ULONG32) ulActualStopTime);
  157.     // /Note: pValue, as well as the two lists, is|are filled with either
  158.     // begin or end time|times, depending on the listType value:
  159.     virtual HX_RESULT getNextResolvedTimeValue(REF(SmilTimeValue*) pValue,
  160.                                                INT32 lCurTimeInGroupTime,
  161.                                                INT32 lCurTimeInSyncBaseTime,
  162.                                                SmilTimingListType  listType,
  163.                                                CHXSimpleList*
  164.        pListOfAllResolvedTimes);
  165.     virtual HX_RESULT resolveEventTimeValues(INT32              lCurTime,
  166.                                              const char*        pEventName,
  167.                                              const char*        pEventElementId,
  168.                                              SmilTimingListType listType,
  169.                                              REF(BOOL)          bATimeWasResolved);
  170.     virtual HX_RESULT resolveSyncArcTimeValues(INT32              lResolvedToTime,
  171.                                                const char*        pSyncBaseElementId,
  172.                                                SmilTimingListType listType,
  173.                                                REF(BOOL)          bATimeWasResolved,
  174.        BOOL bMoveNewlyResolvedsToPendingTimesList,
  175.        CSmilParser* pParser);
  176.     virtual HX_RESULT getParentRestartDefault();
  177.     virtual void      updateRemoveTime(UINT32 ulRemoveTime);
  178.     virtual void      handleXMMF(const char* pszID, const char* pszXMMFile, const char* pszSrc);
  179.     virtual BOOL      hasEventBasedBeginTime();
  180.     virtual BOOL      hasEventBasedEndTime();
  181.     virtual CSmilElement* getSyncAncestorElement();
  183.     // /Use of the new method fixes PR 79699 and PR 8XXYZ (PR 63622 part 3,
  184.     // revisited) by making sure that the duration passed to
  185.     // resetTimelineElementDuration() is in local time coords, not syncbase
  186.     // time coord (i.e., m_ulDuration may or may not include the delay beyond
  187.     // the syncbase.  This method returns the duration from the element's
  188.     // begin to its end, w/o any delay:
  189.     ULONG32 getPureDuration();
  191.     // /This method goes through the m_pEndTimeList to see if there's an
  192.     // event-arc end time or other unresolved end time; this is important
  193.     // for use in the algorithm for determining whether or not something
  194.     // should restart (see SMIL 2.0 Spec Timing Module's getNextInterval()
  195.     // pseudocode):
  196.     BOOL hasUnresolvedEndTime();
  198.     // /This method helps fix PR 50660 (par version) and PR 62408: to make
  199.     // sure restarted track doesn't get treated as a repeat track in
  200.     // handleSource(), it calls this and uses the return val to decide; the
  201.     // m_bIsRestarting is reset to FALSE in case this element does have
  202.     // a repeat so the repeats will also restart:
  203.     BOOL IsRestartingAndNotRepeating() { BOOL bIs=m_bIsRestarting;
  204.                                          m_bIsRestarting=FALSE; return bIs;}
  206.     HX_RESULT GetElementProperties(REF(IHXValues*) pProperties);
  208.     void checkElementFillBehavior();
  209.     
  210.     // /NOTE: all values below are for the currently-active (or, if this
  211.     // element is not active on the timeline currently, the next-to-be
  212.     // active) "interval" (see SMIL 2.0 Timing module for details on
  213.     // how a "current interval" is defined and computed).  Multiple begin
  214.     // and end times are stored in the m_pBeginTimeList and m_pEndTimeList,
  215.     // respectively.  When a new one from that list becomes the active one,
  216.     // the following vars may change (which happens *during* playback):
  217.     SMILNode*             m_pNode;
  218.     UINT32                m_ulClipBegin;           // start of clip
  219.     UINT32                m_ulAuthoredClipBegin;   // explicitly-authored clipBegin value
  220.     UINT32                m_ulClipEnd;             // clip end time
  221.     INT32                 m_lBeginOffset;          // clip delay
  222.     ULONG32   m_ulBeginOffsetFromSyncBase;
  223.     UINT32                m_ulDelay;               // presentation delay
  224.     // /NOTE: this may include delay beyond syncbase.  getPureDuration()
  225.     // returns the duration from the element's begin to its end, w/o delay:
  226.     UINT32                m_ulDuration;            // clip duration
  227.     UINT32                m_ulOriginalDuration;    // value dur attribute if dur is specified.
  228.     UINT32                m_ulDurationInAddTrack;
  229.     UINT32                m_ulMaxDuration;
  230.     UINT32                m_ulMaxActiveDur;        // as set by the "min" attribute. deflt=indef
  231.     UINT32                m_ulMinActiveDur;        // as set by the "min" attribute. default=0.
  232.     UINT32                m_ulAuthoredDur;         // as set by the "dur" attribute.
  233.     INT32                 m_lEndOffset;
  234.     UINT32                m_ulAnticipatedPauseDur;
  235.     UINT32                m_ulEndSync;
  236.     ULONG32   m_ulStopTimeInExcl;
  237.     ULONG32               m_ulLongSyncArcBeginInGroupTime;
  238.     double                m_fRepeatValue;
  239.     UINT32                m_ulTimestamp;           // timestamp to send packet
  240.     SmilElementRestart    m_restartBehavior;
  241.     SmilElementRestart    m_restartDefaultBehavior;
  242.     ULONG32               m_ulSyncTolerance;
  243.     ULONG32               m_ulSyncToleranceDefault;
  244.     SMILSyncBehaviorType  m_syncBehavior;
  245.     SMILSyncBehaviorType  m_syncBehaviorDefault;
  246.     CHXString             m_sensitivityToMouseEvents;
  247.     CHXString             m_title;
  248.     CHXString             m_author;
  249.     CHXString             m_copyright;
  250.     CHXString             m_abstract;
  251.     CHXString             m_alt;
  252.     CHXString             m_longdesc;
  253.     ULONG32               m_ulReadIndex;
  254.     SMILEventSourceTag    m_nBeginEventSourceTag;
  255.     CHXString             m_BeginEventSourceID;
  256.     INT32                 m_lBeginEventClockValue;
  257.     SMILEventSourceTag    m_nEndEventSourceTag;
  258.     CHXString             m_EndEventSourceID;
  259.     INT32                 m_lEndEventClockValue;
  260.     SMILEventSourceTag    m_nEndsyncEventSourceTag;
  261.     CHXString             m_EndsyncEventSourceID;
  262.     CSmilTimelineElement* m_pTimelineElement;
  263.     CSmilElementHandler*  m_pHandler;
  264.     CHXSimpleList*        m_pHyperlinks;
  265.     CHXSimpleList*        m_pBeginTimeList;
  266.     CHXSimpleList*        m_pEndTimeList;
  267.     CHXString             m_beginTransition;
  268.     CHXString             m_endTransition;
  269.     FillType              m_eFill;
  270.     FillDefaultType       m_eFillDefault;
  271.     FillType              m_eActualFill;
  272.     EraseType             m_eErase;
  273.     UINT32                m_ulRemoveTime;
  274.     CHXString             m_customTestKey;
  275.     char*                 m_pszClipBeginMarkerName;
  276.     char*                 m_pszClipBeginExternalMarkerFileName;
  277.     char*                 m_pszClipEndMarkerName;
  278.     char*                 m_pszClipEndExternalMarkerFileName;
  279.     AccessErrorBehavior   m_eAccessErrorBehavior;
  280.     UINT32                m_ulTimeDeferralOccurred;
  281.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  282.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  283.     HX_BITFIELD           m_bBeginOffsetSet : 1;
  284.     HX_BITFIELD           m_bNegBeginOffsetAlreadyUsed : 1;
  285.     HX_BITFIELD           m_bCurBeginIsOffsetFromSyncBase : 1;
  286.     HX_BITFIELD           m_bCurEndClippedByParent : 1; // end clipped by parent end
  287.     HX_BITFIELD           m_bUseMediaDurForMinDur : 1; // flag for min="media"
  288.     HX_BITFIELD           m_bUseMediaDurForMaxDur : 1; // flag for max="media"
  289.     HX_BITFIELD           m_bHasExplicitEnd : 1;
  290.     HX_BITFIELD           m_bHasExplicitDur : 1;
  291.     HX_BITFIELD           m_bDurationIncludesDelayBeyondSyncbase : 1;
  292.     HX_BITFIELD           m_bAddDurationAlreadyDone : 1;
  293.     HX_BITFIELD           m_bEndOffsetSet : 1;
  294.     HX_BITFIELD           m_bInsertedIntoTimeline : 1; // TRUE when inserted
  295.     HX_BITFIELD           m_bHasBeenScheduled : 1;     // TRUE when inserted; doesn't ever reset, though
  296.     HX_BITFIELD           m_bIsPausedInExcl : 1; // TRUE when active+paused in excl
  297.     HX_BITFIELD           m_bIsDeferredInExcl : 1;
  298.     HX_BITFIELD           m_bIsStoppedInExcl : 1;
  299.     HX_BITFIELD           m_bCurrentSourceIsLive : 1;
  300.     HX_BITFIELD           m_bRendererInitialized : 1;
  301.     HX_BITFIELD           m_bIsRestarting : 1;
  302.     // /long sync arc begin resolved before parent delay resolved:
  303.     HX_BITFIELD           m_bAwaitingSyncAncestorBeginNotification : 1;
  304.     HX_BITFIELD           m_bIndefiniteDuration : 1;
  305.     HX_BITFIELD           m_bIndefiniteBegin : 1;
  306.     HX_BITFIELD           m_bIndefiniteEnd : 1;
  307.     HX_BITFIELD           m_bWallClockBegin : 1;
  308.     HX_BITFIELD           m_bWallClockEnd : 1;
  309.     HX_BITFIELD           m_bHasAtLeastOneEventBasedBegin : 1;
  310.     HX_BITFIELD           m_bHasAtLeastOneNonEventBasedBegin : 1;
  311.     HX_BITFIELD           m_bUsesExternalMediaMarkerFile : 1;
  312.     HX_BITFIELD           m_bClipBeginUsesMarker : 1;
  313.     HX_BITFIELD           m_bClipBeginMarkerResolved : 1;
  314.     HX_BITFIELD           m_bWaitingOnClipBeginToResolve : 1;
  315.     HX_BITFIELD           m_bClipEndUsesMarker : 1;
  316.     HX_BITFIELD           m_bClipEndMarkerResolved : 1;
  317.     HX_BITFIELD           m_bWaitingOnClipEndToResolve : 1;
  318. };
  320. class CSmilAddGroup: public CSmilElement
  321. {
  322. public:
  323.     CSmilAddGroup();
  324.     virtual ~CSmilAddGroup();
  326.     virtual HX_RESULT handleElement();
  328.     IHXValues* m_pValues;
  329.     INT32       m_nGroup;
  330.     INT32       m_nTotalTracks;
  331.     INT32       m_nInitTracks;
  332.     UINT32      m_ulDuration;
  333. };
  335. class CSmilRootLayout: public CSmilElement
  336. {
  337. public:
  338.     CSmilRootLayout(SMILNode* pNode);
  339.     virtual ~CSmilRootLayout();
  341.     virtual HX_RESULT handleElement();
  343.     double         m_dWidth;
  344.     CSS2Type       m_eWidthType;
  345.     double         m_dHeight;
  346.     CSS2Type       m_eHeightType;
  347.     UINT32         m_ulBackgroundColor;
  348.     CSS2Type       m_eBackgroundColorType;
  349.     ResizeBehavior m_eResizeBehavior;
  350.     ContextWindow  m_eContextWindow;
  351. };
  353. class CSmilRegion: public CSmilElement
  354. {
  355. public:
  356.     CSmilRegion(SMILNode* pNode);
  357.     virtual ~CSmilRegion();
  359.     virtual HX_RESULT handleElement();
  361.     LayoutRect     m_Rect;
  362.     INT32          m_lZIndex;
  363.     CSS2Type       m_eZIndexType;
  364.     Fit            m_eFit;
  365.     ShowBackground m_eShowBackground;
  366.     UINT32         m_ulBackgroundColor;
  367.     CSS2Type       m_eBackgroundColorType;
  368.     double         m_dSoundLevel;
  369.     CHXString      m_RegionName;
  370.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  371.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  372.     HX_BITFIELD    m_bRegionNameSpecified : 1;
  373. };
  375. class CSmilRegPoint: public CSmilElement
  376. {
  377. public:
  378.     CSmilRegPoint(SMILNode* pNode);
  379.     virtual ~CSmilRegPoint();
  381.     virtual HX_RESULT handleElement();
  383.     RegPoint m_RegPoint;
  384. };
  386. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  388. class CSmilViewport: public CSmilElement
  389. {
  390. public:
  391.     CSmilViewport(SMILNode* pNode);
  392.     virtual ~CSmilViewport();
  394.     virtual HX_RESULT handleElement();
  396.     UINT32         m_ulBackgroundColor;
  397.     CSS2Type       m_eBackgroundColorType;
  398.     double         m_dWidth;
  399.     CSS2Type       m_eWidthType;
  400.     double         m_dHeight;
  401.     CSS2Type       m_eHeightType;
  402.     ViewportOpen   m_eOpen;
  403.     ViewportClose  m_eClose;
  404.     ResizeBehavior m_eResizeBehavior;
  405.     ContextWindow  m_eContextWindow;
  406. };
  408. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  410. class CSmilMeta: public CSmilElement
  411. {
  412. public:
  413.     CSmilMeta(SMILNode* pNode);
  414.     virtual ~CSmilMeta();
  416.     virtual HX_RESULT handleElement();
  418.     CHXString m_name;
  419.     CHXString m_content;
  420. };
  422. class CSmilMetadata: public CSmilElement
  423. {
  424. public:
  425.     CSmilMetadata(SMILNode* pNode);
  426.     virtual ~CSmilMetadata();
  428.     virtual HX_RESULT handleElement();
  429. };
  431. class CSmilRendererPreFetch: public CSmilElement
  432. {
  433. public:
  434.     CSmilRendererPreFetch(SMILNode* pNode);
  435.     virtual ~CSmilRendererPreFetch();
  437.     virtual HX_RESULT handleElement();
  439.     CHXString m_mimeType;
  440. };
  442. class CSmilEndLayout: public CSmilElement
  443. {
  444. public:
  445.     CSmilEndLayout();
  446.     virtual ~CSmilEndLayout();
  448.     virtual HX_RESULT handleElement();
  449. };
  451. class CSmilMetaValues: public CSmilElement
  452. {
  453. public:
  454.     CSmilMetaValues();
  455.     virtual ~CSmilMetaValues();
  457.     IHXValues* m_pValues;
  458. };
  460. class CSmilCustomTest: public CSmilElement
  461. {
  462. public:
  463.     CSmilCustomTest(SMILNode* pNode);
  464.     virtual ~CSmilCustomTest();
  466.     CHXString m_uid;
  467.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  468.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  469.     HX_BITFIELD m_bDefaultState : 1;
  470.     HX_BITFIELD m_bOverrideVisible : 1;
  471. };
  474. class CSmilSource: public CSmilElement
  475. {
  476. public:
  477.     CSmilSource(SMILNode* pNode);
  478.     virtual ~CSmilSource();
  480.     virtual HX_RESULT handleElement();
  481.     void              setRange(const char* pRange);
  483.     CHXString    m_src;
  484.     CHXString    m_region;
  485.     ULONG32      m_ulPrefetchAmount;
  486.     PrefetchType m_typeOfPrefetchAmount;
  487.     UINT32       m_ulColor;
  488.     CSS2Type     m_eColorType;
  489.     LayoutRect   m_Rect;
  490.     INT32        m_lZIndex;
  491.     CSS2Type     m_eZIndexType;
  492.     Fit          m_eFit;
  493.     UINT32       m_ulBackgroundColor;
  494.     CSS2Type     m_eBackgroundColorType;
  495.     CHXString    m_RegPoint;
  496.     RegAlign     m_ePredefRegPoint;
  497.     RegAlign     m_eRegAlign;
  498.     UINT32       m_ulBackgroundOpacity;
  499.     UINT32       m_ulMediaOpacity;
  500.     UINT32       m_ulChromaKey;
  501.     UINT32       m_ulChromaKeyTolerance;
  502.     UINT32       m_ulChromaKeyOpacity;
  503.     CHXString    m_MediaRepeat;
  504.     HandledBy    m_eHandledBy;
  505.     ULONG32      m_ulLinkTargetDestnLevel_pct;
  506.     ULONG32      m_ulLinkTargetSourceLevel_pct;
  507.     CHXString    m_Handler;
  508.     CHXString    m_HandlerID;
  509.     CHXString    m_HandlerFor;
  510.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  511.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  512.     HX_BITFIELD  m_bFitSpecified : 1;
  513.     HX_BITFIELD  m_bBackgroundColorSpecified : 1;
  514.     HX_BITFIELD  m_bRegPointIsPredef : 1;
  515.     HX_BITFIELD  m_bRegAlignSpecified : 1;
  516.     HX_BITFIELD  m_bBackgroundOpacitySpecified : 1;
  517.     HX_BITFIELD  m_bMediaOpacitySpecified : 1;
  518.     HX_BITFIELD  m_bChromaKeySpecified : 1;
  519.     HX_BITFIELD  m_bAudioDeviceReflushHintNeeded : 1;
  520. };
  522. class CSmilSourceUpdate: public CSmilElement
  523. {
  524. public:
  525.     CSmilSourceUpdate();
  526.     virtual ~CSmilSourceUpdate();
  528.     virtual HX_RESULT handleElement();
  530.     CHXString m_srcID;
  531.     UpdateTag m_updateTag;
  532.     UINT32    m_ulUpdatedDuration;
  533.     BOOL      m_bDurationIsPureOfDelay;
  534.     UINT32    m_ulUpdatedDelay;
  535. };
  537. class CSmilPriorityClassElement: public CSmilElement
  538. {
  539. public:
  540.     CSmilPriorityClassElement(SMILNode* pNode);
  541.     virtual ~CSmilPriorityClassElement();
  543.     SMILPriorityClassPauseDisplay m_pauseDisplay;
  544.     SMILPriorityClassPeersHigherLowerVal m_peers;
  545.     SMILPriorityClassPeersHigherLowerVal m_higher;
  546.     SMILPriorityClassPeersHigherLowerVal m_lower;
  547. };
  549. class CSmilAAnchorElement: public CSmilElement
  550. {
  551. public:
  552.     CSmilAAnchorElement(SMILNode* pNode);
  553.     virtual ~CSmilAAnchorElement();
  555.     virtual BOOL isCurrentLink(UINT32 ulTime,
  556.     UINT32  ulXOffset, UINT32 ulYOffset, HXxRect regionRect,
  557.     // /These 3 are ignored for <a> links:
  558.     BOOL bResizeBehaviorIsZoom,
  559.     double dZoomX, double dZoomY);
  560.     // /Tells whether the link is active at the current time (but doesn't
  561.     // do any spatial bounds checking):
  562.     virtual BOOL isLinkActiveAtTime(UINT32 ulTimeOffset,
  563.     REF(ULONG32)rulAnchorRelativeStartTime);
  565.     virtual void rescale(double dXScale, double dYScale,
  566.                          BOOL bResetOriginalCoords);
  568.     virtual BOOL isAAnchor() {return TRUE;}
  570.     CHXString         m_href;
  571.     CHXString         m_show; // /(new|pause|replace) Default is "replace".
  572.     UINT32            m_ulSourceLevel_pct; // /("0%"-"100%"); default is 100% (per DTD).
  573.     UINT32            m_ulDestinationLevel_pct; // /("0%"-"100%"); default is 100%.
  574.     SMILLinkPlaystate m_sourcePlaystate; // /(play|pause|stop); Default is:
  575.  // show=="new"?play:pause;
  576.     SMILLinkPlaystate m_destinationPlaystate; // /(play|stop); Default=play.
  577.     CHXString         m_actuate; // /(onLoad|onRequest) Default value is onRequest.
  578.     CHXString         m_accesskey; // /(an ISO10646 character.  Default unspecified)
  579.     UINT32            m_ulTabindex; // /((UINT32)-1) means value unspecified.
  580.     // /Region name or frame name for where to open the link; if one doesn't
  581.     // exist with that name, creates new one (think command:openwindow()):
  582.     CHXString         m_target; 
  583.     // /This is for RN-extension attribute which allows user to say
  584.     // which browser an "external" link should go to, namely the RealPlayer
  585.     // browser, or a truly external (OS default) browser:
  586.     CHXString         m_sendTo;
  587.     // /These are used for timing solely for the purposes of keeping track of
  588.     // when the link is active (clickable) and NOT for the purposes of
  589.     // constraining or otherwise affecting the times of child elements:
  590.     INT32             m_lAnchorBeginOffset;
  591.     INT32             m_lAnchorEndOffset;
  592.     ULONG32           m_ulAnchorDuration;
  593.     ULONG32           m_ulAnchorMinActiveDur;
  594.     ULONG32           m_ulAnchorMaxActiveDur;
  595.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  596.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  597.     HX_BITFIELD       m_bExternal : 1; // /(true|false) default is false.
  598.     // /This is TRUE if target="x" and "x" is the id of a region in the
  599.     // current presentation:
  600.     HX_BITFIELD       m_bTargetIsARegion : 1;
  601.     HX_BITFIELD       m_bAnchorBeginOffsetSet : 1;
  602.     HX_BITFIELD       m_bAnchorEndOffsetSet : 1;
  603.     HX_BITFIELD       m_bTimeValueSet : 1;
  604. };
  606. class CSmilAnchorVertex
  607. {
  608. public:
  609.     CSmilAnchorVertex() {m_lX=m_lY=0; m_bXIsPercent=m_bYIsPercent=FALSE;}
  610.     ~CSmilAnchorVertex() {};
  612.     INT32       m_lX;
  613.     INT32       m_lY;
  614.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  615.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  616.     HX_BITFIELD m_bXIsPercent : 1;
  617.     HX_BITFIELD m_bYIsPercent : 1;
  618. };
  620. class CSmilAnchorElement: public CSmilAAnchorElement
  621. {
  622. public:
  623.     CSmilAnchorElement(SMILNode* pNode);
  624.     virtual ~CSmilAnchorElement();
  626.     virtual BOOL isCurrentLink(UINT32 ulTime,
  627.     UINT32  ulXOffset, UINT32 ulYOffset, HXxRect regionRect,
  628.     BOOL bResizeBehaviorIsZoom,
  629.     double dZoomX, double dZoomY);
  630.     // /Tells whether the link is active at the current time (but doesn't
  631.     // do any spatial bounds checking):
  632.     virtual BOOL isLinkActiveAtTime(UINT32 ulTimeOffset,
  633.     REF(ULONG32)rulAnchorRelativeStartTime);
  635.     virtual void rescale(double dXScale, double dYScale,
  636.                          BOOL bResetOriginalCoords);
  638.     virtual BOOL isAAnchor() {return FALSE;}
  640.     // /This handles conversion of string of points ("0,0, 20,10, ...") to
  641.     // array of CSmilAnchorVertex's (vertices) in m_pVertexArray:
  642.     HX_RESULT convertRawPolyData(const char* pData);
  644.     // /This is for handling hit-testing in a "poly" (polygon) shape:
  645.     BOOL isPointInPolygon(INT32 lXOffset, INT32 lYOffset,
  646.     HXxRect regionRect,
  647.     double dZoomX, double dZoomY);
  649.     void deleteVertexArrays();
  651.     // /XXXEH- TODO: make these points be unsigned values because shapes
  652.     // can stick out of frame, and thus can be negative in places:
  653.     UINT32             m_ulLeftX;
  654.     UINT32             m_ulOriginalLeftX;
  655.     UINT32             m_ulTopY;
  656.     UINT32             m_ulOriginalTopY;
  657.     UINT32             m_ulRightX;
  658.     UINT32             m_ulOriginalRightX;
  659.     UINT32             m_ulBottomY;
  660.     UINT32             m_ulOriginalBottomY;
  661.     UINT32             m_ulRadius;
  662.     UINT32             m_ulOriginalRadius;
  663.     // /XXXEH- TODO: use these points for rectangles, too (but don't use the
  664.     // hit-test code for them as it is slower for rectangles):
  665.     // /The following three are for handling shape="poly":
  666.     CSmilAnchorVertex* m_pVertexArray;
  667.     CSmilAnchorVertex* m_pOriginalVertexArray;
  668.     UINT16        m_uiNumPoints;
  669.     CHXString          m_shape;
  670.     CHXString          m_fragmentID;
  671.     INT32              m_zIndex;
  672.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  673.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  674.     HX_BITFIELD        m_bCoordsSet : 1;
  675.     HX_BITFIELD        m_bLeftXIsPercent : 1;
  676.     HX_BITFIELD        m_bTopYIsPercent : 1;
  677.     HX_BITFIELD        m_bRightXIsPercent : 1;
  678.     HX_BITFIELD        m_bBottomYIsPercent : 1;
  679.     HX_BITFIELD        m_bRadiusIsPercent : 1;
  680. };
  682. enum
  683. {
  684.     kCalcModeDiscrete,
  685.     kCalcModeLinear,
  686.     kCalcModePaced
  687. #if defined(XXXMEH_SPLINE_ANIMATION)
  688.     ,kCalcModeSpline
  689. #endif
  690. };
  692. enum
  693. {
  694.     kAccumulateSum,
  695.     kAccumulateNone
  696. };
  698. enum
  699. {
  700.     kAdditiveSum,
  701.     kAdditiveReplace
  702. };
  704. enum
  705. {
  706.     kAnimTypeValues,
  707.     kAnimTypeFromTo,
  708.     kAnimTypeFromBy,
  709.     kAnimTypeBy,
  710.     kAnimTypeTo
  711. };
  713. #if defined(XXXMEH_SPLINE_ANIMATION)
  715. struct KeySpline
  716. {
  717.     double x1;
  718.     double y1;
  719.     double x2;
  720.     double y2;
  721. };
  723. typedef enum
  724. {
  725.     PathCmdTypeUnknown,
  726.     PathCmdTypeMoveTo,
  727.     PathCmdTypeLineTo,
  728.     PathCmdTypeHorzLineTo,
  729.     PathCmdTypeVertLineTo,
  730.     PathCmdTypeClosePath,
  731.     PathCmdTypeCubicBezierCurveTo
  732. } PathCmdType;
  734. class PathCmd
  735. {
  736. public:
  737.     PathCmd();
  738.     ~PathCmd();
  740.     PathCmdType m_eType;
  741.     BOOL        m_bRelative;
  742.     UINT32      m_ulNumCoords;
  743.     double*     m_pdCoord;
  744. };
  746. inline PathCmd::PathCmd()
  747. {
  748.     m_eType       = PathCmdTypeUnknown;
  749.     m_bRelative   = FALSE;
  750.     m_ulNumCoords = 0;
  751.     m_pdCoord     = NULL;
  752. }
  754. inline PathCmd::~PathCmd()
  755. {
  756.     HX_VECTOR_DELETE(m_pdCoord);
  757. }
  759. #endif
  761. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  763. class CSmilAnimateElement : public CSmilElement
  764. {
  765. public:
  766.     CSmilAnimateElement(SMILNode* pNode);
  767.     virtual ~CSmilAnimateElement();
  769.     virtual HX_RESULT handleElement();
  770.     // We override this since we handle repeat
  771.     // differently than sources do.
  772.     virtual HX_RESULT getCurrentScheduledStopTime(REF(ULONG32) ulActualStopTime);
  774.     UINT32      m_ulSimpleDuration;
  775.     UINT32      m_ulActiveDuration;
  776.     UINT32      m_ulADNoSpeed;
  777.     CHXString*  m_pTargetElementID;
  778.     SMILNodeTag m_eTargetElementTag;
  779.     UINT32      m_ulNumValues;
  780.     CAttr**     m_ppValue;
  781.     BYTE        m_ucAttributeName;
  782.     BYTE        m_ucCalcMode;
  783.     BYTE        m_ucAccumulate;
  784.     BYTE        m_ucAdditive;
  785.     BYTE        m_ucAnimationType;
  786.     double      m_dRepeatCount;
  787.     UINT32      m_ulRepeatDur;
  788.     double      m_dAccelerate;
  789.     double      m_dDecelerate;
  790.     double      m_dSpeed;
  791. #if defined(XXXMEH_SPLINE_ANIMATION)
  792.     UINT32      m_ulNumKeyTimes;
  793.     double*     m_pdKeyTime;
  794.     UINT32      m_ulNumKeySplines;
  795.     KeySpline*  m_pKeySpline;
  796.     UINT32      m_ulNumPathCmds;
  797.     PathCmd**   m_ppPathCmd;
  798.     UINT32      m_ulNumPathPoints;
  799. #endif
  800.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  801.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  802.     HX_BITFIELD m_bRepeatDurIsIndefinite : 1;
  803.     HX_BITFIELD m_bAutoReverse : 1;
  804.     HX_BITFIELD m_bIndefiniteSimpleDuration : 1;
  805.     HX_BITFIELD m_bIndefiniteActiveDuration : 1;
  806.     HX_BITFIELD m_bCancelAnimation : 1;
  807. };
  809. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  811. class CSmilParamElement : public CSmilElement
  812. {
  813. public:
  814.     CSmilParamElement(SMILNode* pNode);
  815.     virtual ~CSmilParamElement();
  817.     IHXBuffer*   m_pName;
  818.     IHXBuffer*   m_pValue;
  819.     ParamDelivery m_eDelivery;
  820. };
  822. class CSmilParElement: public CSmilElement
  823. {
  824. public:
  825.     CSmilParElement(SMILNode* pNode);
  826.     virtual ~CSmilParElement();
  827. };
  829. class CSmilSeqElement: public CSmilElement
  830. {
  831. public:
  832.     CSmilSeqElement(SMILNode* pNode);
  833.     virtual ~CSmilSeqElement();
  834. };
  836. class CSmilExclElement: public CSmilElement
  837. {
  838. public:
  839.     CSmilExclElement(SMILNode* pNode);
  840.     virtual ~CSmilExclElement();
  842.     CHXStack* m_pPauseStack;
  843. };
  845. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  847. class CSmilTransition: public CSmilElement
  848. {
  849. public:
  850.     CSmilTransition(SMILNode* pNode);
  851.     virtual ~CSmilTransition();
  853.     virtual HX_RESULT handleElement();
  855.     CHXString              m_Type;
  856.     CHXString              m_SubType;
  857.     double                 m_dStartProgress;
  858.     double                 m_dEndProgress;
  859.     TransitionDirection    m_eDirection;
  860.     UINT32                 m_ulFadeColor;
  861.     UINT32                 m_ulHorzRepeat;
  862.     UINT32                 m_ulVertRepeat;
  863.     UINT32                 m_ulBorderWidth;
  864.     UINT32                 m_ulBorderColor;
  865.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  866.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  867.     HX_BITFIELD            m_bBlendBorder : 1;
  868. };
  870. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  872. class CSmilBodyElement : public CSmilElement
  873. {
  874. public:
  875.     CSmilBodyElement(SMILNode* pNode);
  876.     virtual ~CSmilBodyElement();
  877. };
  879. #endif