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

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

Symbian

开发平台：

C/C++

smlparse.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 _SMLPARSE_H_
  37. #define _SMLPARSE_H_
  39. #define MAX_PENDING_CHECK_CALLDEPTH 20
  41. /* <body dur="20s">[no sources]</body> is valid; we need to handle it: */
  42. #define DEFAULT_DUR_IF_NO_SOURCES_SCHEDULED   SMILTIME_INVALID
  44. // forward declarations
  45. typedef _INTERFACE IHXSystemRequired     IHXSystemRequired;
  46. typedef _INTERFACE IHXBuffer             IHXBuffer;
  47. typedef _INTERFACE IHXValues             IHXValues;
  48. typedef _INTERFACE IHXXMLParserResponse  IHXXMLParserResponse;
  49. typedef _INTERFACE IHXCommonClassFactory IHXCommonClassFactory;
  50. typedef _INTERFACE IHXXMLParser          IHXXMLParser;
  51. typedef void*                             LISTPOSITION;
  52. class CHXString;
  53. class SMILNodeList;
  54. class CSmilElement;
  55. class CHXSimpleList;
  56. class ErrorNotifier;
  57. class CSmilParser;
  58. class CSmilElementHandler;
  59. class SmilTimeValue;
  60. class CHXPtrArray;
  61. class CSmilAnchorElement;
  62. class CHXStack;
  63. class CSmilRegion;
  64. class CSmilRegPoint;
  65. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  66. class CSmilViewport;
  67. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  68. class CSmilTransition;
  69. class CSmilRootLayout;
  70. class CSmilMeta;
  71. class CSmilMetadata;
  72. class CSmilRendererPreFetch;
  73. class CSmilSource;
  74. class CSmilPriorityClassElement;
  75. class CSmilAAnchorElement;
  76. class CSmilSeqElement;
  77. class CSmilParElement;
  78. class CSmilExclElement;
  79. class CSmilAnimateElement;
  80. class CSmilParamElement;
  81. class CSmilCustomTest;
  82. class XMLError;
  83. class CHXMapLongToObj;
  84. class CHXMapStringToOb;
  85. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  86. class CRNBinaryMap;
  87. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  88. class CNamespaceInfo;
  89. class CSmilBodyElement;
  90. class CSmilTimelineElementManager;
  92. /* // /XXXEH- we can't do the following until the core starts notifying
  93. // us every time a repeated track begins:
  94. //#define XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED
  95. */
  98. #define NUM_SUPPORTED_SMIL_2_0_MODULE_NAMESPACES   55
  101. class SMILNamespace
  102. {
  103. public:
  104.     SMILNamespace(SMILNamespace* pNS);
  105.     SMILNamespace(const char* name, IHXBuffer* pVal);
  106.     virtual ~SMILNamespace();
  108.     char*       m_name;
  109.     IHXBuffer* m_pValue;
  110. };
  112. class SMILNode
  113. {
  114. public:
  115.     SMILNode();
  116.     virtual ~SMILNode();
  117. #if defined(XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED)
  118.     SMILNode(const SMILNode&, BOOL bKeepId=FALSE, CSmilParser* pParser = NULL);
  119. #else
  120.     SMILNode(const SMILNode&, BOOL bKeepId=FALSE, CSmilParser* pParser = NULL,
  121.              UINT32 ulRepeatNum=0);
  122. #endif
  124.     SMILNode* getFirstChild();
  125.     SMILNode* getNextChild();
  127.     CHXString      m_repeatid;
  128.     CHXString      m_id;
  129.     CHXString      m_name;
  130.     UINT32         m_num;    
  131.     SMILNodeTag    m_tag;
  132.     SMILNode*      m_pParent;
  133.     SMILNode*      m_pDependency;
  134.     SMILNodeList*  m_pNodeList;
  135.     IHXValues*    m_pValues;
  136.     CSmilElement*  m_pElement;
  137.     UINT16         m_nGroup;
  138.     RepeatTag      m_repeatTag;
  139.     CHXString      m_trackHint;
  140.     UINT32         m_ulTagStartLine;
  141.     UINT32         m_ulTagStartColumn;
  142.     UINT16         m_nPrefetchTrackNum;
  143.     double         m_fPartialPlayFactor;
  144.     UINT32         m_ulRepeatDur;
  145.     CHXSimpleList* m_pNamespaceList;
  146.     SMIL2Element   m_eElement;
  147.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  148.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  149.     HX_BITFIELD    m_bLastInGroup : 1;
  150.     HX_BITFIELD    m_bDelete : 1;
  151.     HX_BITFIELD    m_bSkipContent : 1;
  152.     HX_BITFIELD    m_bRepeatHandled : 1;
  153.     HX_BITFIELD    m_bIsSeqWrapperForRepeatElement : 1;
  154.     HX_BITFIELD    m_bIsOuterWrapperTimeContainer : 1;
  155.     HX_BITFIELD    m_bBeginHandledByWrapperParent : 1;
  156.     HX_BITFIELD    m_bEndHandledByWrapperParent : 1;
  157.     HX_BITFIELD    m_bMinHandledByWrapperParent : 1;
  158.     HX_BITFIELD    m_bMaxHandledByWrapperParent : 1;
  159.     HX_BITFIELD    m_bNeedToResolveRepeatDurVSRepeatCount : 1;
  160.     HX_BITFIELD    m_bCloseNode : 1;
  161.     HX_BITFIELD    m_bNamespacedElement : 1;
  162. private:
  163.     LISTPOSITION   m_curPosition;
  164. };
  166. class SMILNodeList: public CHXSimpleList
  167. {
  168. public:
  169.     SMILNodeList();
  170.     virtual ~SMILNodeList();
  172.     SMILNodeList* copy(SMILNode* pParent, BOOL bKeepId = FALSE, CSmilParser* pParser = NULL);
  174.     SMILNode* m_pParentNode;
  175. };
  177. class CNamespaceInfo
  178. {
  179. public:
  180.     CNamespaceInfo();
  181.     ~CNamespaceInfo();
  183.     char*              m_pszPrefix;
  184.     char*              m_pszURL;
  185.     SupportedNamespace m_eNamespace;
  186.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  187.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  188.     HX_BITFIELD        m_bImplemented : 1;
  189. };
  192. class CSmilParserResponse : public IHXXMLParserResponse,
  193.                             public ErrorNotifier
  194. {
  195. public:
  196.     CSmilParserResponse(CSmilParser* pParser);
  197.     virtual ~CSmilParserResponse();
  199.     // IUnknown methods
  200.     STDMETHOD(QueryInterface)    (THIS_ REFIID riid, void** ppvObj);
  201.     STDMETHOD_(ULONG32, AddRef)  (THIS);
  202.     STDMETHOD_(ULONG32, Release) (THIS);
  204.     // IHXXMLParserResponse methods
  205.     STDMETHOD(HandleStartElement)          (THIS_ const char* pName,
  206.                                                   IHXValues* pAttributes,
  207.                                                   UINT32      ulLineNumber,
  208.                                                   UINT32      ulColumNumber);
  209.     STDMETHOD(HandleEndElement)            (THIS_ const char* pName,
  210.                                                   UINT32      ulLineNumber,
  211.                                                   UINT32      ulColumNumber);
  212.     STDMETHOD(HandleCharacterData)         (THIS_ IHXBuffer* pBuffer,
  213.                                                   UINT32      ulLineNumber,
  214.                                                   UINT32      ulColumNumber);
  215.     STDMETHOD(HandleProcessingInstruction) (THIS_ const char* pTarget,
  216.                                                   IHXValues* pAttributes,
  217.                                                   UINT32      ulLineNumber,
  218.                                                   UINT32      ulColumNumber);
  219.     STDMETHOD(HandleUnparsedEntityDecl)    (THIS_ const char* pEntityName,
  220.                                                   const char* pSystemID,
  221.                                                   const char* pPublicID,
  222.                                                   const char* pNotationName,
  223.                                                   UINT32      ulLineNumber,
  224.                                                   UINT32      ulColumNumber);
  225.     STDMETHOD(HandleNotationDecl)          (THIS_ const char* pNotationName,
  226.                                                   const char* pSystemID,
  227.                                                   const char* pPublicID,
  228.                                                   UINT32      ulLineNumber,
  229.                                                   UINT32      ulColumNumber);
  230.     STDMETHOD(HandleComment)               (THIS_ const char* pComment,
  231.                                                   UINT32      ulLineNumber,
  232.                                                   UINT32      ulColumNumber);
  233.     STDMETHOD(HandleUnparsedDoctypeDecl)   (THIS_ const char* pName, 
  234.                                                   const char* pSystemID,
  235.                                                   const char* pPublicID, 
  236.                                                   UINT32      ulLineNumber,
  237.                                                   UINT32      ulColumNumber);
  238.     STDMETHOD(HandleDefault)               (THIS_ IHXBuffer* pBuffer,
  239.                                                   UINT32      ulLineNumber,
  240.                                                   UINT32      ulColumNumber);
  242.     // ErrorNotifer methods
  243.     HX_RESULT ErrorInLastTag(HX_RESULT   Error,
  244.                              const char* pErrorString,
  245.                              const char* pFrameString,
  246.                              UINT32      ulLineNumber,
  247.                              UINT32      ulLinePosition);
  248. private:
  249.     CSmilParser* m_pParser;
  250.     INT32        m_lRefCount;
  251.     SMILNode*    m_pCurrentNode;
  252. };
  254. struct ExternalEventInfo
  255. {
  256.     CHXString       m_EventBaseID;
  257.     CHXString       m_PrefixedEventName;
  258.     CHXString       m_EventName;
  259.     CNamespaceInfo* m_pInfo;
  260. };
  262. class CSmilParser
  263. {
  264. public:
  265.     CSmilParser(IUnknown* pContext);
  266.     virtual ~CSmilParser();
  268.     HX_RESULT            init(BOOL bStoreErrors = FALSE);
  269.     HX_RESULT            parse(IHXBuffer* pBuffer, BOOL bIsFinal);
  270.     HX_RESULT            parse(const char* pSmilText);
  271. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  272.     HX_RESULT            validateContentModel(UINT32 ulElement, SMILNodeList* pChildren);
  273.     HX_RESULT            validateNode(SMILNode* pNode);
  274.     HX_RESULT            validateCDATA(const char* pszStr) const;
  275.     HX_RESULT            validateIDREF(const char* pszStr) const;
  276.     HX_RESULT            validateNMTOKEN(const char* pszStr) const;
  277.     HX_RESULT            validateEnumerated(UINT32 ulElem, UINT32 ulAttr, const char* pszStr);
  278.     BOOL                 isXMLLetter(char c) const;
  279.     BOOL                 isXMLDigit(char c) const;
  280.     BOOL                 isXMLNameChar(char c) const;
  281.     BOOL                 isNamespacePrefixed(const char* pszStr);
  282.     HX_RESULT            normalizeAttribute(const char* pszStr,
  283.                                             BOOL        bIsCDATA,
  284.                                             REF(char*)  rpszNormal);
  285.     HX_RESULT            validateAttribute(UINT32 ulElement, UINT32 ulAttrib,
  286.                                            const char* pszStr, REF(char*) rpszNormStr);
  287.     HX_RESULT            validateElementName(SMILNode* pNode);
  288.     HX_RESULT            setupValidationNamespaces(SMILNode* pNode);
  289.     HX_RESULT            validateAgainstDTD();
  290.     HX_RESULT            checkExtensionElementNamespace(SMIL2Element eElem,
  291.                                                         SupportedNamespace eNS);
  292.     HX_RESULT            checkExtensionAttributeNamespace(SMIL2Attribute eAttr,
  293.                                                           SupportedNamespace eNS);
  294. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  295.     CNamespaceInfo*      getNamespaceInfo(const char* pszStr, REF(const char*) rpszAttr);
  296.     HX_RESULT            createElements();
  297.     HX_RESULT            durationResolved(const char* pID, UINT32 ulDuration,
  298.                                           BOOL bSetByParent=FALSE,
  299.                                           BOOL bDurationExtendingDueToPause=FALSE);
  300.     HX_RESULT            trackRemoved(const char* pID, UINT32 ulDuration);
  301.     HX_RESULT            adjustForNegativeOffset(const char* pID);
  302.     void                 insertTimelineElement(const char* pID, UINT32 ulDelay);
  303.     void                 resetTimelineElementDuration(const char* pID,
  304.                                                       UINT32 ulDuration,
  305.                                                       UINT32 ulPriorDuration);
  306.     void                 resetTimelineElementDelay(const char* pID, UINT32 ulDelay,
  307.                                                    UINT32 ulPriorDelay);
  308.     void                 resetTimeline();
  309.     HX_RESULT  prepForSeek(UINT32 ulOldTime, UINT32 ulNewTime);
  310.     HX_RESULT            handlePrefetchFinished(const char* pID, UINT32 ulTimeFinished);
  311.     UINT16               getFragmentGroup(const char* pFragment);
  312.     UINT32               getFragmentOffset(const char* pFragment,
  313.                                            BOOL& bFragFoundAndResolved,
  314.                                            BOOL bResolveBeginOfFragmentTarget=FALSE,
  315.                                            ULONG32 ulCurTime=0);
  316.     HX_RESULT            handleNextElement(CSmilElementHandler* pHandler);
  317.     HX_RESULT            setAllElementHandlers(CSmilElementHandler* pHandler);
  318.     SMILNode*            findFirstNode(SMILNodeTag tag);
  319.     SMILNode*            getFirstNodeChild(SMILNode* pNode);
  320.     SMILNode*            getPrevNode(SMILNode* pCurrentNode);
  321.     CSmilElement*        findElement(const char* pID);
  322.     SMILNode*            getNextNodeChild();
  323.     SMILNodeTag          getSyncTag(SMILNode* pNode);
  324.     void                 getPacketPending(UINT16 unStreamNumber);
  325.     HX_RESULT            addGlobalNamespace(const char* pNamespace, const char* pPrefix);
  326.     HX_RESULT            storeNamespaces(SMILNode* pNode);
  327.     HX_RESULT            addToNamespaceScope(SMILNode* pNode);
  328.     HX_RESULT            removeFromNamespaceScope(SMILNode* pNode);
  329.     BOOL                 isSupportedNonRNNamespace(const char* pNamespace);
  330.     HX_RESULT            addBeginTimeSyncElement(CSmilElement* pElement);
  331.     HX_RESULT            addEndTimeSyncElement(CSmilElement* pElement);
  332.     HX_RESULT            resolveSyncBaseElements();
  333.     HX_RESULT            handleExclDescendants();
  334.     HX_RESULT            addBeginEventElement(SmilTimeValue* pTimeVal);
  335.     HX_RESULT            tryToResolveBeginEndEvents(const char* pEventName,
  336.                                                     const char* pEventElementId,
  337.                                                     ULONG32     ulEventTime);
  338.     HX_RESULT            addEndEventElement(SmilTimeValue* pTimeVal);
  339.     HX_RESULT            addBeginMediaMarkerSyncElement(SmilTimeValue* pTmpVal);
  340.     HX_RESULT            addEndMediaMarkerSyncElement(SmilTimeValue* pTmpVal);
  341.     HX_RESULT            resolveMediaMarkerTime(const char* pszID,
  342.                                                 const char* pszMarkerName,
  343.                                                 UINT32      ulMarkerTime,
  344.                                                 REF(BOOL)   rbNeedHandleElements);
  345.     HX_RESULT            handlePendingScheduling(INT32 lCurTime,
  346.                                                  INT16 iCurrentGroupIndex,
  347.                                                  REF(BOOL) bSomeScheduleWasChanged,
  348.                                                  /*OUT*/ CHXSimpleList* pPauseDisplayElementHideList,
  349.                                                  /*OUT*/ CHXSimpleList* pPauseDisplayDisableElementList);
  350.     HX_RESULT            checkPendingBeginAndEndTimes(INT32     lCurTime,
  351.                                                       INT16 iCurrentGroupIndex,
  352.                                                       REF(BOOL) bREFSomeScheduleWasChanged,
  353.                                                       INT32     lRecursionCount,
  354.                                                       /*OUT*/ CHXSimpleList* pPauseDisplayElementHideList,
  355.                                                       /*OUT*/ CHXSimpleList* pPauseDisplayDisableElementList,
  356.                                                       BOOL bDoHandleExclBeforePlaybackStarts);
  357.     HX_RESULT            insertElementWithPendingBeginOrEnd(CSmilElement*      pElement,
  358.                                                             INT32              lCurTime,
  359.                                                             SmilTimingListType listType);
  360.     void                 handleAllXMMFReferences();
  361.     CHXMapStringToOb*    findNextPendingOnLoadURL(UINT32 lCurTime);
  362.     BOOL                 hasActivateEventListener(const char* pMediaID,
  363.                                                   INT16 iCurrentGroupIndex);
  364.     const char*          getDefaultNamespace();
  365.     // note -- the pErr array returned has the same scope as the SMILParser 
  366.     // object
  367.     HX_RESULT            getErrors(CHXPtrArray** pErrs);
  368.     SMILNode*            getSyncAncestor(SMILNode* pNode);
  369.     // /NOTE: sync base is not always begin of sync ancestor; in a seq, it's
  370.     // end of prior sibling (if any), so this calculates all that:
  371.     virtual ULONG32      getSyncBaseTimeInGroupTimeCoords(SMILNode* pNode);
  373.     // /Tells whether any node all the way up to the root has specified
  374.     // ancestor tag:
  375.     BOOL                 hasAncestor(SMILNodeTag ancestor, SMILNode* pNode);
  377.     // Added to be able to quickly lookup <anchor> or <area> tags
  378.     // by id and not by the region they map to.
  379.     CSmilAnchorElement*  getAnchorOrAreaElement(const char* pID);
  380.     // XXXMEH - moved this from private to public so that we 
  381.     // could animate the coords attribute. This method is needed
  382.     // to parse the coords attribute.
  383.     HX_RESULT            parseAnchorCoords(const char*         pCoords,
  384.                                            CSmilAnchorElement* pAnchor);
  385.     BOOL                 presentationContainsASource() {return m_bContainsSource; }
  386.     BOOL                 presentationContainsInitiallyScheduledTrack() {
  387.                     return m_bContainsInitiallyScheduledTrack; }
  388.     ULONG32              presentationDurIfNoInitialTracksScheduled() {
  389.                             return m_ulDurIfNoInitialTracksScheduled; }
  390.     BOOL                 EstablishBeginTimeList();
  391.     BOOL                 EstablishEndTimeList();
  392.     BOOL                 EstablishBeginEventList();
  393.     BOOL                 EstablishEndEventList();
  394.     CHXSimpleList*       GetPendingBeginTimeList() {return m_pPendingBeginTimeList;}
  395.     CHXSimpleList*       GetPendingEndTimeList() {return m_pPendingEndTimeList;}
  396.     CHXSimpleList*       GetBeginEventList() {return m_pBeginEventList;}
  397.     CHXSimpleList*       GetEndEventList()   {return m_pEndEventList;}
  398.     BOOL                 isDuplicateEntry(CHXSimpleList* pList,
  399.                                           SmilTimeValue* pTimeValue);
  400.     HX_RESULT            addResumeEvent(SmilTimeValue* pTimeValue,
  401.                                         REF(BOOL) bOldResumeEventWasRemoved);
  402.     HX_RESULT            addUndeferEvent(SmilTimeValue* pTimeValue,
  403.                                         REF(BOOL) bOldUndeferEventWasRemoved);
  404.     HX_RESULT            addResumeOrUndeferEvent(SmilTimeValue* pTimeValue,
  405.                                         REF(BOOL) bOldSuchEventWasRemoved,
  406. BOOL bIsResumeEvent);
  407.     HX_RESULT            computeRemoveTime(const char* pszID,
  408.                                            REF(UINT32) rulRemoveTime);
  409.     void                 InitPersistent(UINT32 ulPersistentComponentID, IHXValues* pProperties);
  410.     BOOL                 isTimelineObject(SMILNode* pNode);
  411.     static BOOL          isMediaObject(SMILNode* pNode);
  412.     BOOL                 isNonMediaPlayableObject(SMILNode* pNode);
  413.     BOOL                 isTimeContainerObject(SMILNode* pNode);
  414.     UINT16               getNumGroups() const { return m_usNumGroups; }
  415.     const char*          getEnumAttrString(SMIL2Attribute eAttr, BYTE ucVal);
  416.     void                 setParseError(HX_RESULT rv) { m_lParseError = rv;   }
  417.     HX_RESULT            getParseError() const       { return m_lParseError; }
  418.     BOOL                 isAttributeAnimated(const char* pszElementID,
  419.                                              UINT32      ulAttrName);
  420.     SMIL2Element         getSMIL2Element(const char* pszStr);
  421.     SMIL2Attribute       getSMIL2Attribute(const char* pszStr);
  422.     void                 checkForExternalEvents();
  423.     BOOL                 anyExternalEvents(const char* pszID);
  424.     ExternalEventInfo*   getFirstExternalEvent(const char* pszID);
  425.     ExternalEventInfo*   getNextExternalEvent(const char* pszID);
  426.     void                 checkForEventHandlers();
  427.     AccessErrorBehavior  getAccessErrorBehavior(SMILNode* pNode);
  428.     UINT32               GetUniqueNumber() { return m_ulNextVar++; }
  430.     // CSmilParser static public member methods
  431.     static HX_RESULT     parseRegionDimension(const char*   pszStr,
  432.                                               REF(double)   rdValue,
  433.                                               REF(CSS2Type) reType);
  434.     static HX_RESULT     parseZIndex(const char*   pszStr,
  435.                                      REF(INT32)    rlValue,
  436.                                      REF(CSS2Type) reType);
  437.     static HX_RESULT     parseColor(const char*   pszStr,
  438.                                     REF(UINT32)   rulColor,
  439.                                     REF(CSS2Type) reType);
  440.     static HX_RESULT     parseFit(const char*   pszStr,
  441.                                   REF(Fit)      reValue);
  442.     static HX_RESULT     parseRegAlign(const char*   pszStr,
  443.                                        REF(RegAlign) reValue);
  444.     static HX_RESULT     parseOpacity(const char* pszStr, REF(UINT32) rulOpacity);
  445.     static HX_RESULT     parseFill(const char* pszStr, REF(FillType) reFill);
  446.     static HX_RESULT     getFillString(FillType eFill, REF(CHXString) rcFill);
  447.     static HX_RESULT     getEraseString(EraseType eErase, REF(CHXString) rcErase);
  448.     static HX_RESULT     parseFillDefault(const char* pszStr, REF(FillDefaultType) reFillDefault);
  449.     static HX_RESULT     parseAccelDecel(const char* pszStr, REF(double) rdVal);
  450. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  451.     static HX_RESULT     getDefaultTransitionSubType(const char* pszType, REF(CHXString) rcSubType);
  452.     static BOOL          isLegalTransitionType(const char* pszType);
  453.     static BOOL          isLegalTransitionSubType(const char* pszType, const char* pszSubType);
  454. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  455.     static HX_RESULT     parseMarkerURI(const char*    pszStr,
  456.                                         REF(CHXString) rcMarker,
  457.                                         REF(BOOL)      rbExternal,
  458.                                         REF(CHXString) rcExternalFileName);
  459.     static HX_RESULT     parseHandlerForID(const char*    pszStr,
  460.                                            REF(CHXString) rcHandlerID);
  461.     static HX_RESULT     parseAccessErrorBehavior(const char* pszStr,
  462.                                                   REF(AccessErrorBehavior) reErr);
  463. #if defined(XXXMEH_SPLINE_ANIMATION)
  464.     static HX_RESULT     parseKeyTimes(const char* pszVal, CSmilAnimateElement* pAnim);
  465.     static HX_RESULT     parseKeySplines(const char* pszVal, CSmilAnimateElement* pAnim);
  466.     static HX_RESULT     parseSVGPath(const char* pszVal, CSmilAnimateElement* pAnim);
  467. #endif
  468.     static BOOL          isDataURL(const char* pszURL);
  469.     static HX_RESULT     validateDataURL(const char* pszURL);
  470.     static void          addStringProperty(IHXValues* pValues,
  471.                                            IUnknown*   pContext,
  472.                                            const char* pszName,
  473.                                            const char* pszValue);
  475.     BOOL                 allTracksNeedReflushHint() { return m_bAllTracksNeedReflushHint; }
  477.     // CSmilParser public members    
  478.     CHXStack*     m_pNodeListStack;
  479.     SMILNodeList* m_pNodeList;
  480.     UINT32        m_ulErrorLineNumber;
  481.     UINT32        m_ulErrorColumnNumber;
  482.     IHXBuffer*   m_pErrorText;
  483.     IHXBuffer*   m_pDefaultNamespace;
  484.     UINT32        m_ulPersistentComponentDelay;
  485.     UINT32        m_ulPersistentComponentDuration;
  486.     CSmilTimelineElementManager* m_pTimelineElementManager;
  487.     friend class CSmilParserResponse;
  488. private:
  489.     void                   close();
  490.     void                   initRequireTags();
  491.     void    GetSystemScreenInfo(REF(UINT32) rulScreenHeight,
  492.        REF(UINT32) rulScreenWidth,
  493.        REF(UINT32) rulScreenBitDepth);
  494.     void                   getPreferences();
  495.     HX_RESULT              createHeadElements(SMILNodeList* pNodeList);
  496.     HX_RESULT              createSeqWrapper(SMILNodeList* pNodeList, BOOL bMakeInnerPar);
  497.     HX_RESULT              createBodyElements(SMILNodeList* pNodeList);
  498.     HX_RESULT              createElementForAnchorTarget(CSmilAAnchorElement* pAnchor,
  499.                                                        SMILNodeList* pNodeList);
  500. #if 0  /*XXXEH- I wrote this and then didn't need it but it may come in
  501.          handy later so #if(0) it out: */
  502.     BOOL                   hasNoSourceChildren(SMILNode* pNode);
  503. #endif
  504.     HX_RESULT              assignGroupIndexes(SMILNodeList* pNodeList);
  505.     HX_RESULT              assignGroupIndexOnPar(SMILNode* pNode, UINT16 nGroup);
  506.     HX_RESULT              assignGroupIndexOnSeq(SMILNode* pNode, UINT16& nGroup);
  507.     HX_RESULT              constructTimelineElements(SMILNodeList* pNodeList);
  508.     HX_RESULT              setInitialDelays(SMILNodeList* pNodeList);
  509.     void                   setInitialDelay(SMILNode* pNode);
  510.     void                   setInitialDelayOnSeq(SMILNode* pNode);
  511.     HX_RESULT              expandRepeatElements(SMILNodeList* pNodeList);
  512.     HX_RESULT              printBodyElements(SMILNodeList* pNodeList);
  513.     HX_RESULT              updateEventElements(SMILNodeList* pNodeList);
  514.     HX_RESULT              insertElementByTimestamp(CSmilElement* pElement);
  515.     HX_RESULT              addGroup(SMILNode* pNode);
  516.     HX_RESULT              insertGroups();
  517.     HX_RESULT              mapID(SMILNode* pNode, BOOL bOverWrite = FALSE);
  518.     HX_RESULT              mapChildrenIDs(SMILNodeList* pNodeList, BOOL bOverWrite = FALSE);
  519.     HX_RESULT              markRepeatReplica(SMILNodeList* pNodeList, RepeatTag repeatTag);
  521.     BOOL                   testAttributeFailed(SMILNode* pNode);
  522.     BOOL                   customTestFailed(SMILNode* pNode);
  523.     BOOL                   systemComponentFailed(IHXBuffer* pRequiredValue);
  524.     HX_RESULT              markTestAttributeNodes(SMILNodeList* pNodeList);
  525.     HX_RESULT              selectSwitchNodes(SMILNode* pNode);
  527.     BOOL                   inSeq(SMILNode* pNode);
  528.     HX_RESULT              createParent(SMILNode* pChildNode, SMILNodeTag tag,
  529.                                         SMILNode*& pParent, SMILNode*& pParentEnd);
  530.     void                   resolveTimestamps();
  531.     void                   resolveTimestamps(SMILNodeList* pNodeList);
  532.     UINT32                 getStartTime(SMILNode* pNode);
  533.     CSmilRegion*           makeRegion(SMILNode* pNode);
  534.     CSmilRegPoint*         makeRegPoint(SMILNode* pNode);
  535. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  536.     CSmilViewport*         makeViewport(SMILNode* pNode);
  537. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  538.     CSmilTransition*       makeTransition(SMILNode* pNode, REF(HX_RESULT) retVal);
  539.     CSmilRootLayout*       makeRootLayout(SMILNode* pNode);
  540.     CSmilMeta*             makeMeta(SMILNode* pNode);
  541.     CSmilMetadata*         makeMetadata(SMILNode* pNode);
  542.     CSmilCustomTest*       makeCustomTest(SMILNode* pNode,
  543.                                     REF(HX_RESULT) retVal);
  544.     CSmilRendererPreFetch* makeRendererPreFetch(SMILNode* pNode);
  545.     CSmilSource*           makeSource(SMILNode* pNode);
  546.     CSmilPriorityClassElement* makePriorityClassElement(SMILNode* pNode);
  547.     CSmilAAnchorElement*   makeAAnchorElement(SMILNode* pNode);
  548.     CSmilAnchorElement*    makeAnchorElement(SMILNode* pNode);
  549.     CSmilSeqElement*       makeSeqElement(SMILNode* pNode);
  550.     CSmilParElement*       makeParElement(SMILNode* pNode);
  551.     CSmilExclElement*      makeExclElement(SMILNode* pNode);
  552.     CSmilParamElement*     makeParamElement(SMILNode* pNode);
  553.     CSmilBodyElement*      makeBodyElement(SMILNode* pNode);
  554. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  555.     CSmilAnimateElement*   makeAnimateElement(SMILNode* pNode);
  556.     HX_RESULT              animSetupElement(CSmilAnimateElement* pAnim);
  557. #if defined(XXXMEH_SPLINE_ANIMATION)
  558.     HX_RESULT              checkSplineAnimation(CSmilAnimateElement* pAnim);
  559.     HX_RESULT              makeSVGPathExplicit(CSmilAnimateElement* pAnim);
  560. #endif
  561.     HX_RESULT              animCountValues(const char* pszStr, REF(char*)  rpStr,
  562.                                            REF(UINT32) rulNumValues, REF(char**) rppStr);
  563.     HX_RESULT              animParseValue(CSmilAnimateElement* pAnim,
  564.                                           const char*          pszVal,
  565.                                           UINT32               i);
  566. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  567.     SMILNode*              getSpecificAncestor(SMILNodeTag ancestor, SMILNode* pNode);
  568.     SMILNode*              findAnyActiveDescendant(SMILNode* pNode,
  569.                                LONG32 lCurTime, SMILNode* pButNotThisNode);
  570.     SMILNode*              findActiveChildOfAncestorExcl(SMILNode* pNode, LONG32 lCurTime);
  571.     SMILNode*              findLastDeferredChildOfAncestorExcl(
  572.                                    SMILNode* pInterruptingNode, LONG32 lCurTime);
  573.     SMILNode*              findLastDeferredDescendant(SMILNode* pNode,
  574.                                      LONG32 lCurTime,
  575.                                      SMILNode* pButNotThisNode,
  576.                                      SMILNode* pLastDeferredChild);
  577.     BOOL                   firstDependentChild(SMILNode* pNode);
  578.     SMILNode*              findFirstNode(SMILNodeList* pNodelist, SMILNodeTag tag);
  579.     // /Finds parent's next child; doesn't have to be a timeline element:
  580.     SMILNode*              findNextSibling(SMILNode* pNode);
  581.     SMILNode*              getTimelineDescendent(SMILNode* pParentNode, SMILNode* pSiblingNode);
  582.     SMILNode*              getTimelineDescendent(SMILNode* pParentNode);
  583.     const char*            assignID(const char* pPrefix);
  584.     HX_RESULT              parseDuration(const char*          pDuration,
  585.                                          CSmilElement*        pElement,
  586.                                          SMILSyncAttributeTag nTag);
  587.     HX_RESULT              parseMarkerClipBeginEnd(const char* pszStr,
  588.                                                    REF(char*)  rpszMarkerName,
  589.                                                    REF(char*)  rpszExtFileName);
  590.     HX_RESULT              adjustDuration(CSmilElement* pElement);
  591.     HX_RESULT              parseClockValue(const char* pValue, UINT32& ulClockValue);
  592.     HX_RESULT              parseSyncBehaviorVal(const char*          pSyncBhvrBuf,
  593.                                                 CSmilElement*        pElement,
  594.                                                 SMILSyncAttributeTag nTag);
  595.     HX_RESULT              parsePeersHigherLower(const char* pBuf,
  596.                                 CSmilPriorityClassElement* pPCElement,
  597.                                 SMILPriorityClassPeersHigherLowerAttrib nAttrib);
  598.     HX_RESULT              parsePauseDisplay(const char* pBuf,
  599.                                 CSmilPriorityClassElement* pPCElement);
  600.     BOOL                   inLanguagePreference(const char* pLang);
  601.     BOOL                   isRelativeURL(const char* pURL);
  602.     UINT8                  getColorElement(const char* pColorFragment, int len);
  603.     void                   handleXMLParserError(XMLError* pError);
  604.     void                   badAttributeError(SMILNodeTag tag,
  605.                                              const char* pNodeName,
  606.                                              UINT32      ulLineNumber,
  607.                                              BOOL        bJustStore);
  608.     void                   initTagAttributes();
  609.     void                   deleteTagAttributes();
  610.     BOOL                   isLegalAttribute(SMILNodeTag tag, const char* pAttrName);
  611.     HX_RESULT              storeError(HX_RESULT   errCode, 
  612.                                       const char* pErrorString, 
  613.                                       const char* pFrameString,
  614.                                       UINT32      ulLineNumber, 
  615.                                       UINT32      ulLinePosition,
  616.                                       BOOL        bXml = TRUE);
  617.     BOOL                   isEndTagObject(SMILNode* pNode);
  618.     const char*            removeSurroundingWhitespace(const char* pValue);
  619.     HX_RESULT              parseBeginEnd(const char*          pBuffer, 
  620.                                          CSmilElement*        pElement,
  621.                                          SMILSyncAttributeTag nTag);
  622.     HX_RESULT              parseSmil1SyncbaseValue(const char*          pCh, 
  623.                                                    CSmilElement*        pElement,
  624.                                                    SMILSyncAttributeTag nTag);
  625.     HX_RESULT              parseCoord(IHXBuffer* pBuf, REF(float) f);
  626.     HX_RESULT              parseDigit(IHXBuffer* pBuf, REF(UINT32) ul);
  627.     HX_RESULT              parseRestart(const char* pBuffer, CSmilElement* pElement);
  628.     HX_RESULT              parseRestartDefault(const char* pBuffer, CSmilElement* pElement);
  629.     HX_RESULT              parseSensitivity(const char* pszValue, CSmilElement* pSource);
  630.     FillDefaultType        getFillDefault(CSmilElement* pElement);
  631.     void                   resolveFillValue(CSmilElement* pElement);
  632.     BOOL                   isAttributeSpecified(CSmilElement* pElement, const char* pszAttr);
  633. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  634.     HX_RESULT              getNextTransitionEnd(CSmilElement* pElement, REF(UINT32) rulTime);
  635. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  636.     void                   initParsingMaps();
  637. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  638.     void                   processCollection(CRNBinaryMap* pMap,
  639.                                              UINT32        ulElement,
  640.                                              UINT32        ulCollection);
  641.     void                   deleteEnumAttrMaps();
  642.     void                   deleteReqAttrLists();
  643. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  644.     void                   deleteValidationNamespaceList();
  645.     void                   checkForXMMFDependency(CSmilElement* pElement);
  646.     void                   handleBeginEndListXMMFReferences(CSmilElement*  pElement,
  647.                                                             CHXSimpleList* pList);
  648.     void                   handleClipBeginEndXMMFReference(CSmilElement*  pElement,
  649.                                                            BOOL           bIsClipBegin);
  650.     HX_RESULT              setElementHandler(SMILNode* pNode, CSmilElementHandler* pHandler);
  651.     void                   addToBeginOrEndTimeMap(SmilTimeValue*     pValue,
  652.                                                   SmilTimingListType eType);
  653.     void                   removeFromBeginOrEndTimeMap(SmilTimeValue*     pValue,
  654.                                                        SmilTimingListType eType);
  655.     BOOL                   isTimeValueListPresent(const char*         pszEventName,
  656.                                                   const char*         pszElementID,
  657.                                                   SmilTimingListType  eType,
  658.                                                   REF(CHXSimpleList*) rpList);
  659.     void                   clearTimeValueMap(SmilTimingListType eType);
  660.     void                   checkNodeForExternalEvents(SMILNode* pNode);
  661.     void                   checkNodeTimeListForExternalEvents(CHXSimpleList* pList);
  662.     void                   addExternalEventToList(const char*     pszID,
  663.                                                   const char*     pszFullName,
  664.                                                   const char*     pszName,
  665.                                                   CNamespaceInfo* pInfo);
  666.     void                   clearExternalEventList();
  668.     IUnknown*               m_pContext;
  669.     IHXCommonClassFactory* m_pClassFactory;
  670.     IHXSystemRequired*     m_pISystemRequired;
  671.     IHXXMLParser*          m_pParser;
  672.     CSmilParserResponse*    m_pResponse;
  673.     SMILNode*               m_pCurNode;
  674.     CHXStack*               m_pNodeDependencies;
  675.     SMILNode*               m_pCurrentDependentNode;
  676.     CHXStack*               m_pAnchorStack;
  677.     CSmilAAnchorElement*    m_pCurrentAnchor;
  678.     INT32                   m_lLastCheckPendingTime;
  679.     CHXSimpleList*          m_pPacketQueue;
  680.     CHXSimpleList*          m_pSourceUpdateList;
  681.     CHXMapLongToObj*        m_pAddGroupMap;
  682.     CHXMapLongToObj*        m_pTagAttributeMap;
  683.     CHXMapStringToOb*       m_pIDMap;
  684.     CHXMapStringToOb*       m_pRequireTagsMap;
  685. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  686.     CHXMapStringToOb*       m_pTransitionMap;
  687. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  688.     CHXMapStringToOb*       m_pActiveNamespaceMap;
  689.     CHXMapStringToOb*       m_pCustomTestMap;
  690.     CHXSimpleList*          m_pNSConflictList;
  691.     CHXSimpleList*          m_pBeginTimeSyncList;
  692.     CHXSimpleList*          m_pEndTimeSyncList;
  693.     CHXSimpleList*          m_pBeginEventList;
  694.     CHXSimpleList*          m_pEndEventList;
  695.     CHXSimpleList*          m_pBeginMediaMarkerList;
  696.     CHXSimpleList*          m_pEndMediaMarkerList;
  697.     CHXSimpleList*          m_pClipBeginMarkerList;
  698.     CHXSimpleList*          m_pClipEndMarkerList;
  699.     CHXSimpleList*          m_pPendingBeginTimeList;
  700.     CHXSimpleList*          m_pPendingEndTimeList;
  701.     CHXSimpleList*          m_pOnLoadURLList;
  702.     CHXSimpleList*          m_pOnLoadURLListCopyForPostSeek; 
  703.     BOOL                    m_bHandlePostSeekOnLoadURLs;
  704.     char*                   m_pBasePath;
  705.     CHXSimpleList*          m_pTrackHintList;
  706.     UINT32                  m_ulBandwidthPreference;
  707.     UINT32                  m_ulScreenHeightPreference;
  708.     UINT32                  m_ulScreenWidthPreference;
  709.     UINT32                  m_ulScreenDepthPreference;
  710.     UINT32                  m_ulDurIfNoInitialTracksScheduled;
  711.     char*                   m_pOverdubOrCaptionPreference;
  712.     char*                   m_pEncoding;
  713.     CHXSimpleList*          m_pLanguagePreferenceList;
  714.     CHXPtrArray*            m_pErrors;
  715.     time_t                  m_tRefTime;
  716.     HXVERSIONINFO           m_versionInfo;
  717.     ULONG32                 m_ulPlatformVer; // /Ret val of HXGetWinVer().
  718.     CHXMapStringToOb*       m_pElementMap;
  719.     CHXMapStringToOb*       m_pAttributeMap;
  720. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  721.     CHXMapStringToOb*       m_pExtElementMap;
  722.     CHXMapStringToOb*       m_pExtAttributeMap;
  723.     CHXMapStringToOb*       m_pNamespaceMap;
  724.     CRNBinaryMap*           m_pLegalAttrMap;
  725.     CRNBinaryMap*           m_pContentModelMap;
  726.     XMLAttributeType*       m_pAttrType;
  727.     CHXMapStringToOb**      m_ppEnumAttrMap;
  728.     CHXSimpleList**         m_ppReqAttrList;
  729. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  730.     CHXSimpleList*          m_pValNSList;
  731.     CHXSimpleList*          m_pXMMFElementList;
  732.     UINT32                  m_ulPersistentComponentID;
  733.     ElementWithinTag        m_elementWithinTag;
  734.     UINT16                  m_usNumGroups;
  735.     HX_RESULT               m_lParseError;
  736.     CHXSimpleList*          m_pAnimateElementList;
  737.     CHXMapStringToOb*       m_pBeginTimeMap;
  738.     CHXMapStringToOb*       m_pEndTimeMap;
  739.     CHXSimpleList*          m_pExternalEventList;
  740.     LISTPOSITION            m_pExternalEventListPos;
  741.     CHXSimpleList*          m_pElementsWithHandlerList;
  742.     char*                   m_pVarName;
  743.     UINT32                  m_ulNextVar;
  744.     static const char* const zm_pSupportedSMIL2ModuleNamespaces[
  745.                                NUM_SUPPORTED_SMIL_2_0_MODULE_NAMESPACES + 1];
  746.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  747.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  748.     HX_BITFIELD             m_bIgnoreUnrecognizedElements : 1;
  749.     HX_BITFIELD             m_bNoNamespaces : 1;
  750.     HX_BITFIELD             m_bRNNamespace : 1;
  751.     HX_BITFIELD             m_bSMILRootLayoutAlreadyFound : 1;
  752.     HX_BITFIELD             m_bCaptionsPreference : 1;
  753.     HX_BITFIELD             m_bSystemAudioDescPreference : 1;
  754.     HX_BITFIELD             m_bUseSystemCPU : 1;
  755.     HX_BITFIELD             m_bUseSystemOS : 1;
  756.     HX_BITFIELD             m_bContainsSource : 1;
  757.     HX_BITFIELD             m_bContainsInitiallyScheduledTrack: 1;
  758.     HX_BITFIELD             m_bStoreErrors : 1;
  759.     HX_BITFIELD             m_bFirstPacket : 1;
  760.     HX_BITFIELD             m_bTimestampsResolved : 1;
  761.     HX_BITFIELD             m_bAllowPlaylistBehavior : 1;
  762.     HX_BITFIELD             m_bAllTracksNeedReflushHint : 1;
  763. };
  765. #if defined(HELIX_FEATURE_SMIL2_VALIDATION)
  767. inline BOOL CSmilParser::isXMLLetter(char ch) const
  768. {
  769.     BOOL bRet = FALSE;
  771.     // /Fixes some gcc compiler warnings that might actually be bugs in our
  772.     // UNIX player; need to compare unsigneds with the 0x..'s which are unsigned:
  773.     const unsigned char c = (unsigned char)ch;
  775.     if ((c >= 0x41 && c <= 0x5A) ||
  776.         (c >= 0x61 && c <= 0x7A) ||
  777.         (c >= 0xC0 && c <= 0xD6) ||
  778.         (c >= 0xD8 && c <= 0xF6) ||
  779.         (c >= 0xF8 && c <= 0xFF))
  780.     {
  781.         bRet = TRUE;
  782.     }
  784.     return bRet;
  785. }
  787. inline BOOL CSmilParser::isXMLDigit(char c) const
  788. {
  789.     return ((c >= 0x30 && c <= 0x39) ? TRUE : FALSE);
  790. }
  792. inline BOOL CSmilParser::isXMLNameChar(char ch) const
  793. {
  794.     BOOL bRet = FALSE;
  796.     // /Fixes some gcc compiler warnings that might actually be bugs in our
  797.     // UNIX player; need to compare unsigneds with the 0x..'s which are unsigned:
  798.     const unsigned char c = (unsigned char)ch;
  800.     if (isXMLLetter(c) ||
  801.         isXMLDigit(c)  ||
  802.         c == '.'       ||
  803.         c == '-'       ||
  804.         c == '_'       ||
  805.         c == ':'       ||
  806.         c == 0xB7)
  807.     {
  808.         bRet = TRUE;
  809.     }
  811.     return bRet;
  812. }
  814. #endif /* #if defined(HELIX_FEATURE_SMIL2_VALIDATION) */
  816. #endif  /* _SMLPARSE_H_ */