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

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

Symbian

开发平台：

C/C++

smldoc.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 SMLDOC_H
  37. #define SMLDOC_H
  39. // Forward declarations
  40. typedef _INTERFACE IHXSite               IHXSite;
  41. typedef _INTERFACE IHXValues             IHXValues;
  42. typedef _INTERFACE IHXRenderer           IHXRenderer;
  43. typedef _INTERFACE IHXGroup              IHXGroup;
  44. typedef _INTERFACE IHXBuffer             IHXBuffer;
  45. typedef _INTERFACE IHXScheduler          IHXScheduler;
  46. typedef _INTERFACE IHXSiteManager        IHXSiteManager;
  47. typedef _INTERFACE IHXStatusMessage      IHXStatusMessage;
  48. typedef _INTERFACE IHXViewPortManager    IHXViewPortManager;
  49. typedef _INTERFACE IHXErrorMessages      IHXErrorMessages;
  50. typedef _INTERFACE IHXErrorSink          IHXErrorSink;
  51. typedef _INTERFACE IHXHyperNavigate      IHXHyperNavigate;
  52. typedef _INTERFACE IHXMutex              IHXMutex;
  53. typedef _INTERFACE IHXSiteUser           IHXSiteUser;
  54. typedef _INTERFACE IHXPlayer             IHXPlayer;
  55. typedef _INTERFACE IHXPersistentRenderer IHXPersistentRenderer;
  56. typedef _INTERFACE IHXLayoutStream       IHXLayoutStream;
  57. typedef void*                             LISTPOSITION;
  58. typedef void*                             POSITION;
  59. class  CSmilRenderer;
  60. class  CSmilAddGroup;
  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  CSmilRootLayout;
  67. class  CSmilSource;
  68. class  CSmilMeta;
  69. class  CSmilMetadata;
  70. class  CSmilEndLayout;
  71. class  CSmilRendererPreFetch;
  72. class  CSmilSourceUpdate;
  73. class  CSmilTransition;
  74. class  SMILNode;
  75. class  CSmilAnimateElement;
  76. class  CSmilElement;
  77. class  CSmilSiteUser;
  78. class  CSmilBasicRegion;
  79. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  80. class  CSmilBasicViewport;
  81. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  82. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  83. class  CSmilTransitionInfo;
  84. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  85. class  CAnimationSandwichLayer;
  86. class  CSmilBasicBox;
  87. class  CSmilAnimateInfo;
  88. class  CAttr;
  89. class  CSmilSiteWatcher;
  90. class  CSmilLayoutEvent;
  91. class  CHXSimpleList;
  92. class  CSmilAAnchorElement;
  93. class  CSmilParser;
  94. class  CHXMapStringToOb;
  95. class  CSmilBasicRootLayout;
  96. class  CHXMapPtrToPtr;
  97. class  CHXMapLongToObj;
  98. class  CSmilTransition;
  99. class  CSmilShowSiteEvent;
  100. class  CSmilAnimateEvent;
  101. class  CHyperlinkCallback;
  102. class  HandlePendingSchedulingCallback;
  103. class  CHXString;
  104. class  CHXStack;
  105. class  CExternalMediaMarkerInfo;
  106. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  107. class CResourceLoader;
  108. #elif defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  109. class XData;
  110. #endif
  111. struct SMILSiteInfo;
  112. struct SMILPlayToAssoc;
  113. struct SMILGroupInfo;
  114. struct SMILSourceInfo;
  116. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  117. //We need to include the X headers...
  118. // XXXMEH - try to get rid of these - not
  119. // usually a good idea to have includes
  120. // inside of a header file
  121. #include <X11/Xlib.h>
  122. #include <X11/Xutil.h>
  123. #include "hxmap.h"
  124. #include "hxvsurf.h"
  125. #endif
  127. #define DEFAULT_ROOT_LAYOUT_WIDTH  320
  128. #define DEFAULT_ROOT_LAYOUT_HEIGHT 240
  130. class CSmilDocumentRenderer:  public IHXRendererAdviseSink,
  131.                               public IHXClientAdviseSink,
  132.                               public IHXGroupSink,
  133.                               public IHXPrefetchSink,
  134.                               public IHXTrackSink,
  135. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  136.                               public IHXViewPortSink,
  137. #if defined(XXXMEH_DO_VIEWPORT_TLC)
  138.                               public IHXViewPortSupplier,
  139. #endif
  140. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  141. #if defined(BE_SITE_SUPPLIER_20010205)
  142.                               public IHXSiteSupplier,
  143. #endif
  144.                               public IHXMediaMarkerSink,
  145.                               public IHXEventSink,
  146.                               public IHXErrorSink,
  147.                               public CSmilElementHandler,
  148.                               public CSmilEventHookResponse,
  149.                               public CSmilSiteUserResponse,
  150.                               public CSmilPassiveSiteWatcherResponse
  151. {
  152. public:
  153.     CSmilDocumentRenderer(CSmilRenderer* pParent, IUnknown* pContext);
  154.     virtual ~CSmilDocumentRenderer();
  156.     // IUnknown methods
  157.     STDMETHOD(QueryInterface)    (THIS_ REFIID riid, void** ppvObj);
  158.     STDMETHOD_(ULONG32, AddRef)  (THIS);
  159.     STDMETHOD_(ULONG32, Release) (THIS);
  161.     // IHXRendererAdviseSink methods
  162.     STDMETHOD(TrackDurationSet)         (THIS_ UINT32 ulGroupIndex, UINT32 ulTrackIndex,
  163.                                                UINT32 ulDuration,   UINT32 ulDelay,
  164.                                                BOOL   bIsLive);
  165.     STDMETHOD(RepeatedTrackDurationSet) (THIS_ const char* pID, UINT32 ulDuration,
  166.                                                BOOL bIsLive);
  167.     STDMETHOD(TrackUpdated)             (THIS_ UINT32 ulGroupIndex, UINT32 ulTrackIndex,
  168.                                                IHXValues* pValues);
  169.     STDMETHOD(RendererInitialized)      (THIS_ IHXRenderer* pRend, IUnknown* pStream,
  170.                                                IHXValues* pInfo);
  171.     STDMETHOD(RendererClosed)           (THIS_ IHXRenderer* pRend, IHXValues* pInfo);
  173.    // IHXClientAdviseSink methods               ref:  hxclsnk.h
  174.     STDMETHOD (OnPosLength)  (THIS_ UINT32 ulPosition, UINT32 ulLength);
  175.     STDMETHOD (OnPresentationOpened) (THIS);
  176.     STDMETHOD (OnPresentationClosed) (THIS);
  177.     STDMETHOD (OnStatisticsChanged)  (THIS);
  178.     STDMETHOD (OnPreSeek)    (THIS_ UINT32 ulOldTime, UINT32 ulNewTime);
  179.     STDMETHOD (OnPostSeek)   (THIS_ UINT32 ulOldTime, UINT32 ulNewTime);
  180.     STDMETHOD (OnStop)       (THIS);
  181.     STDMETHOD (OnPause)      (THIS_ UINT32 ulTime);
  182.     STDMETHOD (OnBegin)      (THIS_ UINT32 ulTime);
  183.     STDMETHOD (OnBuffering)  (THIS_ UINT32 ulFlags, UINT16 unPercentComplete);
  184.     STDMETHOD (OnContacting) (THIS_ const char* pHostName);
  186.     // IHXGroupSink methods
  187.     STDMETHOD(GroupAdded)       (THIS_ UINT16 uGroupIndex, IHXGroup* pGroup);
  188.     STDMETHOD(GroupRemoved)     (THIS_ UINT16 uGroupIndex, IHXGroup* pGroup);
  189.     STDMETHOD(AllGroupsRemoved) (THIS);
  190.     STDMETHOD(TrackAdded)       (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pTrack);
  191.     STDMETHOD(TrackRemoved)     (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pTrack);
  192.     STDMETHOD(TrackStarted)     (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pTrack);
  193.     STDMETHOD(TrackStopped)     (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pTrack);
  194.     STDMETHOD(CurrentGroupSet)  (THIS_ UINT16 uGroupIndex, IHXGroup* pGroup);
  196.     // IHXPrefetchSink methods
  197.     STDMETHOD(PrefetchTrackAdded)   (THIS_ UINT16 uGroupIndex, UINT16 uPrefetchTrackId,
  198.                                            IHXValues* pTrack);
  199.     STDMETHOD(PrefetchTrackRemoved) (THIS_ UINT16 uGroupIndex, UINT16 uPrefetchTrackId,
  200.                                            IHXValues* pTrack);
  201.     STDMETHOD(PrefetchTrackDone)    (THIS_ UINT16 uGroupIndex, UINT16 uPrefetchTrackId,
  202.                                            HX_RESULT   status);
  204.     // IHXTrackSink methods
  205.     STDMETHOD(BeginDone)             (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex);
  206.     STDMETHOD(SeekDone)              (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex,
  207.                                             UINT32 ulSeekTime);
  208.     STDMETHOD(PauseDone)             (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex);
  209.     STDMETHOD(StopDone)              (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex);
  210.     STDMETHOD(OnSoundLevelAnimation) (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex,
  211.                                             UINT32 ulSoundLevelAnimationTime);
  213. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  214.     // IHXViewPortSink methods
  215.     STDMETHOD(ViewPortOpened)    (THIS_ const char* pszViewPort);
  216.     STDMETHOD(ViewPortClosed)    (THIS_ const char* pszViewPort);
  217.     STDMETHOD(ViewPortShown)     (THIS_ const char* pszViewPort);
  218.     STDMETHOD(ViewPortHidden)    (THIS_ const char* pszViewPort);
  219.     STDMETHOD(ViewPortFocusSet)  (THIS_ const char* pszViewPort);
  220.     STDMETHOD(ViewPortZOrderSet) (THIS_ const char* pszViewPort, UINT32 ulZOrder);
  222. #ifdef XXXMEH_DO_VIEWPORT_TLC
  223.     // IHXViewPortSupplier methods
  224.     STDMETHOD(OnViewPortOpen)   (THIS_ IHXValues* pValues, IHXSiteUser* pSiteUser);
  225.     STDMETHOD(OnViewPortClose)  (THIS_ const char* pszViewPort);
  226.     STDMETHOD(OnViewPortShow)   (THIS_ const char* pszViewPort);
  227.     STDMETHOD(OnViewPortHide)   (THIS_ const char* pszViewPort);
  228.     STDMETHOD(OnViewPortFocus)  (THIS_ const char* pszViewPort);
  229.     STDMETHOD(OnViewPortZOrder) (THIS_ const char* pszViewPort, UINT32 ulZOrder);
  230. #endif
  232. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  234. #if defined(BE_SITE_SUPPLIER_20010205)
  235.     // IHXSiteSupplier methods
  236.     STDMETHOD(SitesNeeded)       (THIS_ UINT32 uRequestID, IHXValues* pSiteProps);
  237.     STDMETHOD(SitesNotNeeded)    (THIS_ UINT32 uRequestID);
  238.     STDMETHOD(BeginChangeLayout) (THIS);
  239.     STDMETHOD(DoneChangeLayout)  (THIS);
  240. #endif
  242.     // IHXMediaMarkerSink methods
  243.     STDMETHOD(MarkerResolved) (THIS_ IHXBuffer* pURLStr,
  244.                                      IHXBuffer* pMarkerNameStr,
  245.                                      UINT32      ulTime,
  246.                                      IHXValues* pOtherMarkerParams);
  248.     // IHXEventSink methods
  249.     STDMETHOD(EventFired) (THIS_ IHXBuffer* pURLStr,
  250.                                  IHXBuffer* pFragmentStr,
  251.                                  IHXBuffer* pEventNameStr,
  252.                                  IHXValues* pOtherValues);
  254.     // IHXErrorSink methods
  255.     STDMETHOD(ErrorOccurred) (THIS_ const UINT8   unSeverity,
  256.                                     const ULONG32 ulHXCode,
  257.                                     const ULONG32 ulUserCode,
  258.                                     const char*   pUserString,
  259.                                     const char*   pMoreInfoURL);
  261.     // CSmilElementHandler methods - these are
  262.     // the methods that the CSmilParser and CSmilElements
  263.     // will call us back on
  264.     HX_RESULT handleAddGroup(CSmilAddGroup* pAddGroup);
  265.     HX_RESULT handleRegion(CSmilRegion* pRegion);
  266.     HX_RESULT handleRegPoint(CSmilRegPoint* pRegPt);
  267. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  268.     HX_RESULT handleViewport(CSmilViewport* pView);
  269. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  270.     HX_RESULT handleRootLayout(CSmilRootLayout* pRootLayout);
  271.     HX_RESULT handleSource(CSmilSource* pSource);
  272.     HX_RESULT handleMeta(CSmilMeta* pMeta);
  273.     HX_RESULT handleMetadata(CSmilMetadata* pMetadata);
  274.     HX_RESULT handleEndLayout(CSmilEndLayout* pSource);
  275.     HX_RESULT handleRendererPreFetch(CSmilRendererPreFetch* pRend);
  276.     HX_RESULT handleSourceUpdate(CSmilSourceUpdate* pUpdate);
  277. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  278.     HX_RESULT handleTransition(CSmilTransition* pTrans);
  279. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  280.     HX_RESULT handleTrackRemoval(const char* pID, INT32 nGroupNum);
  281.     HX_RESULT handleTrackPausing(SMILNode*                     pNode,
  282.                                  LONG32                        lTimeOfPause,
  283.                                  SMILPriorityClassPauseDisplay pauseDisplay,
  284.                                  const char*                   pIdOfPauser);
  285.     HX_RESULT handleTrackResuming(const char* pID, INT32 nGroupNum);
  286. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  287.     HX_RESULT handleAnimate(CSmilAnimateElement* pAnimate);
  288. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  289.     HX_RESULT handleRemoveTimeUpdate(CSmilElement* pElement, UINT32 ulRemoveTime);
  290.     HX_RESULT handleExternalMediaMarkerFile(CSmilElement* pElement,
  291.                                             const char*   pszID,
  292.                                             const char*   pszExternalFileName,
  293.                                             const char*   pszRelativeSource);
  294.     HX_RESULT resolveGroupDurToOuterTimeContainerDur(UINT32 ulGroupIndex,
  295.                                                      UINT32 ulGroupTimeContainerDuration);
  296.     HX_RESULT GetCurGroupDuration(REF(UINT32) ulCurGrpDur);
  298.     // CSmilEventHookResponse methods
  299.     STDMETHOD(HandleMouseMove)        (THIS_ void*       pWindow,
  300.                                              const char* pRegionID,
  301.                                              const char* pMediaID,
  302.                                              UINT16      uXPos,
  303.                                              UINT16      uYPos,
  304.                                              UINT32      kRMAEvent,
  305.                                              REF(BOOL)   bHandleSetCursor);
  306.     STDMETHOD(HandleLButtonUp)        (THIS_ const char* pRegionID,
  307.                                              const char* pMediaID,
  308.                                              UINT16      uXPos,
  309.                                              UINT16      uYPos,
  310.                                              REF(BOOL)   rbHandled);
  311.     STDMETHOD(HandleGotFocus)         (THIS_ const char* pRegionID,
  312.                                              const char* pMediaID);
  313.     STDMETHOD(HandleLostFocus)        (THIS_ const char* pRegionID,
  314.                                              const char* pMediaID);
  315.     STDMETHOD(HandleCharEvent)        (THIS_ UINT16 uChar);
  316.     STDMETHOD_(BOOL, HandleSetCursor) (THIS);
  317.     STDMETHOD(AddShowEvents)          (THIS_ const char* pRegionName, IHXSite* pSite);
  319.     // CSmilSiteUserResponse methods
  320.     STDMETHOD(SiteUserAttachSite)  (THIS_ CSmilSiteUser* pUser, IHXSite* pSite);
  321.     STDMETHOD(SiteUserDetachSite)  (THIS_ CSmilSiteUser* pUser);
  322.     STDMETHOD(SiteUserHandleEvent) (THIS_ CSmilSiteUser* pUser, HXxEvent* pEvent);
  324.     // CSmilPassiveSiteWatcherResponse methods
  325.     STDMETHOD(SitePositionChanged) (THIS_ IHXSite* pSite, HXxPoint* pPoint);
  326.     STDMETHOD(SiteSizeChanged)     (THIS_ IHXSite* pSite, HXxSize*  pSize);
  328.     // CSmilDocumentRenderer public methods
  329.     HX_RESULT            close(CSmilRenderer* pParent);
  330.     HX_RESULT            setDocument(const char* pFragment);
  331.     HX_RESULT            setupDummySource();
  332.     HX_RESULT            onPacket(IHXBuffer* pBuffer, BOOL bIsFinal);
  333.     HX_RESULT            handleNamedEvent(const char* pRegionID,
  334.                                           const char* pMediaID,
  335.                                           const char* pEventName);
  336.     HX_RESULT            detachSite(IHXSite* pSite);
  337.     double               getResizeXScale() { return m_dResizeXScale; }
  338.     double               getResizeYScale() { return m_dResizeYScale; }
  339.     HX_RESULT            onHeader(IHXValues* pHeader);
  340.     HX_RESULT            onTimeSync(UINT32 ulTimeValue);
  341.     HX_RESULT            onPreSeek(UINT32 ulOldTime, UINT32 ulNewTime);
  342.     HX_RESULT            endStream();
  343.     CSmilBasicRegion*    setupDefaultLayout();
  344.     CSmilBasicRegion*    getRegionByID(const char* pID);
  345.     UINT32               getNumRegionsByName(const char* pszName);
  346.     CSmilBasicRegion*    getFirstRegionByName(const char* pszName);
  347.     CSmilBasicRegion*    getNextRegionByName(const char* pszName);
  348.     BOOL                 isAncestorRegion(CSmilBasicRegion* pPossibleParent,
  349.                                           CSmilBasicRegion* pPossibleChild);
  350.     HX_RESULT            getCommonAncestorRegion(CSmilBasicRegion*      pRegA,
  351.                                                  CSmilBasicRegion*      pRegB,
  352.                                                  REF(CSmilBasicRegion*) rpCommon);
  353.     CSmilRegPoint*       getRegPoint(const char* pszID);
  354.     CSmilSource*         getSource(const char* pszID);
  355.     HX_RESULT            handleHyperlinkTraversal(CSmilAAnchorElement* pAnc,
  356.                                                   BOOL bCalledFromCallback = FALSE);
  357. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  358.     CSmilBasicViewport*  getViewport(const char* pszID);
  359.     CSmilBasicViewport*  getViewportBySiteUser(CSmilSiteUser* pSiteUser);
  360.     CSmilBasicViewport*  getViewportBySite(IHXSite* pSite);
  361.     CSmilBasicViewport*  getViewportByDescendant(CSmilBasicRegion* pRegion);
  362. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  363.     CSmilBasicBox*       getTopLevelBox(CSmilBasicRegion* pRegion);
  364.     void                 resizeRegion(const char* pRegionName, HXxSize* pNewSize);
  365.     void                 repositionRegion(const char* pRegionName, HXxPoint* pNewPosition);
  366.     void                 setTopLevelSiteSize();
  367.     HX_RESULT            getErrorInfo(REF(UINT32) ulErrorLine,
  368.                                       REF(UINT32) ulErrorColumn,
  369.                                       REF(IHXBuffer*) pErrorText);
  370.     HX_RESULT            getErrorInterface(REF(IHXErrorMessages*) rpErrMsgs);
  371. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  372.     CSmilTransitionInfo* getTransition(const char* pID);
  373.     HX_RESULT            makeTransitionValues(CSmilTransitionInfo* pInfo,
  374.                                               BOOL                 bTransIn,
  375.                                               REF(IHXValues*)     rpValues);
  376.     HX_RESULT            startTransition(UINT32               ulStartTime,
  377.                                          CSmilTransitionInfo* pTransInfo,
  378.                                          SMILSiteInfo*        pInfo,
  379.                                          SMILPlayToAssoc*     pAssoc,
  380.                                          IHXSite*            pSite,
  381.                                          UINT32               ulActualTime,
  382.                                          BOOL                 bBeginTransition);
  383. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  384. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  385.     HX_RESULT            addAnimation(CAnimationSandwichLayer* pLayer);
  386.     HX_RESULT            removeAnimation(CSmilAnimateElement* pAnimate);
  387.     void                 removeAnimation(CSmilAnimateInfo* pInfo);
  388. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  389.     const char*          getDefaultNamespace();
  390.     void                 setMediaNativeSize(const char* pszID, HXxSize cSize);
  391.     HX_RESULT            processMediaRegionOverrides(const char* pszRegionID,
  392.                                                      const char* pszMediaID,
  393.                                                      BOOL        bMediaStart,
  394.                                                      UINT32      ulTime);
  395.     BOOL                 isTransparent(UINT32 ulColor) const;
  396.     void                 resolveZOrder(CSmilBasicBox* pBox, UINT32 ulTime);
  397.     HX_RESULT            getMostRecentInfo(IHXSite* pSite, UINT32 ulTime,
  398.                                            REF(UINT32) rulStartTime,
  399.                                            REF(UINT32) rulLexicalOrder);
  400.     BOOL                 hasParamChildren(CSmilElement* pElement,
  401.                                           BOOL          bServerOnly);
  402.     void                 addParamProperties(CSmilElement* pElement,
  403.                                             IHXValues*   pValues,
  404.                                             IUnknown*     pContext,
  405.                                             BOOL          bServerOnly);
  406.     void                 checkAnimChildren(CSmilElement* pElement, UINT32 ulTrackEnd);
  407.     void                 showAllSites(CSmilBasicBox* pBox, BOOL bShow);
  409.     HX_RESULT            GetElementProperties(UINT16            uGroupID, 
  410.                                               UINT16            uTrackID, 
  411.                                               REF(IHXValues*)  pProperties);
  413.     HX_RESULT            GetElementStatus(UINT16            uGroupID,
  414.                                           UINT16            uTrackID,
  415.                                           UINT32            ulCurrentTime,
  416.                                           REF(IHXValues*)  pStatus);
  418.     HX_RESULT  AttachElementLayout(UINT16     uGroupID,
  419.      UINT16     uTrackID,
  420.      IHXRenderer*  pRenderer,
  421.      IHXStream*    pStream,
  422.      IHXValues*    pProps);
  423.     HX_RESULT  DetachElementLayout(IUnknown*     pLSG);
  425.     BOOL                 isRegionActive(const char* pszRegID, UINT16 usGroup, UINT32 ulTime);
  426.     void                 handlePendingScheduling(void);
  428.     HX_RESULT            AdjustSoundLevelsOfAllCurrentTracks(UINT16 uCurGroupIndex,
  429.                                         UINT32 ulSoundLevelAdjustment_pct,
  430.                                         CSmilSource* pSmilSourceDontAdjustMe);
  433.     // CSmilDocumentRenderer static public methods
  434.     static void          computeRegPoint(HXxRect       cRegionRect,
  435.                                          RegPoint      cRegPointInfo,
  436.                                          REF(HXxPoint) rcRegPoint);
  437.     static HX_RESULT     computeMediaLayout(HXxRect      cRegionRect,
  438.                                             Fit          eFit,
  439.                                             HXxPoint     cRegPoint,
  440.                                             RegAlign     eRegAlign,
  441.                                             HXxSize      cMediaSize,
  442.                                             REF(HXxRect) rcMediaRect,
  443.                                             BOOL         bMediaIsBrush);
  444.     static void          computeHalfBounds(INT32 lMid, INT32 lSpan,
  445.                                            REF(INT32) rlMin, REF(INT32) rlMax);
  446.     static void          computeFillHiddenScaling(Fit eFit, INT32 lRegPt, INT32 lMediaDim,
  447.                                                   INT32 lRegionLo, INT32 lRegionHi,
  448.                                                   REF(INT32) rlMediaLo,
  449.                                                   REF(INT32) rlMediaHi);
  450.     static void          computeMeetSliceScaling(BOOL   bIsMeet, UINT32 ulNumDim,
  451.                                                  INT32 lA1, INT32 lA2, INT32 lA3,
  452.                                                  INT32 lB1, INT32 lB2, INT32 lB3,
  453.                                                  INT32 lC1, INT32 lC2, INT32 lC3,
  454.                                                  INT32 lD1, INT32 lD2, INT32 lD3,
  455.                                                  REF(INT32) rlA, REF(INT32) rlB,
  456.                                                  REF(INT32) rlC, REF(INT32) rlD);
  457.     static void          showSite(IHXSite* pSite, BOOL bShow);
  458.     static BOOL          isSiteVisible(IHXSite* pSite);
  459.     static void          setSiteZIndex(IHXSite* pSite, INT32 lZIndex);
  460.     static INT32         getSiteZIndex(IHXSite* pSite);
  461.     static UINT32        getNumberOfChildSites(IHXSite* pSite);
  462.     static void          addStringProperty(IHXValues* pValues,
  463.                                            IUnknown*   pContext,
  464.                                            const char* pszName,
  465.                                            const char* pszValue);
  468.     // CSmilDocumentRenderer public members
  469.     CHXString        m_metadata;
  470.     CHXStack*        m_pPlayerResumeStack;
  471. #if defined(BE_SITE_SUPPLIER_20010205)
  472.     CHXString        m_XXXEH_HACK_regionId;
  473.     IHXPlayer*      m_pIndependentPlayer;
  474.     CHXMapLongToObj* m_pChildSiteInfoMap;
  475. #endif
  477.     friend class CSmilRenderer;
  478. private:
  479.     // CSmilDocumentRenderer private methods
  480.     HX_RESULT            addSiteForRenderer(SMILPlayToAssoc* pPlayToAssoc,
  481.                                             SMILSourceInfo*  pSMILSourceInfo,
  482.                                             IHXRenderer*    pRenderer,
  483.                                             BOOL             bNoRegion);
  484.     HX_RESULT            addSiteForRendererByRegion(SMILPlayToAssoc*  pPlayToAssoc,
  485.                                                     SMILSourceInfo*   pSMILSourceInfo,
  486.                                                     IHXRenderer*     pRenderer,
  487.                                                     BOOL              bNoRegion,
  488.                                                     CSmilBasicRegion* pRegion);
  489.     HX_RESULT            setSiteProperty(IHXSite*   pSite,
  490.                                          const char* pszKey,
  491.                                          const char* pszValue);
  492.     HX_RESULT            setSitePropertyULONG32(IHXSite*   pSite,
  493.                                                 const char* pszKey,
  494.                                                 UINT32      ulValue);
  495.     HX_RESULT            getSiteProperty(IHXSite*        pSite,
  496.                                          const char*      pszKey,
  497.                                          REF(IHXBuffer*) rpValueStr);
  498.     void                 setPlayToAssoc(UINT16      uGroupIndex, 
  499.                                         UINT16      uTrackIndex, 
  500.                                         const char* pID,
  501.                                         const char* pRepeatID,
  502.                                         const char* pPlayTo,
  503.                                         const char* pRegionName,
  504.                                         const char* pBeginTransition,
  505.                                         const char* pEndTransition,
  506.                                         UINT32      regionZOrder,
  507.                                         BOOL        bXMMSource = FALSE);
  508.     HX_RESULT            doTransition(LISTPOSITION pos, UINT32 ulTime);
  509.     HX_RESULT            moveHideEventForSiteBack(SMILSiteInfo* pInfo,
  510.                                                   UINT32        ulEndTime,
  511.                                                   UINT32        len, 
  512.                                                   BOOL          bJustRenderer);
  513. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  514.     HX_RESULT            checkSitesHideTime(SMILSiteInfo*        pOtherSiteInfo,
  515.                                             SMILSiteInfo*        pSiteInfo,
  516.                                             CSmilTransitionInfo* pTransInfo,
  517.                                             REF(IHXSite*)       pSiteToTransition,
  518.                                             BOOL                 bBeginTransition);
  519. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  520.     HX_RESULT            ignoreLastHideEvent(UINT32 ulGroupIndex, SMILGroupInfo* pGroupInfo);
  521.     BOOL                 SitesOverlap(IHXSite* pCanidate, IHXSite* pSite);
  522.     SMILPlayToAssoc*     getPlayToAssoc(UINT16 uGroupIndex, UINT16 uTrackIndex);
  523.     SMILPlayToAssoc*     getPlayToAssoc(const char* pName);
  524.     SMILPlayToAssoc*     getPlayToAssocByMedia(const char* pszMediaID);
  525.     void                 removeAllPlayToAssoc();
  526.     void                 removeGroupsPlayToAssoc(UINT16 uGroupIndex);
  527.     void                 removeTracksPlayToAssoc(UINT16 uGroupIndex, UINT16 uTrackIndex);
  528.     void                 removeActiveTransitions();
  529.     void                 removeViewports();
  530.     void                 resetRendererSites(CSmilBasicRegion* pRegion);
  531.     CSmilSiteWatcher*    getRendererSiteWatcher(const char* pszMediaID);
  532.     void                 addRendererSiteWatcherToMap(const char* pszMediaID,
  533.                                                      CSmilSiteWatcher* pWatch);
  534.     void                 removeRendererSiteWatcherFromMap(const char* pszMediaID);
  535.     void                 clearRendererSiteWatcherMap();
  536.     HX_RESULT            getRendererSite(const char* pszMediaID, REF(IHXSite*) rpSite);
  537.     void                 addRendererSiteToMap(const char* pszMediaID, IHXSite* pSite);
  538.     void                 removeRendererSiteFromMap(const char* pszMediaID);
  539.     void                 clearRendererSiteMap();
  540.     HX_RESULT            getRenderer(const char* pszMediaID, REF(IHXRenderer*) rpRenderer);
  541.     void                 addRendererToMap(const char* pszMediaID, IHXRenderer* pRenderer);
  542.     void                 removeRendererFromMap(const char* pszMediaID);
  543.     void                 clearRendererMap();
  544.     HX_RESULT            actualRendererClosed(IHXRenderer* pRenderer,
  545.                                               IHXValues*   pInfo);
  546.     HX_RESULT            closeOldRenderers(BOOL bAll);
  547.     HX_RESULT            addOldRendererHideEvents(UINT16 uGroupIndex);
  548.     void                 removeSourcemap(SMILPlayToAssoc* pPlayToAssoc);
  549.     HX_RESULT            insertEvent(CSmilLayoutEvent* pEvent);
  550.     CSmilShowSiteEvent*  getShowHideEvent(const char* pszMediaID,
  551.                                           const char* pszRegionID,
  552.                                           BOOL        bShowEvent);
  553. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  554.     void                 doAnimation(CSmilAnimateInfo* pInfo, UINT32 ulTime);
  555.     HX_RESULT            getUnderlyingValue(CSmilAnimateInfo* pInfo, REF(CAttr*) rpValue);
  556.     HX_RESULT            getDependentValue(CSmilAnimateInfo* pInfo, REF(CAttr*) rpDepend);
  557.     HX_RESULT            setValue(CSmilAnimateInfo* pInfo, CAttr* pValue,
  558.                                   CAttr* pDepend, BOOL bUnderlyingValue = FALSE);
  559.     void                 removeActiveAnimations();
  560.     CSmilAnimateEvent*   getAnimateEvent(CSmilAnimateElement* pAnim);
  561. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  562.     void                 removeEvent(CSmilLayoutEvent* pEvent);
  563.     HX_RESULT            insertSiteInfo(void* pInfo);
  564.     void                 removeSiteInfo(SMILSiteInfo* pSiteInfo);
  565.     void                 removeGroupEvents(UINT16 uGroupIndex);
  566.     BOOL                 draw(HXxEvent* pEvent, IHXSite* pSite, UINT32 ulBgColor);
  567.     HX_RESULT            insertIntoZOrderList(CHXSimpleList* pList,
  568.                                               SMILSiteInfo*  pSiteInfo);
  569.     HX_RESULT            setRendererZOrder(SMILSiteInfo* pSiteInfo);
  570.     HX_RESULT            handleElements();
  571.     HX_RESULT            postParseSetup();
  572.     void                 setProperty(IHXValues* pValues, 
  573.                                      const char* pName, 
  574.                                      const char* pValue);
  575.     HX_RESULT            parseDimension(const char* pDimensionString,
  576.                                         REF(UINT32) ulValue,
  577.                                         REF(BOOL)   bIsPercent);
  578.     HX_RESULT            computeBoxDimension(CSmilBasicBox* pBox, BoxDimension eDim);
  579.     void                 clearResolvedFlags(CSmilBasicBox* pBox);
  580.     void                 resetSites(CSmilBasicBox* pBox, BOOL bOptimizeRedraws);
  581.     void                 resizeTopLevelBox(CSmilBasicBox* pBox, HXxSize cOrigSize, HXxSize cSize);
  582.     void                 zoomRect(CSmilBasicBox* pBox, double dScaleX, double dScaleY);
  583.     void                 recomputeBoxLayout(CSmilBasicBox* pBox, BOOL bOptimizeRedraws);
  584.     BOOL                 isMediaPausedAndDisabled(const char* pID);
  585.     BOOL                 reenablePausedAndDisabledMedia(const char* pID,
  586.                                 UINT16 iGroupIndex);
  588.     CSmilAAnchorElement* findHyperlinkElement(const char* pRegionID,
  589.                                               const char* pMediaID,
  590.                                               UINT16      uXPos,
  591.                                               UINT16      uYPos,
  592.                                               BOOL        bResolveTargetBeginIfFragment = FALSE);
  593.     CSmilElement*        findIfCurElementHasAltOrLongdesc(const char* pID,
  594.                                             UINT16 ulXPos, UINT16 ulYPos);
  595.     HX_RESULT            convertURL(const char* pszBaseRoot, const char* pszBasePrefix,
  596.                                     const char* pURL, CHXString& newURL);
  597.     HX_RESULT            doSourceUpdate(SMILPlayToAssoc*   pPlayToAssoc,
  598.                                         CSmilSourceUpdate* pUpdateElement);
  599.     HX_RESULT            updateStreamTiming(const char* pElementID,
  600.                                             UINT32      ulDuration);
  601.     HX_RESULT            updateStreamDelay(UINT16 uGroupIndex, UINT32 ulDelay);
  602.     HX_RESULT            updateSiteEvents(UINT16 uGroupIndex);
  603.     HX_RESULT            seekTo(const char* pElementID);
  604.     HX_RESULT            setRegionParentChild(CSmilBasicRegion* pRegion);
  605.     HX_RESULT            createRegionSites(CHXSimpleList* pChildList);
  606.     HX_RESULT            createRegionSite(CSmilBasicRegion* pRegion);
  607.     void                 destroyRegionSites(CHXSimpleList* pChildList);
  608.     CSmilBasicRegion*    getRegionByName(const char* pszName);
  609.     void                 RemoveEvents(UINT32 ulGroupIndex, IHXSite* pSite);
  610.     HX_RESULT            flushAllEvents(UINT32 ulFlushToTime, BOOL bBreak = FALSE);
  611.     HX_RESULT            flushAllEvents () { return flushAllEvents(m_ulCurrentTime); }
  612.     BOOL                 IsFullScreen();
  613.     BOOL                 isAttributeAnimated(const char* pszElementID, UINT32 ulAttrName);
  614.     BOOL                 isRegionBackgroundColorOverridden(CSmilBasicRegion* pRegion);
  615. #if defined(HELIX_FEATURE_SMIL2_ANIMATION)
  616.     void                 startSoundLevelAnimation(CSmilAnimateInfo* pInfo);
  617.     void                 finishSoundLevelAnimation(CSmilAnimateInfo* pInfo,
  618.                                                    BOOL bUseCurrentLevel = FALSE);
  619.     CSmilAnimateElement* getFirstAnimationElement(const char* pszElementID, UINT32 ulAttrName);
  620.     CSmilAnimateElement* getNextAnimationElement(const char* pszElementID, UINT32 ulAttrName);
  621. #endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
  622.     BOOL                 getGroupDuration(UINT16 usGroupIndex, REF(UINT32) rulDuration);
  623.     HX_RESULT            getTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, REF(IHXTrack*) rpTrack);
  624.     void                 forceFullRedraw(IHXSite* pSite);
  625.     void                 forceFullRecursiveRedraw(CSmilBasicBox* pBox);
  626.     void                 destroyRendererSites(CSmilBasicBox* pBox);
  627.     HX_RESULT            setupRootLayout(BOOL bAssignDefaults);
  628. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  629.     HX_RESULT            setupViewports();
  630.     HX_RESULT            finishOneViewportSetup(CSmilBasicViewport* pPort);
  631.     HX_RESULT            setupViewportsDone(HX_RESULT status);
  632.     void                 closeViewports();
  633.     void                 showHideViewport(const char* pszID, BOOL bShow);
  634.     void                 showHideViewport(CSmilBasicViewport* pPort, BOOL bShow);
  635. #ifdef XXXMEH_DO_VIEWPORT_TLC
  636.     void                 clearViewportMap();
  637. #endif
  638. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
  639.     void                 destroyRegions(CHXSimpleList* pChildList);
  640.     void                 destroyAllRegions();
  641.     void                 setElementRemoveTime(const char* pszID, UINT32 ulRemoveTime);
  642. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  643.     XData*               InitXVisualSupport(IHXSite* pSite, HXxWindow* pWnd);
  644. #endif
  645. #if defined(_DEBUG)
  646.     void                 DumpEventQueue();
  647.     void                 DumpZOrder(CSmilBasicBox* pBox, UINT32 ulIndentLevel);
  648.     void                 DumpAllGroupInfo(UINT32 ulTime);
  649.     void                 DumpAllProperties(IHXValues* pValues, UINT32 ulNumTabIndent);
  650.     void                 DumpAllSiteInfo(const char* pszFileName, UINT32 ulTime);
  651.     void                 DumpBoxSiteInfo(CSmilBasicBox* pBox, FILE* fp, UINT32 ulIndentLevel);
  652. #endif
  653.     HX_RESULT            getMediaIDFromSite(IHXSite* pSite, REF(CHXString) rcStr);
  654.     CExternalMediaMarkerInfo* getExternalMediaMarkerInfo(const char* pszURL);
  655.     BOOL                      isIDMappedToExternalMediaMarkerFile(CExternalMediaMarkerInfo* pInfo,
  656.                                                                   const char*               pszID);
  657.     void                      deleteExternalMediaMarkerList();
  658.     void                      queueSiteForAnimationRedraw(IHXSite* pSite);
  659.     void                      queueRegionForRecompute(CSmilBasicRegion* pRegion);
  660.     void                      removePendingAnimationRedraw(IHXSite* pSite);
  661.     void                      turnSiteCompositionModeON();
  662.     void                      turnSiteCompositionModeOFF();
  663.     void                      lockSiteComposition();
  664.     void                      unlockSiteComposition();
  665.     void                      bltSiteComposition();
  666.     BOOL                      isSiteCompositionLocked();
  667.     BOOL                      isSiteCompositionModeON();
  668.     void                      GoToURLWithParamCheck(const char*        pszURL,
  669.                                                     const char*        pszTarget,
  670.                                                     const char*        pszSendTo,
  671.                                                     IHXHyperNavigate* pHyper,
  672.                                                     CSmilElement*      pElement,
  673.                                                     IUnknown*          pContext,
  674.                                                     BOOL               bUserInvoked,
  675.                                                     BOOL               bHint = FALSE);
  676.     UINT16                    getCurrentGroup();
  677.     HX_RESULT                 InitPersistent(UINT32                   ulPersistentComponentID,
  678.                                              UINT16                   uPersistentGroupID,
  679.                                              UINT16                   uPersistentTrackID,
  680.                                              IHXPersistentRenderer*  pPersistentParent);
  681.     BOOL                      IsNestedMetaSupported(void);
  682.     void                      PersistentDurationSet(UINT32 ulDuration, UINT32 ulDelay, BOOL bIsLive);
  683.     FillType                  getMediaFillBehavior(const char* pszID);
  684.     BOOL                      atLeastOneActiveAnimation(UINT32 ulTime);
  685.     void                      clearAllEventHandledFlags();
  686.     HX_RESULT                 setRendererULONG32Property(const char* pszMediaID,
  687.                                                          const char* pszName,
  688.                                                          UINT32      ulValue,
  689.                                                          REF(BOOL)   rbSetNewValue);
  690.     HX_RESULT                 setRendererCStringProperty(const char* pszMediaID,
  691.                                                          const char* pszName,
  692.                                                          const char* pszValue,
  693.                                                          REF(BOOL)   rbSetNewValue);
  694.     void                      addRemoveMediaMarkerSink(BOOL bAdd);
  695.     void                      addRemoveEventSink(BOOL bAdd);
  696.     void                      addRemoveErrorSink(BOOL bAdd);
  697.     void                      addEventSinkFilterRule(const char*    pszURL,
  698.                                                      const char*    pszFragment,
  699.                                                      const char*    pszEventName,
  700.                                                      IHXEventSink* pSink = NULL);
  701.     HX_RESULT                 getEventSink(const char*         pszID,
  702.                                            REF(IHXEventSink*) rpEventSink);
  703.     HX_RESULT                 addRemoveEventSink(const char* pszID, BOOL bAdd);
  704.     void                      removeAllEventSinks();
  705.     HX_RESULT                 setupEventPipe(const char* pszSrcID,
  706.                                              const char* pszDstID,
  707.                                              const char* pszEventName);
  708.     void                      SendHyperlinkHints();
  709.     void                      HintHyperlinkNodeRecurse(SMILNode* pNode);
  710.     void                      HintHyperlinkNode(CSmilAAnchorElement* pAnchor);
  712.     // CSmilDocumentRenderer private members
  713.     CSmilRenderer*          m_pParent;
  714.     CSmilParser*            m_pSmilParser;
  715.     HX_RESULT               m_ulParseResult;
  716.     IHXScheduler*          m_pScheduler;
  717.     char*                   m_pFragment;
  718.     CHXMapStringToOb*       m_pRegionMap;
  719.     CSmilBasicRootLayout*   m_pRootLayout;
  720.     CHXSimpleList*          m_pViewportList;
  721.     CHXMapStringToOb*       m_pRegPointMap;
  722. #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
  723.     CHXMapStringToOb*       m_pTransitionMap;
  724. #endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
  725.     CHXMapPtrToPtr*         m_pSiteInfoByRendererMap;
  726.     CHXMapPtrToPtr*         m_pSiteWatcherMap;
  727.     CHXMapLongToObj*        m_pGroupInfoMap;
  728.     CHXMapLongToObj*        m_pGroupMap;
  729.     CHXMapStringToOb*       m_pDeferredSourceMap;
  730.     CHXMapStringToOb*       m_pPausedAndDisabledIDMap;
  731.     CHXMapStringToOb*       m_pPausedAndDisabledBrightnessMap;
  732.     CHXMapLongToObj*        m_pPrefetchTrackElementMap;
  733.     CHXSimpleList*          m_pSiteInfoList;
  734.     CHXSimpleList*          m_pPlayToAssocList;
  735.     CHXSimpleList*          m_pEventList;
  736.     CHXSimpleList*          m_pZOrderList;
  737.     CHXSimpleList*          m_pDelayedRendererCloseList;
  738.     LISTPOSITION            m_ulEventListPosition;
  739.     INT16                   m_uCurrentGroupIndex;
  740.     INT16                   m_nFragmentTracks;
  741.     UINT32                  m_ulCurrentTime;
  742.     LONG32                  m_lRefCount;
  743.     IUnknown*               m_pContext;
  744.     IHXSiteManager*        m_pSiteMgr;
  745.     IHXStatusMessage*      m_pStatusMessage;
  746.     ULONG32                 m_ulFragmentTimeOffset;
  747.     double                  m_dResizeXScale;
  748.     double                  m_dResizeYScale;
  749.     CHXSimpleList*          m_pActiveTransitions;
  750.     CHXSimpleList*          m_pActiveAnimations;
  751.     POSITION                m_pRegionMapIterator;
  752.     CHXMapStringToOb*       m_pAnimationMap;
  753.     IHXLayoutStream*       m_pPersistentLayoutStream;
  754.     UINT32                  m_ulNoLayoutRendererCount;
  755.     IHXErrorMessages*      m_pErrorMessages;
  756.     UINT32                  m_ulGroupIndex;
  757.     UINT32                  m_ulTrackIndex;
  758.     UINT16                  m_uGroupIndexWithin;
  759.     IHXBuffer*             m_pSMILDefaultNamespaceStr;
  760.     IHXViewPortManager*    m_pViewPortManager;
  761.     HandlePendingSchedulingCallback* m_pHandlePendingSchedulingCallback;
  762.     CHyperlinkCallback*     m_pHyperlinkCallback;
  763.     HXxSize                 m_topSiteSize;
  764.     HXxSize                 m_topSiteOriginalSize;
  765. #ifdef XXXMEH_DO_VIEWPORT_TLC
  766.     CHXMapStringToOb*       m_pViewPortSiteMap;
  767. #endif
  768. #if defined(_WINDOWS)
  769.     HCURSOR                 m_hHyperlinkCursor;
  770.     HCURSOR                 m_hPreHyperlinkCursor;
  771. #elif defined(_MACINTOSH) || defined(_MAC_UNIX)
  772.     CursHandle              m_hHyperlinkCursor;
  773.     CResourceLoader*        m_pResourceLoader;
  774. #elif defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  775.     XVisualInfo*            m_pVisualInfo;
  776.     Cursor                  m_hHyperlinkCursor;
  777.     Cursor                  m_hCurrentCursor;
  778.     Display*                m_pDisplay;          
  779.     Window                  m_Window;
  780.     Display*                m_pPixmapDisplay;
  781.     CHXMapPtrToPtr          m_siteToXDataMap;
  782. #endif
  783.     UINT32                  m_ulPersistentComponentID;
  784.     UINT16                  m_uPersistentGroupID;
  785.     UINT16                  m_uPersistentTrackID;
  786.     IHXValues*             m_pPersistentProperties;
  787.     IHXPersistentRenderer* m_pPersistentParentRenderer;
  788.     CHXSimpleList*          m_pExternalMediaMarkerList;
  789.     POSITION                m_AnimationIterator;
  790.     CHXMapPtrToPtr*         m_pAnimSiteRedrawMap;
  791.     CHXMapPtrToPtr*         m_pAnimRegionRecomputeMap;
  792.     CHXMapPtrToPtr*         m_pAnimTopLayoutMap;
  793.     UINT16                  m_usAnimBaseGroupIndex;
  794.     UINT32                  m_ulAnimDuration;
  795.     UINT32                  m_ulCurGroupDuration;
  796.     IHXMutex*              m_pSoundLevelMutex;
  797.     CHXMapStringToOb*       m_pMediaID2RendererMap;
  798.     CHXMapStringToOb*       m_pMediaID2RendererSiteMap;
  799.     CHXMapStringToOb*       m_pMediaID2RendererSiteWatcherMap;
  800.     CHXMapStringToOb*       m_pDeferrededRemoveTrackMap;
  801.     CHXSimpleList*          m_pEventSinkList;
  802.     UINT32                  m_ulPktnum;
  803.     UINT16                  m_usOldXPos;
  804.     UINT16                  m_usOldYPos;
  805.     // ONLY HX_BITFIELD MEMBERS SHOULD GO BELOW THIS LINE!
  806.     // ALL OTHER MEMBER TYPES SHOULD GO ABOVE THIS LINE!
  807.     HX_BITFIELD             m_bFirstTimeSync : 1;
  808.     HX_BITFIELD             m_bSettingFragment : 1;
  809.     HX_BITFIELD             m_bFragFoundAndResolved : 1;
  810.     HX_BITFIELD             m_bInHyperlink : 1;
  811.     HX_BITFIELD             m_bSiteLayoutComplete : 1;
  812.     HX_BITFIELD             m_bStatusMessageSet : 1;
  813.     HX_BITFIELD             m_bMetadataPassedOffAlready : 1;
  814.     HX_BITFIELD             m_bIsRootLayoutSetup : 1;
  815.     HX_BITFIELD             m_bSMILPresentationHasEnded : 1;
  816.     HX_BITFIELD             m_bSitesDetached : 1;
  817.     HX_BITFIELD             m_bLayoutElementPresent : 1;
  818.     HX_BITFIELD             m_bEmptyLayout : 1;
  819.     HX_BITFIELD             m_bDoNotZoom : 1;
  820.     HX_BITFIELD             m_bAnimateRootLayout : 1;
  821.     HX_BITFIELD             m_bCloseCalled : 1;
  822.     HX_BITFIELD             m_bRootLayoutSiteDetached : 1;
  823.     HX_BITFIELD             m_bInTrackDurationSetCall : 1;
  824.     HX_BITFIELD             m_bEventSinkWasSetup : 1;
  825.     HX_BITFIELD             m_bDestPlaystateIsPause : 1;
  826. #ifdef XXXMEH_DO_VIEWPORT_TLC
  827.     HX_BITFIELD             m_bSMILViewportClose : 1;
  828. #endif
  829. #if defined(_WINDOWS)
  830.     HX_BITFIELD             m_bNeedToSetHyperlinkCursor : 1;
  831. #elif defined(_MACINTOSH) || defined(_MAC_UNIX)
  832.     HX_BITFIELD             m_bResetCursor : 1;
  833. #endif
  834. };
  836. inline BOOL CSmilDocumentRenderer::isTransparent(UINT32 ulColor) const
  837. {
  838.     BOOL bRet = FALSE;
  840.     if ((ulColor & 0xFF000000) == 0xFF000000)
  841.     {
  842.         bRet = TRUE;
  843.     }
  845.     return bRet;
  846. }
  848. #endif