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

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

Symbian

开发平台：

C/C++

sm1doc.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 _SM1DOC_H_
  37. #define _SM1DOC_H_
  39. #include "hxthread.h"
  40. #include "baseobj.h"
  42. class CSmil1Renderer;
  43. class CSmil1Parser;
  44. class CSmil1BasicRegion;
  45. class CSmil1RootLayout;
  46. class CHXHeader;
  47. struct SMIL1PlayToAssoc;
  48. struct SMIL1SourceInfo;
  49. class CSmil1LayoutEvent;
  50. class CSmil1ShowSiteEvent;
  51. class CSmil1EventHook;
  52. class CSmil1PassiveSiteWatcher;
  53. class CResourceLoader;
  54. class ProcessElementCallback;
  56. #ifdef _WINDOWS
  57. class CHXDIBits;
  58. #endif
  60. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  61. #include <X11/Xlib.h>
  62. #include <X11/Xutil.h>
  64. typedef ULONG32 COLORTYPE;
  67. class XData
  68. {
  69.   public:
  70.       XData()
  71.       {
  72.   m_Pixmap = 0;
  73.   m_Display = 0;
  74.       }
  76.       ~XData()
  77.       {
  78.   if (m_Pixmap != 0)
  79.   {
  80.               XFreePixmap(m_Display, m_Pixmap);
  81.   }
  82.       }
  84.   public:
  85.       HXBitmapInfoHeader m_backgroundBitmapInfoHeader;
  86.       Pixmap m_Pixmap;
  87.       Display* m_Display;
  88.       Colormap m_colormap;
  89. };
  90. #endif    // _UNIX
  93. class CSmil1DocumentRenderer:  public IHXSiteUser,
  94.        public IHXRendererAdviseSink,
  95.        public IHXGroupSink,
  96.        public IHXValues,
  97.        public CSmil1ElementHandler,
  98.        public IHXPassiveSiteWatcher,
  99.                                public CHXBaseCountingObject
  100. {
  101. public:
  102.     CSmil1DocumentRenderer     (CSmil1Renderer* pParent,
  103.     IUnknown* pContext);
  104.     virtual ~CSmil1DocumentRenderer  ();
  106.     HX_RESULT close     (CSmil1Renderer* pParent);
  107.     HX_RESULT setDocument     (const char* pFragment);
  108.     HX_RESULT onPacket     (IHXBuffer* pBuffer,
  109.     BOOL bIsFinal);
  111.     HX_RESULT handleLButtonUp     (const char* pID,
  112.     UINT16 uXPos,
  113.     UINT16 uYPos);
  115.     HX_RESULT handleMouseMove     (void* pWindow,
  116.     const char* pID,
  117.     UINT16 uXPos,
  118.     UINT16 uYPos);
  119.     BOOL handleSetCursor     ();
  121.     HX_RESULT detachSite     (IHXSite* pSite);
  123.     double     getResizeXScale()
  124.     {
  125. return m_dResizeXScale;
  126.     }
  127.     double     getResizeYScale()
  128.     {
  129. return m_dResizeYScale;
  130.     }
  132.     HX_RESULT addShowEvents     (const char* pRegionName,
  133.     IHXSite* pSite);
  135.     /*
  136.      * IUnknown methods
  137.      */
  138.     STDMETHOD(QueryInterface)     (THIS_
  139.     REFIID riid,
  140.     void** ppvObj);
  141.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  142.     STDMETHOD_(ULONG32, Release)    (THIS);
  144.     /*
  145.      * IHXSiteUser methods
  146.      */
  147.     STDMETHOD(AttachSite)     (THIS_
  148.     IHXSite* pSite);
  149.     STDMETHOD(DetachSite)     (THIS);
  150.     STDMETHOD(HandleEvent)     (THIS_
  151.     HXxEvent* pEvent);
  152.     STDMETHOD_(BOOL,NeedsWindowedSites) (THIS);
  154.     /*
  155.      * IHXRendererAdviseSink methods
  156.      */
  157.     STDMETHOD(TrackDurationSet) (THIS_
  158. UINT32 ulGroupIndex,
  159. UINT32 ulTrackIndex,
  160. UINT32 ulDuration,
  161. UINT32 ulDelay,
  162. BOOL   bIsLive);
  164.     STDMETHOD(RepeatedTrackDurationSet) (THIS_
  165. const char*  pID,
  166. UINT32 ulDuration,
  167.         BOOL   bIsLive);
  169.     STDMETHOD(RendererInitialized) (THIS_
  170. IHXRenderer* pRend,
  171. IUnknown* pStream,
  172. IHXValues* pInfo);
  174.     STDMETHOD(RendererClosed) (THIS_
  175. IHXRenderer* pRend,
  176. IHXValues* pInfo);
  178.     // /POST-RP8REV release IHXRendererAdviseSink method:
  179.     STDMETHOD(TrackUpdated)             (THIS_ UINT32 ulGroupIndex, UINT32 ulTrackIndex,
  180.                                                IHXValues* pValues);
  183.     /*
  184.      * IHXGroupSink methods
  185.      */
  186.     STDMETHOD(GroupAdded) (THIS_
  187. UINT16 uGroupIndex,
  188. IHXGroup* pGroup);
  190.     STDMETHOD(GroupRemoved) (THIS_
  191. UINT16 uGroupIndex,
  192. IHXGroup* pGroup);
  194.     STDMETHOD(AllGroupsRemoved) (THIS);
  196.     STDMETHOD(TrackAdded) (THIS_
  197. UINT16 uGroupIndex,
  198. UINT16 uTrackIndex,
  199. IHXValues* pTrack);
  201.     STDMETHOD(TrackRemoved) (THIS_
  202. UINT16 uGroupIndex,
  203. UINT16 uTrackIndex,
  204. IHXValues* pTrack);
  206.     STDMETHOD(TrackStarted) (THIS_
  207. UINT16 uGroupIndex,
  208. UINT16 uTrackIndex,
  209. IHXValues* pTrack);
  211.     STDMETHOD(TrackStopped) (THIS_
  212. UINT16 uGroupIndex,
  213. UINT16 uTrackIndex,
  214. IHXValues* pTrack);
  216.     STDMETHOD(CurrentGroupSet) (THIS_
  217. UINT16 uGroupIndex,
  218. IHXGroup* pGroup);
  220.     /*
  221.      * IHXValues methods
  222.      */
  223.     STDMETHOD(SetPropertyULONG32) (THIS_
  224. const char*  pPropertyName,
  225. ULONG32  uPropertyValue);
  227.     STDMETHOD(GetPropertyULONG32) (THIS_
  228. const char*  pPropertyName,
  229. REF(ULONG32)  uPropertyValue);
  231.     STDMETHOD(GetFirstPropertyULONG32) (THIS_
  232. REF(const char*) pPropertyName,
  233. REF(ULONG32)  uPropertyValue);
  235.     STDMETHOD(GetNextPropertyULONG32) (THIS_
  236. REF(const char*) pPropertyName,
  237. REF(ULONG32)  uPropertyValue);
  239.     STDMETHOD(SetPropertyBuffer) (THIS_
  240. const char*  pPropertyName,
  241. IHXBuffer*  pPropertyValue);
  243.     STDMETHOD(GetPropertyBuffer) (THIS_
  244. const char*  pPropertyName,
  245. REF(IHXBuffer*) pPropertyValue);
  247.     STDMETHOD(GetFirstPropertyBuffer) (THIS_
  248. REF(const char*) pPropertyName,
  249. REF(IHXBuffer*) pPropertyValue);
  251.     STDMETHOD(GetNextPropertyBuffer) (THIS_
  252. REF(const char*) pPropertyName,
  253. REF(IHXBuffer*) pPropertyValue);
  255.     STDMETHOD(SetPropertyCString) (THIS_
  256. const char*  pPropertyName,
  257. IHXBuffer*  pPropertyValue);
  259.     STDMETHOD(GetPropertyCString) (THIS_
  260. const char*  pPropertyName,
  261. REF(IHXBuffer*) pPropertyValue);
  263.     STDMETHOD(GetFirstPropertyCString) (THIS_
  264. REF(const char*) pPropertyName,
  265. REF(IHXBuffer*) pPropertyValue);
  267.     STDMETHOD(GetNextPropertyCString) (THIS_
  268. REF(const char*) pPropertyName,
  269. REF(IHXBuffer*) pPropertyValue);
  271.     /*
  272.      * IHXPassiveSiteWatcher methods
  273.      */
  274.     STDMETHOD(PositionChanged) (THIS_
  275. HXxPoint* /*IN*/ pPoint);
  277.     STDMETHOD(SizeChanged)  (THIS_
  278. HXxSize* /*IN*/ pSize);
  280.     /*
  281.      * CSmil1ElementHandler methods
  282.      */
  283.     HX_RESULT handleAddGroup (CSmil1AddGroup* pAddGroup);
  284.     HX_RESULT handleRegion (CSmil1Region* pRegion);
  285.     HX_RESULT handleRootLayout (CSmil1RootLayout* pRootLayout);
  286.     HX_RESULT handleSource (CSmil1Source* pSource);
  287.     HX_RESULT handleMeta (CSmil1Meta* pMeta);
  288.     HX_RESULT handleEndLayout (CSmil1EndLayout* pSource);
  289.     HX_RESULT handleRendererPreFetch (CSmil1RendererPreFetch* pRend);
  290.     HX_RESULT handleSourceUpdate (CSmil1SourceUpdate* pUpdate);
  292.     /*
  293.      * CSmil1Parser methods
  294.      */
  295.     HX_RESULT onHeader (IHXValues* pHeader);
  296.     HX_RESULT onTimeSync (UINT32 ulTimeValue);
  297.     HX_RESULT onPreSeek (UINT32 ulOldTime,
  298. UINT32 ulNewTime);
  299.     HX_RESULT endStream ();
  301.     HX_RESULT seekTo (const char* pElementID);
  303.     CSmil1BasicRegion* getRegion (const char* pID);
  304.     void resizeRegion (const char* pRegionName,
  305. HXxSize* pNewSize);
  306.     void repositionRegion (const char* pRegionName,
  307. HXxPoint* pNewPosition);
  308.     void setTopLevelSiteSize ();
  310.     HX_RESULT HandleSurfaceUpdate (HXxEvent* pEvent,
  311. IHXSite* pSite,
  312. HXxColor ulBGColor);
  314.     HX_RESULT getErrorInfo (REF(UINT32) ulErrorLine,
  315.  REF(UINT32) ulErrorColumn,
  316.  REF(IHXBuffer*) pErrorText);
  318.     HX_RESULT  GetElementProperties(UINT16 uGroupID, 
  319.       UINT16 uTrackID, 
  320.       REF(IHXValues*) pProperties);
  322.     HX_RESULT  GetElementStatus(UINT16     uGroupID,
  323.   UINT16     uTrackID,
  324.   UINT32     ulCurrentTime,
  325.   REF(IHXValues*)  pStatus);
  327.     HX_RESULT  AttachElementLayout(UINT16     uGroupID,
  328.      UINT16     uTrackID,
  329.      IHXRenderer*  pRenderer,
  330.      IHXStream*    pStream,
  331.      IHXValues*    pProps);
  332.     HX_RESULT  DetachElementLayout(IUnknown*     pLSG);
  334.     BOOL m_bSiteChangingSize;
  335.     BOOL m_bNeedToAdjustSites;
  336.     UINT32 m_ulNoRootLayoutHeight;
  337.     UINT32 m_ulNoRootLayoutWidth;
  339.     BOOL                                isRootLayoutWidthSet() const  { return m_bRootLayoutWidthSet;  }
  340.     BOOL                                isRootLayoutHeightSet() const { return m_bRootLayoutHeightSet; }
  342.     friend class CSmil1Renderer;
  344. private:
  345.     HX_RESULT addSiteForRenderer (SMIL1PlayToAssoc* pPlayToAssoc,
  346. SMIL1SourceInfo* pSMIL1SourceInfo,
  347. IHXRenderer* pRenderer,
  348. BOOL bNoRegion);
  349.     void setPlayToAssoc (UINT16 uGroupIndex, 
  350. UINT16 uTrackIndex, 
  351. const char* pID,
  352. const char* pRepeatID, // /For SHAZAM
  353. const char* pPlayTo,
  354. const char* pRegionName);
  355.     SMIL1PlayToAssoc* getPlayToAssoc (UINT16 uGroupIndex, 
  356. UINT16 uTrackIndex);
  357.     SMIL1PlayToAssoc* getPlayToAssoc (const char* pName); 
  358.     void removeAllPlayToAssoc ();
  359.     void removeGroupsPlayToAssoc (UINT16 uGroupIndex);
  360.     void removeSourcemap (SMIL1PlayToAssoc* pPlayToAssoc);
  361.     HX_RESULT insertEvent (CSmil1ShowSiteEvent* pEvent);
  362.     CSmil1ShowSiteEvent* getShowHideEvent(IHXSite* pRegionSite,
  363.   IHXSite* pRendererSite,
  364.                                           BOOL     bShowEvent);
  365.     HX_RESULT insertSiteInfo (void* pInfo);
  366.     void removeGroupEvents (UINT16 uGroupIndex);
  367.     void showSite (IHXSite* pSite, 
  368. BOOL bShow);
  369.     void resizeSite (HXxSize newSize);
  370.     void resizeSite (IHXSite* pSite,
  371. double dXScale,
  372. double dYScale);
  373.     void resizeRegionSiteAbs(CSmil1BasicRegion* pRegion,
  374.                              double            dXAbsScale,
  375.                              double            dYAbsScale);
  376.     BOOL draw (HXxEvent* pEvent,
  377. IHXSite* pSite,
  378. HXxColor ulBgColor);
  379.     void insertZOrder (IHXSite* pSite, 
  380. INT32 lZOrder);
  381.     void setZOrder ();
  382.     HX_RESULT handleElements ();
  383.     void setProperty (IHXValues* pValues, 
  384. const char* pName, 
  385. const char* pValue);
  386.     HX_RESULT parseDimension (const char* pDimensionString,
  387. REF(UINT32) ulValue,
  388. REF(BOOL) bIsPercent);
  389.     HX_RESULT regionToRect (CSmil1Region* pElement,
  390. HXxRect* pRect,
  391. BOOL& bWidthUnspecified,
  392. BOOL& bHeightUnspecified);
  393.     CSmil1AAnchorElement*
  394. findHyperlinkElement (const char* pID,
  395. UINT16 uXPos,
  396. UINT16 uYPos);
  397.     HX_RESULT convertURL (const char* pURL,
  398. CHXString& newURL);
  399.     HX_RESULT updateStreamTiming (const char* pElementID,
  400. UINT32 ulDuration);
  401.     HX_RESULT updateStreamDelay (UINT16 uGroupIndex,
  402. UINT32 ulDelay);
  403.     HX_RESULT updateSiteEvents (UINT16 uGroupIndex);
  404.     HX_RESULT createRegionSites ();
  406.     void      RemoveEvents (UINT32 ulGroupIndex, IHXSite* pSite);
  407.     HX_RESULT flushAllEvents (UINT32 ulFlushToTime, BOOL bBreak=FALSE );
  408.     inline HX_RESULT flushAllEvents () { return flushAllEvents( m_ulCurrentTime ); }
  410.     BOOL      IsFullScreen();
  411.     void      computeMediaFitSize(HXxSize cRegSize, HXxSize cMedSize,
  412.                                   const char* pszFitAttr, REF(HXxSize) rcFitSize);
  413.     HX_RESULT getPreference(IUnknown*        pContext,
  414.                             const char*      pszKey,
  415.                             REF(IHXBuffer*) rpValue);
  416.     HX_RESULT getBooleanPreference(IUnknown*   pContext, 
  417.                                    const char* pszKey,
  418.                                    REF(BOOL)   rbValue);
  420. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  421.     void ConvertPNxColorToXColor(HXxColor hxxColor, XColor& xcolor);
  422.     XData* InitXVisualSupport(IHXSite* pSite, HXxWindow* pWnd);
  423. #endif
  425.     CSmil1Renderer* m_pParent;
  426.     CSmil1Parser* m_pSmilParser;
  427.     HX_RESULT m_ulParseResult;
  428.     IHXSite* m_pMISUSSite;
  429.     IHXScheduler* m_pScheduler;
  430. public:
  431.     HXxSize m_topSiteSize;
  432.     HXxSize m_topSiteOriginalSize;
  433. private:
  434.     IHXValues* m_pValues;
  435.     char* m_pFragment;
  436.     CHXMapStringToOb* m_pRegionMap;
  437.     CHXMapPtrToPtr* m_pSiteInfoByRendererMap;
  438.     CHXMapPtrToPtr* m_pSiteWatcherMap;
  439.     CHXMapLongToObj* m_pGroupInfoMap;
  440.     CHXMapLongToObj* m_pGroupMap;
  441.     CHXMapStringToOb* m_pDeferredSourceMap;
  442.     CHXMapStringToOb* m_pRepeatIDMap;
  443.     CHXSimpleList* m_pSiteInfoList;
  444.     CHXSimpleList* m_pPlayToAssocList;
  445.     CHXSimpleList* m_pEventList;
  446.     CHXSimpleList* m_pZOrderList;
  447.     LISTPOSITION m_ulEventListPosition;
  448.     INT16 m_uCurrentGroupIndex;
  449.     INT16 m_nFragmentTracks;
  450.     UINT32 m_ulCurrentTime;
  451.     LONG32 m_lRefCount;
  452.     IUnknown* m_pContext;
  453.     IHXSiteManager* m_pSiteMgr;
  454.     IHXStatusMessage* m_pStatusMessage;
  455.     BOOL m_bFirstTimeSync;
  456.     BOOL m_bSettingFragment;
  457.     BOOL m_bInHyperlink;
  458.     BOOL m_bShowDependencies;
  459.     BOOL m_bSiteLayoutComplete;
  460.     BOOL m_bStatusMessageSet;
  461.     double m_dResizeXScale;
  462.     double m_dResizeYScale;
  463.     UINT32                              m_ulPktnum;
  464.     UINT16                              m_usOldXPos;
  465.     UINT16                              m_usOldYPos;
  466.     ProcessElementCallback* m_pProcessElementCallback;
  468. #ifdef _WINDOWS
  469.     HCURSOR  m_hHyperlinkCursor;
  470.     HCURSOR m_hPreHyperlinkCursor;
  471.     BOOL m_bNeedToSetHyperlinkCursor;
  472. #endif
  473. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  474.     BOOL m_bResetCursor;
  475.     CursHandle m_hHyperlinkCursor;
  476.     CResourceLoader* m_pResourceLoader;
  477. #endif
  479. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  480.     // needed for background drawing
  481.     XVisualInfo*                        m_pVisualInfo;
  482.     Cursor                              m_hHyperlinkCursor;
  483.     Cursor                              m_hCurrentCursor;
  484.     Display*                            m_pDisplay;          
  485.     Window                              m_Window;
  486.     Display*                            m_pPixmapDisplay;
  487.     CHXMapPtrToPtr                      m_siteToXDataMap;
  488. #endif
  490.     BOOL m_bRootLayoutWidthSet;
  491.     BOOL m_bRootLayoutHeightSet;
  492.     UINT32 m_ulRootLayoutHeight;
  493.     UINT32 m_ulRootLayoutWidth;
  494.     HXxColor m_ulRootLayoutBGColor;
  496.     UINT32     m_ulGroupIndex;
  497.     UINT32     m_ulTrackIndex;
  498.     UINT16     m_uGroupIndexWithin;
  499.     BOOL     m_bSitesDetached;
  500.     BOOL     m_bInRAM20;
  501.     BOOL     m_bLastGroupInRAM20;
  502.     INT32     m_ulPersistentComponentDelay;
  503.     UINT32     m_ulPersistentComponentID;
  504.     UINT16     m_uPersistentGroupID;
  505.     UINT16     m_uPersistentTrackID;
  506.     ElementWithinTag     m_elementWithinTag;
  507.     IHXValues*     m_pPersistentProperties;
  508.     IHXPersistentRenderer* m_pPersistentParentRenderer;
  509.     BOOL                    m_bCloseCalled;
  511.     HX_RESULT     InitPersistent(UINT32     ulPersistentComponentID,
  512.    UINT16     uPersistentGroupID,
  513.    UINT16     uPersistentTrackID,
  514.    IHXPersistentRenderer*  pPersistentParent);
  516.     HX_RESULT     setupRootLayout();
  517.     BOOL     IsNestedMetaSupported(UINT16& uSupportedType);
  518.     void     PersistentDurationSet(UINT32 ulDuration, UINT32 ulDelay, BOOL bIsLive);
  519. };
  521. class CSmil1SiteWatcher: public CHXBaseCountingObject,
  522.                          public IHXSiteWatcher
  523. {
  524. public:
  525.     CSmil1SiteWatcher     (CSmil1DocumentRenderer* pDoc, 
  526.     const char* pID,
  527.     BOOL bIsChildSite);
  528.     ~CSmil1SiteWatcher     ();
  530.     HX_RESULT close     ();
  532.     IHXSite*     GetSite() { return m_pSite; }
  533.     void     SiteChangingSize(BOOL bFlag) { m_bChangingSize = bFlag; }
  535.     /*
  536.      * IUnknown methods
  537.      */
  538.     STDMETHOD(QueryInterface)     (THIS_
  539.     REFIID riid,
  540.     void** ppvObj);
  541.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  542.     STDMETHOD_(ULONG32, Release)    (THIS);
  544.     /*
  545.      * IHXSiteWatcher methods
  546.      */
  547.     STDMETHOD(AttachSite)     (THIS_
  548.     IHXSite* pSite);
  550.     STDMETHOD(DetachSite)     (THIS);
  551.     
  552.     STDMETHOD(ChangingPosition)     (THIS_
  553.     HXxPoint posOld,
  554.     REF(HXxPoint) posNew);
  556.     STDMETHOD(ChangingSize)     (THIS_
  557.     HXxSize sizeOld,
  558.     REF(HXxSize) posNew);
  559. private:
  560.     CHXString          m_id;
  561.     CSmil1DocumentRenderer*       m_pDoc;
  562.     IHXSite*          m_pSite;
  563.     BOOL     m_bIsChildSite;
  564.     BOOL     m_bChangingSize;
  565.     LONG32          m_lRefCount;
  566.     BOOL                            m_bFirstSetSize;
  567. };
  569. class CSmil1EventHook: public CHXBaseCountingObject,
  570.                        public IHXEventHook
  571. {
  572. public:
  573.     CSmil1EventHook     (CSmil1DocumentRenderer* pDoc,
  574.     const char* pRegionName,
  575.     const char* pChannelName,
  576.     BOOL bNoRegion);
  577.     virtual ~CSmil1EventHook     ();
  579.     /*
  580.      * IUnknown methods
  581.      */
  582.     STDMETHOD(QueryInterface)     (THIS_
  583.     REFIID riid,
  584.     void** ppvObj);
  585.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  586.     STDMETHOD_(ULONG32, Release)    (THIS);
  588.     /*
  589.      * IHXEventHook methods
  590.      */
  591.     STDMETHOD(HandleEvent)     (IHXSite* pSite,
  592.     HXxEvent* pEvent);
  593.     STDMETHOD(SiteAdded)     (IHXSite* pSite);
  594.     STDMETHOD(SiteRemoved)     (IHXSite* pSite);
  595.     
  596.     char*     m_pChannelName;
  598. private:
  599.     CSmil1DocumentRenderer*     m_pDoc;
  600.     char*     m_pRegionName;
  601.     IHXSite*     m_pSite;
  602.     BOOL     m_bNoRegion;
  603.     CSmil1PassiveSiteWatcher*     m_pSiteWatcher;
  604.     LONG32     m_lRefCount;
  605. };
  607. class CSmil1PassiveSiteWatcher: public CHXBaseCountingObject,
  608.                                 public IHXPassiveSiteWatcher
  609. {
  610. public:
  611.     CSmil1PassiveSiteWatcher     (CSmil1DocumentRenderer* pDoc,
  612.     const char* pRegionName);
  613.     ~CSmil1PassiveSiteWatcher     ();
  615.     /*
  616.      * IUnknown methods
  617.      */
  618.     STDMETHOD(QueryInterface)     (THIS_
  619.     REFIID riid,
  620.     void** ppvObj);
  621.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  622.     STDMETHOD_(ULONG32, Release)    (THIS);
  624.     /*
  625.      * IHXPassiveSiteWatcher methods
  626.      */
  627.     STDMETHOD(PositionChanged)     (THIS_
  628.     HXxPoint* pPoint);
  629.     STDMETHOD(SizeChanged)     (THIS_
  630.     HXxSize* pSize);
  632. private:
  633.     LONG32     m_lRefCount;
  634.     CSmil1DocumentRenderer*     m_pDoc;
  635.     char*     m_pRegionName;
  636. };
  638. class CSmil1SiteUser: public CHXBaseCountingObject,
  639.                       public IHXSiteUser
  640. {
  641. public:
  642.     CSmil1SiteUser     (CSmil1DocumentRenderer* pDoc,
  643.     HXxColor ulBGColor);
  644.     ~CSmil1SiteUser     ();
  646.     /*
  647.      * IUnknown methods
  648.      */
  649.     STDMETHOD(QueryInterface)     (THIS_
  650.     REFIID riid,
  651.     void** ppvObj);
  652.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  653.     STDMETHOD_(ULONG32, Release)    (THIS);
  655.     /*
  656.      * IHXSiteUser methods
  657.      */
  658.     STDMETHOD(AttachSite)     (THIS_
  659.     IHXSite* pSite);
  660.     STDMETHOD(DetachSite)     (THIS);
  661.     STDMETHOD(HandleEvent)     (THIS_
  662.     HXxEvent* pEvent);
  663.     STDMETHOD_(BOOL,NeedsWindowedSites) (THIS);
  665. private:
  666.     LONG32     m_lRefCount;
  667.     HXxColor     m_ulBGColor;
  668.     CSmil1DocumentRenderer*     m_pDoc;
  669.     IHXSite*     m_pSite;
  670. };
  672. /*
  673.  * CSmil1BasicRegion methods
  674.  */
  676. class CSmil1BasicRegion : public CHXBaseCountingObject
  677. {
  678. public:
  679.     CSmil1BasicRegion     (const char* pName, 
  680.     HXxRect rect, 
  681.     INT32 lZindex, 
  682.     const char* pFit, 
  683.     HXxColor ulBgColor,
  684.     BOOL bBgColorSet, 
  685.     BOOL bImplicitRegion,
  686.     BOOL bWidthUnspecified,
  687.     BOOL bHeightUnspecified);
  688.     ~CSmil1BasicRegion();
  690.     HXxRect m_rect;
  691.     HXxRect m_originalRect;
  692.     HXxSize m_mediaSize;
  693.     HXxSize m_originalMediaSize;
  694.     BOOL    m_bMediaSizeSet;
  695.     IHXSite* m_pSite;
  696.     IHXSiteUser* m_pSiteUser;
  697.     INT32 m_lZIndex;
  698.     CHXString m_region;
  699.     CHXString m_fit;
  700.     HXxColor m_ulBgColor;
  701.     BOOL m_bBgColorSet;
  702.     BOOL m_bImplicitRegion;
  703.     BOOL m_bWidthUnspecified;
  704.     BOOL m_bHeightUnspecified;
  705. };
  707. class ProcessElementCallback : public IHXCallback
  708. {
  709. public:
  710.     CHXString m_elementID;
  711.     CSmil1DocumentRenderer* m_pOwner;
  712.     CallbackHandle m_PendingHandle;
  713.     BOOL m_bIsCallbackPending;
  715. ProcessElementCallback();
  716.     /*
  717.      * IUnknown methods
  718.      */
  719.     STDMETHOD(QueryInterface) (THIS_
  720. REFIID riid,
  721. void** ppvObj);
  722.     STDMETHOD_(ULONG32,AddRef) (THIS);
  723.     STDMETHOD_(ULONG32,Release) (THIS);
  725.     /*
  726.      * IHXCallback methods
  727.      */
  728.     STDMETHOD(Func) (THIS);
  730. protected:
  731. ~ProcessElementCallback();
  732.     LONG32 m_lRefCount;
  733. };
  735. #endif /* _SM1DOC_H_ */