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

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

Symbian

开发平台：

Visual C++

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