Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
sm1doc.h
Package: 142_61_thumb_advanced.rar　[view]
Upload User: dangjiwu
Upload Date: 2013-07-19
Package Size: 42019k
Code Size: 22k
Category:

Symbian

Development Platform:

Visual C++

sm1doc.h：Code Content
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: sm1doc.h,v 1.2.12.1 2004/07/09 01:57:34 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #ifndef _SM1DOC_H_
  51. #define _SM1DOC_H_
  53. #include "hxthread.h"
  54. #include "baseobj.h"
  56. class CSmil1Renderer;
  57. class CSmil1Parser;
  58. class CSmil1BasicRegion;
  59. class CSmil1RootLayout;
  60. class CHXHeader;
  61. struct SMIL1PlayToAssoc;
  62. struct SMIL1SourceInfo;
  63. class CSmil1LayoutEvent;
  64. class CSmil1ShowSiteEvent;
  65. class CSmil1EventHook;
  66. class CSmil1PassiveSiteWatcher;
  67. class CResourceLoader;
  68. class ProcessElementCallback;
  70. #ifdef _WINDOWS
  71. class CHXDIBits;
  72. #endif
  74. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  75. #include <X11/Xlib.h>
  76. #include <X11/Xutil.h>
  78. typedef ULONG32 COLORTYPE;
  81. class XData
  82. {
  83.   public:
  84.       XData()
  85.       {
  86.   m_Pixmap = 0;
  87.   m_Display = 0;
  88.       }
  90.       ~XData()
  91.       {
  92.   if (m_Pixmap != 0)
  93.   {
  94.               XFreePixmap(m_Display, m_Pixmap);
  95.   }
  96.       }
  98.   public:
  99.       HXBitmapInfoHeader m_backgroundBitmapInfoHeader;
  100.       Pixmap m_Pixmap;
  101.       Display* m_Display;
  102.       Colormap m_colormap;
  103. };
  104. #endif    // _UNIX
  107. class CSmil1DocumentRenderer:  public IHXSiteUser,
  108.        public IHXRendererAdviseSink,
  109.        public IHXGroupSink,
  110.        public IHXValues,
  111.        public CSmil1ElementHandler,
  112.        public IHXPassiveSiteWatcher,
  113.                                public CHXBaseCountingObject
  114. {
  115. public:
  116.     CSmil1DocumentRenderer     (CSmil1Renderer* pParent,
  117.     IUnknown* pContext);
  118.     virtual ~CSmil1DocumentRenderer  ();
  120.     HX_RESULT close     (CSmil1Renderer* pParent);
  121.     HX_RESULT setDocument     (const char* pFragment);
  122.     HX_RESULT onPacket     (IHXBuffer* pBuffer,
  123.     BOOL bIsFinal);
  125.     HX_RESULT handleLButtonUp     (const char* pID,
  126.     UINT16 uXPos,
  127.     UINT16 uYPos);
  129.     HX_RESULT handleMouseMove     (void* pWindow,
  130.     const char* pID,
  131.     UINT16 uXPos,
  132.     UINT16 uYPos);
  133.     BOOL handleSetCursor     ();
  135.     HX_RESULT detachSite     (IHXSite* pSite);
  137.     double     getResizeXScale()
  138.     {
  139. return m_dResizeXScale;
  140.     }
  141.     double     getResizeYScale()
  142.     {
  143. return m_dResizeYScale;
  144.     }
  146.     HX_RESULT addShowEvents     (const char* pRegionName,
  147.     IHXSite* pSite);
  149.     /*
  150.      * IUnknown methods
  151.      */
  152.     STDMETHOD(QueryInterface)     (THIS_
  153.     REFIID riid,
  154.     void** ppvObj);
  155.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  156.     STDMETHOD_(ULONG32, Release)    (THIS);
  158.     /*
  159.      * IHXSiteUser methods
  160.      */
  161.     STDMETHOD(AttachSite)     (THIS_
  162.     IHXSite* pSite);
  163.     STDMETHOD(DetachSite)     (THIS);
  164.     STDMETHOD(HandleEvent)     (THIS_
  165.     HXxEvent* pEvent);
  166.     STDMETHOD_(BOOL,NeedsWindowedSites) (THIS);
  168.     /*
  169.      * IHXRendererAdviseSink methods
  170.      */
  171.     STDMETHOD(TrackDurationSet) (THIS_
  172. UINT32 ulGroupIndex,
  173. UINT32 ulTrackIndex,
  174. UINT32 ulDuration,
  175. UINT32 ulDelay,
  176. BOOL   bIsLive);
  178.     STDMETHOD(RepeatedTrackDurationSet) (THIS_
  179. const char*  pID,
  180. UINT32 ulDuration,
  181.         BOOL   bIsLive);
  183.     STDMETHOD(RendererInitialized) (THIS_
  184. IHXRenderer* pRend,
  185. IUnknown* pStream,
  186. IHXValues* pInfo);
  188.     STDMETHOD(RendererClosed) (THIS_
  189. IHXRenderer* pRend,
  190. IHXValues* pInfo);
  192.     // /POST-RP8REV release IHXRendererAdviseSink method:
  193.     STDMETHOD(TrackUpdated)             (THIS_ UINT32 ulGroupIndex, UINT32 ulTrackIndex,
  194.                                                IHXValues* pValues);
  197.     /*
  198.      * IHXGroupSink methods
  199.      */
  200.     STDMETHOD(GroupAdded) (THIS_
  201. UINT16 uGroupIndex,
  202. IHXGroup* pGroup);
  204.     STDMETHOD(GroupRemoved) (THIS_
  205. UINT16 uGroupIndex,
  206. IHXGroup* pGroup);
  208.     STDMETHOD(AllGroupsRemoved) (THIS);
  210.     STDMETHOD(TrackAdded) (THIS_
  211. UINT16 uGroupIndex,
  212. UINT16 uTrackIndex,
  213. IHXValues* pTrack);
  215.     STDMETHOD(TrackRemoved) (THIS_
  216. UINT16 uGroupIndex,
  217. UINT16 uTrackIndex,
  218. IHXValues* pTrack);
  220.     STDMETHOD(TrackStarted) (THIS_
  221. UINT16 uGroupIndex,
  222. UINT16 uTrackIndex,
  223. IHXValues* pTrack);
  225.     STDMETHOD(TrackStopped) (THIS_
  226. UINT16 uGroupIndex,
  227. UINT16 uTrackIndex,
  228. IHXValues* pTrack);
  230.     STDMETHOD(CurrentGroupSet) (THIS_
  231. UINT16 uGroupIndex,
  232. IHXGroup* pGroup);
  234.     /*
  235.      * IHXValues methods
  236.      */
  237.     STDMETHOD(SetPropertyULONG32) (THIS_
  238. const char*  pPropertyName,
  239. ULONG32  uPropertyValue);
  241.     STDMETHOD(GetPropertyULONG32) (THIS_
  242. const char*  pPropertyName,
  243. REF(ULONG32)  uPropertyValue);
  245.     STDMETHOD(GetFirstPropertyULONG32) (THIS_
  246. REF(const char*) pPropertyName,
  247. REF(ULONG32)  uPropertyValue);
  249.     STDMETHOD(GetNextPropertyULONG32) (THIS_
  250. REF(const char*) pPropertyName,
  251. REF(ULONG32)  uPropertyValue);
  253.     STDMETHOD(SetPropertyBuffer) (THIS_
  254. const char*  pPropertyName,
  255. IHXBuffer*  pPropertyValue);
  257.     STDMETHOD(GetPropertyBuffer) (THIS_
  258. const char*  pPropertyName,
  259. REF(IHXBuffer*) pPropertyValue);
  261.     STDMETHOD(GetFirstPropertyBuffer) (THIS_
  262. REF(const char*) pPropertyName,
  263. REF(IHXBuffer*) pPropertyValue);
  265.     STDMETHOD(GetNextPropertyBuffer) (THIS_
  266. REF(const char*) pPropertyName,
  267. REF(IHXBuffer*) pPropertyValue);
  269.     STDMETHOD(SetPropertyCString) (THIS_
  270. const char*  pPropertyName,
  271. IHXBuffer*  pPropertyValue);
  273.     STDMETHOD(GetPropertyCString) (THIS_
  274. const char*  pPropertyName,
  275. REF(IHXBuffer*) pPropertyValue);
  277.     STDMETHOD(GetFirstPropertyCString) (THIS_
  278. REF(const char*) pPropertyName,
  279. REF(IHXBuffer*) pPropertyValue);
  281.     STDMETHOD(GetNextPropertyCString) (THIS_
  282. REF(const char*) pPropertyName,
  283. REF(IHXBuffer*) pPropertyValue);
  285.     /*
  286.      * IHXPassiveSiteWatcher methods
  287.      */
  288.     STDMETHOD(PositionChanged) (THIS_
  289. HXxPoint* /*IN*/ pPoint);
  291.     STDMETHOD(SizeChanged)  (THIS_
  292. HXxSize* /*IN*/ pSize);
  294.     /*
  295.      * CSmil1ElementHandler methods
  296.      */
  297.     HX_RESULT handleAddGroup (CSmil1AddGroup* pAddGroup);
  298.     HX_RESULT handleRegion (CSmil1Region* pRegion);
  299.     HX_RESULT handleRootLayout (CSmil1RootLayout* pRootLayout);
  300.     HX_RESULT handleSource (CSmil1Source* pSource);
  301.     HX_RESULT handleMeta (CSmil1Meta* pMeta);
  302.     HX_RESULT handleEndLayout (CSmil1EndLayout* pSource);
  303.     HX_RESULT handleRendererPreFetch (CSmil1RendererPreFetch* pRend);
  304.     HX_RESULT handleSourceUpdate (CSmil1SourceUpdate* pUpdate);
  306.     /*
  307.      * CSmil1Parser methods
  308.      */
  309.     HX_RESULT onHeader (IHXValues* pHeader);
  310.     HX_RESULT onTimeSync (UINT32 ulTimeValue);
  311.     HX_RESULT onPreSeek (UINT32 ulOldTime,
  312. UINT32 ulNewTime);
  313.     HX_RESULT endStream ();
  315.     HX_RESULT seekTo (const char* pElementID);
  317.     CSmil1BasicRegion* getRegion (const char* pID);
  318.     void resizeRegion (const char* pRegionName,
  319. HXxSize* pNewSize);
  320.     void repositionRegion (const char* pRegionName,
  321. HXxPoint* pNewPosition);
  322.     void setTopLevelSiteSize ();
  324.     HX_RESULT HandleSurfaceUpdate (HXxEvent* pEvent,
  325. IHXSite* pSite,
  326. HXxColor ulBGColor);
  328.     HX_RESULT getErrorInfo (REF(UINT32) ulErrorLine,
  329.  REF(UINT32) ulErrorColumn,
  330.  REF(IHXBuffer*) pErrorText);
  332.     HX_RESULT  GetElementProperties(UINT16 uGroupID, 
  333.       UINT16 uTrackID, 
  334.       REF(IHXValues*) pProperties);
  336.     HX_RESULT  GetElementStatus(UINT16     uGroupID,
  337.   UINT16     uTrackID,
  338.   UINT32     ulCurrentTime,
  339.   REF(IHXValues*)  pStatus);
  341.     HX_RESULT  AttachElementLayout(UINT16     uGroupID,
  342.      UINT16     uTrackID,
  343.      IHXRenderer*  pRenderer,
  344.      IHXStream*    pStream,
  345.      IHXValues*    pProps);
  346.     HX_RESULT  DetachElementLayout(IUnknown*     pLSG);
  348.     BOOL m_bSiteChangingSize;
  349.     BOOL m_bNeedToAdjustSites;
  350.     UINT32 m_ulNoRootLayoutHeight;
  351.     UINT32 m_ulNoRootLayoutWidth;
  353.     BOOL                                isRootLayoutWidthSet() const  { return m_bRootLayoutWidthSet;  }
  354.     BOOL                                isRootLayoutHeightSet() const { return m_bRootLayoutHeightSet; }
  356.     friend class CSmil1Renderer;
  358. private:
  359.     HX_RESULT addSiteForRenderer (SMIL1PlayToAssoc* pPlayToAssoc,
  360. SMIL1SourceInfo* pSMIL1SourceInfo,
  361. IHXRenderer* pRenderer,
  362. BOOL bNoRegion);
  363.     void setPlayToAssoc (UINT16 uGroupIndex, 
  364. UINT16 uTrackIndex, 
  365. const char* pID,
  366. const char* pRepeatID, // /For SHAZAM
  367. const char* pPlayTo,
  368. const char* pRegionName);
  369.     SMIL1PlayToAssoc* getPlayToAssoc (UINT16 uGroupIndex, 
  370. UINT16 uTrackIndex);
  371.     SMIL1PlayToAssoc* getPlayToAssoc (const char* pName); 
  372.     void removeAllPlayToAssoc ();
  373.     void removeGroupsPlayToAssoc (UINT16 uGroupIndex);
  374.     void removeSourcemap (SMIL1PlayToAssoc* pPlayToAssoc);
  375.     HX_RESULT insertEvent (CSmil1ShowSiteEvent* pEvent);
  376.     CSmil1ShowSiteEvent* getShowHideEvent(IHXSite* pRegionSite,
  377.   IHXSite* pRendererSite,
  378.                                           BOOL     bShowEvent);
  379.     HX_RESULT insertSiteInfo (void* pInfo);
  380.     void removeGroupEvents (UINT16 uGroupIndex);
  381.     void showSite (IHXSite* pSite, 
  382. BOOL bShow);
  383.     void resizeSite (HXxSize newSize);
  384.     void resizeSite (IHXSite* pSite,
  385. double dXScale,
  386. double dYScale);
  387.     void resizeRegionSiteAbs(CSmil1BasicRegion* pRegion,
  388.                              double            dXAbsScale,
  389.                              double            dYAbsScale);
  390.     BOOL draw (HXxEvent* pEvent,
  391. IHXSite* pSite,
  392. HXxColor ulBgColor);
  393.     void insertZOrder (IHXSite* pSite, 
  394. INT32 lZOrder);
  395.     void setZOrder ();
  396.     HX_RESULT handleElements ();
  397.     void setProperty (IHXValues* pValues, 
  398. const char* pName, 
  399. const char* pValue);
  400.     HX_RESULT parseDimension (const char* pDimensionString,
  401. REF(UINT32) ulValue,
  402. REF(BOOL) bIsPercent);
  403.     HX_RESULT regionToRect (CSmil1Region* pElement,
  404. HXxRect* pRect,
  405. BOOL& bWidthUnspecified,
  406. BOOL& bHeightUnspecified);
  407.     CSmil1AAnchorElement*
  408. findHyperlinkElement (const char* pID,
  409. UINT16 uXPos,
  410. UINT16 uYPos);
  411.     HX_RESULT convertURL (const char* pURL,
  412. CHXString& newURL);
  413.     HX_RESULT updateStreamTiming (const char* pElementID,
  414. UINT32 ulDuration);
  415.     HX_RESULT updateStreamDelay (UINT16 uGroupIndex,
  416. UINT32 ulDelay);
  417.     HX_RESULT updateSiteEvents (UINT16 uGroupIndex);
  418.     HX_RESULT createRegionSites ();
  420.     void      RemoveEvents (UINT32 ulGroupIndex, IHXSite* pSite);
  421.     HX_RESULT flushAllEvents (UINT32 ulFlushToTime, BOOL bBreak=FALSE );
  422.     inline HX_RESULT flushAllEvents () { return flushAllEvents( m_ulCurrentTime ); }
  424.     BOOL      IsFullScreen();
  425.     void      computeMediaFitSize(HXxSize cRegSize, HXxSize cMedSize,
  426.                                   const char* pszFitAttr, REF(HXxSize) rcFitSize);
  427.     HX_RESULT getPreference(IUnknown*        pContext,
  428.                             const char*      pszKey,
  429.                             REF(IHXBuffer*) rpValue);
  430.     HX_RESULT getBooleanPreference(IUnknown*   pContext, 
  431.                                    const char* pszKey,
  432.                                    REF(BOOL)   rbValue);
  434. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  435.     void ConvertPNxColorToXColor(HXxColor hxxColor, XColor& xcolor);
  436.     XData* InitXVisualSupport(IHXSite* pSite, HXxWindow* pWnd);
  437. #endif
  439.     CSmil1Renderer* m_pParent;
  440.     CSmil1Parser* m_pSmilParser;
  441.     HX_RESULT m_ulParseResult;
  442.     IHXSite* m_pMISUSSite;
  443.     IHXScheduler* m_pScheduler;
  444. public:
  445.     HXxSize m_topSiteSize;
  446.     HXxSize m_topSiteOriginalSize;
  447. private:
  448.     IHXValues* m_pValues;
  449.     char* m_pFragment;
  450.     CHXMapStringToOb* m_pRegionMap;
  451.     CHXMapPtrToPtr* m_pSiteInfoByRendererMap;
  452.     CHXMapPtrToPtr* m_pSiteWatcherMap;
  453.     CHXMapLongToObj* m_pGroupInfoMap;
  454.     CHXMapLongToObj* m_pGroupMap;
  455.     CHXMapStringToOb* m_pDeferredSourceMap;
  456.     CHXMapStringToOb* m_pRepeatIDMap;
  457.     CHXSimpleList* m_pSiteInfoList;
  458.     CHXSimpleList* m_pPlayToAssocList;
  459.     CHXSimpleList* m_pEventList;
  460.     CHXSimpleList* m_pZOrderList;
  461.     LISTPOSITION m_ulEventListPosition;
  462.     INT16 m_uCurrentGroupIndex;
  463.     INT16 m_nFragmentTracks;
  464.     UINT32 m_ulCurrentTime;
  465.     LONG32 m_lRefCount;
  466.     IUnknown* m_pContext;
  467.     IHXSiteManager* m_pSiteMgr;
  468.     IHXStatusMessage* m_pStatusMessage;
  469.     BOOL m_bFirstTimeSync;
  470.     BOOL m_bSettingFragment;
  471.     BOOL m_bInHyperlink;
  472.     BOOL m_bShowDependencies;
  473.     BOOL m_bSiteLayoutComplete;
  474.     BOOL m_bStatusMessageSet;
  475.     double m_dResizeXScale;
  476.     double m_dResizeYScale;
  477.     UINT32                              m_ulPktnum;
  478.     UINT16                              m_usOldXPos;
  479.     UINT16                              m_usOldYPos;
  480.     ProcessElementCallback* m_pProcessElementCallback;
  482. #ifdef _WINDOWS
  483.     HCURSOR  m_hHyperlinkCursor;
  484.     HCURSOR m_hPreHyperlinkCursor;
  485.     BOOL m_bNeedToSetHyperlinkCursor;
  486. #endif
  487. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  488.     BOOL m_bResetCursor;
  489.     CursHandle m_hHyperlinkCursor;
  490.     CResourceLoader* m_pResourceLoader;
  491. #endif
  493. #if defined(_UNIX) && (!(defined(_BEOS))) && (!(defined(_MAC_UNIX)))
  494.     // needed for background drawing
  495.     XVisualInfo*                        m_pVisualInfo;
  496.     Cursor                              m_hHyperlinkCursor;
  497.     Cursor                              m_hCurrentCursor;
  498.     Display*                            m_pDisplay;          
  499.     Window                              m_Window;
  500.     Display*                            m_pPixmapDisplay;
  501.     CHXMapPtrToPtr                      m_siteToXDataMap;
  502. #endif
  504.     BOOL m_bRootLayoutWidthSet;
  505.     BOOL m_bRootLayoutHeightSet;
  506.     UINT32 m_ulRootLayoutHeight;
  507.     UINT32 m_ulRootLayoutWidth;
  508.     HXxColor m_ulRootLayoutBGColor;
  510.     UINT32     m_ulGroupIndex;
  511.     UINT32     m_ulTrackIndex;
  512.     UINT16     m_uGroupIndexWithin;
  513.     BOOL     m_bSitesDetached;
  514.     BOOL     m_bInRAM20;
  515.     BOOL     m_bLastGroupInRAM20;
  516.     INT32     m_ulPersistentComponentDelay;
  517.     UINT32     m_ulPersistentComponentID;
  518.     UINT16     m_uPersistentGroupID;
  519.     UINT16     m_uPersistentTrackID;
  520.     ElementWithinTag     m_elementWithinTag;
  521.     IHXValues*     m_pPersistentProperties;
  522.     IHXPersistentRenderer* m_pPersistentParentRenderer;
  523.     BOOL                    m_bCloseCalled;
  525.     HX_RESULT     InitPersistent(UINT32     ulPersistentComponentID,
  526.    UINT16     uPersistentGroupID,
  527.    UINT16     uPersistentTrackID,
  528.    IHXPersistentRenderer*  pPersistentParent);
  530.     HX_RESULT     setupRootLayout();
  531.     BOOL     IsNestedMetaSupported(UINT16& uSupportedType);
  532.     void     PersistentDurationSet(UINT32 ulDuration, UINT32 ulDelay, BOOL bIsLive);
  533. };
  535. class CSmil1SiteWatcher: public CHXBaseCountingObject,
  536.                          public IHXSiteWatcher
  537. {
  538. public:
  539.     CSmil1SiteWatcher     (CSmil1DocumentRenderer* pDoc, 
  540.     const char* pID,
  541.     BOOL bIsChildSite);
  542.     ~CSmil1SiteWatcher     ();
  544.     HX_RESULT close     ();
  546.     IHXSite*     GetSite() { return m_pSite; }
  547.     void     SiteChangingSize(BOOL bFlag) { m_bChangingSize = bFlag; }
  549.     /*
  550.      * IUnknown methods
  551.      */
  552.     STDMETHOD(QueryInterface)     (THIS_
  553.     REFIID riid,
  554.     void** ppvObj);
  555.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  556.     STDMETHOD_(ULONG32, Release)    (THIS);
  558.     /*
  559.      * IHXSiteWatcher methods
  560.      */
  561.     STDMETHOD(AttachSite)     (THIS_
  562.     IHXSite* pSite);
  564.     STDMETHOD(DetachSite)     (THIS);
  565.     
  566.     STDMETHOD(ChangingPosition)     (THIS_
  567.     HXxPoint posOld,
  568.     REF(HXxPoint) posNew);
  570.     STDMETHOD(ChangingSize)     (THIS_
  571.     HXxSize sizeOld,
  572.     REF(HXxSize) posNew);
  573. private:
  574.     CHXString          m_id;
  575.     CSmil1DocumentRenderer*       m_pDoc;
  576.     IHXSite*          m_pSite;
  577.     BOOL     m_bIsChildSite;
  578.     BOOL     m_bChangingSize;
  579.     LONG32          m_lRefCount;
  580.     BOOL                            m_bFirstSetSize;
  581. };
  583. class CSmil1EventHook: public CHXBaseCountingObject,
  584.                        public IHXEventHook
  585. {
  586. public:
  587.     CSmil1EventHook     (CSmil1DocumentRenderer* pDoc,
  588.     const char* pRegionName,
  589.     const char* pChannelName,
  590.     BOOL bNoRegion);
  591.     virtual ~CSmil1EventHook     ();
  593.     /*
  594.      * IUnknown methods
  595.      */
  596.     STDMETHOD(QueryInterface)     (THIS_
  597.     REFIID riid,
  598.     void** ppvObj);
  599.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  600.     STDMETHOD_(ULONG32, Release)    (THIS);
  602.     /*
  603.      * IHXEventHook methods
  604.      */
  605.     STDMETHOD(HandleEvent)     (IHXSite* pSite,
  606.     HXxEvent* pEvent);
  607.     STDMETHOD(SiteAdded)     (IHXSite* pSite);
  608.     STDMETHOD(SiteRemoved)     (IHXSite* pSite);
  609.     
  610.     char*     m_pChannelName;
  612. private:
  613.     CSmil1DocumentRenderer*     m_pDoc;
  614.     char*     m_pRegionName;
  615.     IHXSite*     m_pSite;
  616.     BOOL     m_bNoRegion;
  617.     CSmil1PassiveSiteWatcher*     m_pSiteWatcher;
  618.     LONG32     m_lRefCount;
  619. };
  621. class CSmil1PassiveSiteWatcher: public CHXBaseCountingObject,
  622.                                 public IHXPassiveSiteWatcher
  623. {
  624. public:
  625.     CSmil1PassiveSiteWatcher     (CSmil1DocumentRenderer* pDoc,
  626.     const char* pRegionName);
  627.     ~CSmil1PassiveSiteWatcher     ();
  629.     /*
  630.      * IUnknown methods
  631.      */
  632.     STDMETHOD(QueryInterface)     (THIS_
  633.     REFIID riid,
  634.     void** ppvObj);
  635.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  636.     STDMETHOD_(ULONG32, Release)    (THIS);
  638.     /*
  639.      * IHXPassiveSiteWatcher methods
  640.      */
  641.     STDMETHOD(PositionChanged)     (THIS_
  642.     HXxPoint* pPoint);
  643.     STDMETHOD(SizeChanged)     (THIS_
  644.     HXxSize* pSize);
  646. private:
  647.     LONG32     m_lRefCount;
  648.     CSmil1DocumentRenderer*     m_pDoc;
  649.     char*     m_pRegionName;
  650. };
  652. class CSmil1SiteUser: public CHXBaseCountingObject,
  653.                       public IHXSiteUser
  654. {
  655. public:
  656.     CSmil1SiteUser     (CSmil1DocumentRenderer* pDoc,
  657.     HXxColor ulBGColor);
  658.     ~CSmil1SiteUser     ();
  660.     /*
  661.      * IUnknown methods
  662.      */
  663.     STDMETHOD(QueryInterface)     (THIS_
  664.     REFIID riid,
  665.     void** ppvObj);
  666.     STDMETHOD_(ULONG32, AddRef)     (THIS);
  667.     STDMETHOD_(ULONG32, Release)    (THIS);
  669.     /*
  670.      * IHXSiteUser methods
  671.      */
  672.     STDMETHOD(AttachSite)     (THIS_
  673.     IHXSite* pSite);
  674.     STDMETHOD(DetachSite)     (THIS);
  675.     STDMETHOD(HandleEvent)     (THIS_
  676.     HXxEvent* pEvent);
  677.     STDMETHOD_(BOOL,NeedsWindowedSites) (THIS);
  679. private:
  680.     LONG32     m_lRefCount;
  681.     HXxColor     m_ulBGColor;
  682.     CSmil1DocumentRenderer*     m_pDoc;
  683.     IHXSite*     m_pSite;
  684. };
  686. /*
  687.  * CSmil1BasicRegion methods
  688.  */
  690. class CSmil1BasicRegion : public CHXBaseCountingObject
  691. {
  692. public:
  693.     CSmil1BasicRegion     (const char* pName, 
  694.     HXxRect rect, 
  695.     INT32 lZindex, 
  696.     const char* pFit, 
  697.     HXxColor ulBgColor,
  698.     BOOL bBgColorSet, 
  699.     BOOL bImplicitRegion,
  700.     BOOL bWidthUnspecified,
  701.     BOOL bHeightUnspecified);
  702.     ~CSmil1BasicRegion();
  704.     HXxRect m_rect;
  705.     HXxRect m_originalRect;
  706.     HXxSize m_mediaSize;
  707.     HXxSize m_originalMediaSize;
  708.     BOOL    m_bMediaSizeSet;
  709.     IHXSite* m_pSite;
  710.     IHXSiteUser* m_pSiteUser;
  711.     INT32 m_lZIndex;
  712.     CHXString m_region;
  713.     CHXString m_fit;
  714.     HXxColor m_ulBgColor;
  715.     BOOL m_bBgColorSet;
  716.     BOOL m_bImplicitRegion;
  717.     BOOL m_bWidthUnspecified;
  718.     BOOL m_bHeightUnspecified;
  719. };
  721. class ProcessElementCallback : public IHXCallback
  722. {
  723. public:
  724.     CHXString m_elementID;
  725.     CSmil1DocumentRenderer* m_pOwner;
  726.     CallbackHandle m_PendingHandle;
  727.     BOOL m_bIsCallbackPending;
  729. ProcessElementCallback();
  730.     /*
  731.      * IUnknown methods
  732.      */
  733.     STDMETHOD(QueryInterface) (THIS_
  734. REFIID riid,
  735. void** ppvObj);
  736.     STDMETHOD_(ULONG32,AddRef) (THIS);
  737.     STDMETHOD_(ULONG32,Release) (THIS);
  739.     /*
  740.      * IHXCallback methods
  741.      */
  742.     STDMETHOD(Func) (THIS);
  744. protected:
  745. ~ProcessElementCallback();
  746.     LONG32 m_lRefCount;
  747. };
  749. #endif /* _SM1DOC_H_ */