smldoc.h

linux下的一款播放器

    // IHXTrackSink methods
    STDMETHOD(BeginDone)             (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex);
    STDMETHOD(SeekDone)              (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex,
                                            UINT32 ulSeekTime);
    STDMETHOD(PauseDone)             (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex);
    STDMETHOD(StopDone)              (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex);
    STDMETHOD(OnSoundLevelAnimation) (THIS_ UINT16 uGroupIndex, UINT16 uTrackIndex,
                                            UINT32 ulSoundLevelAnimationTime);

#if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
    // IHXViewPortSink methods
    STDMETHOD(ViewPortOpened)    (THIS_ const char* pszViewPort);
    STDMETHOD(ViewPortClosed)    (THIS_ const char* pszViewPort);
    STDMETHOD(ViewPortShown)     (THIS_ const char* pszViewPort);
    STDMETHOD(ViewPortHidden)    (THIS_ const char* pszViewPort);
    STDMETHOD(ViewPortFocusSet)  (THIS_ const char* pszViewPort);
    STDMETHOD(ViewPortZOrderSet) (THIS_ const char* pszViewPort, UINT32 ulZOrder);

#ifdef XXXMEH_DO_VIEWPORT_TLC
    // IHXViewPortSupplier methods
    STDMETHOD(OnViewPortOpen)   (THIS_ IHXValues* pValues, IHXSiteUser* pSiteUser);
    STDMETHOD(OnViewPortClose)  (THIS_ const char* pszViewPort);
    STDMETHOD(OnViewPortShow)   (THIS_ const char* pszViewPort);
    STDMETHOD(OnViewPortHide)   (THIS_ const char* pszViewPort);
    STDMETHOD(OnViewPortFocus)  (THIS_ const char* pszViewPort);
    STDMETHOD(OnViewPortZOrder) (THIS_ const char* pszViewPort, UINT32 ulZOrder);
#endif

#endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */

#if defined(BE_SITE_SUPPLIER_20010205)
    // IHXSiteSupplier methods
    STDMETHOD(SitesNeeded)       (THIS_ UINT32 uRequestID, IHXValues* pSiteProps);
    STDMETHOD(SitesNotNeeded)    (THIS_ UINT32 uRequestID);
    STDMETHOD(BeginChangeLayout) (THIS);
    STDMETHOD(DoneChangeLayout)  (THIS);
#endif

    // IHXMediaMarkerSink methods
    STDMETHOD(MarkerResolved) (THIS_ IHXBuffer* pURLStr,
                                     IHXBuffer* pMarkerNameStr,
                                     UINT32      ulTime,
                                     IHXValues* pOtherMarkerParams);

    // IHXEventSink methods
    STDMETHOD(EventFired) (THIS_ IHXBuffer* pURLStr,
                                 IHXBuffer* pFragmentStr,
                                 IHXBuffer* pEventNameStr,
                                 IHXValues* pOtherValues);

    // IHXErrorSink methods
    STDMETHOD(ErrorOccurred) (THIS_ const UINT8   unSeverity,
                                    const ULONG32 ulHXCode,
                                    const ULONG32 ulUserCode,
                                    const char*   pUserString,
                                    const char*   pMoreInfoURL);

    // CSmilElementHandler methods - these are
    // the methods that the CSmilParser and CSmilElements
    // will call us back on
    HX_RESULT handleAddGroup(CSmilAddGroup* pAddGroup);
    HX_RESULT handleRegion(CSmilRegion* pRegion);
    HX_RESULT handleRegPoint(CSmilRegPoint* pRegPt);
#if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
    HX_RESULT handleViewport(CSmilViewport* pView);
#endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
    HX_RESULT handleRootLayout(CSmilRootLayout* pRootLayout);
    HX_RESULT handleSource(CSmilSource* pSource);
    HX_RESULT handleMeta(CSmilMeta* pMeta);
    HX_RESULT handleMetadata(CSmilMetadata* pMetadata);
    HX_RESULT handleEndLayout(CSmilEndLayout* pSource);
    HX_RESULT handleRendererPreFetch(CSmilRendererPreFetch* pRend);
    HX_RESULT handleSourceUpdate(CSmilSourceUpdate* pUpdate);
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
    HX_RESULT handleTransition(CSmilTransition* pTrans);
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
    HX_RESULT handleTrackRemoval(const char* pID, INT32 nGroupNum);
    HX_RESULT handleTrackPausing(SMILNode*                     pNode,
                                 LONG32                        lTimeOfPause,
                                 SMILPriorityClassPauseDisplay pauseDisplay,
                                 const char*                   pIdOfPauser);
    HX_RESULT handleTrackResuming(const char* pID, INT32 nGroupNum);
#if defined(HELIX_FEATURE_SMIL2_ANIMATION)
    HX_RESULT handleAnimate(CSmilAnimateElement* pAnimate);
#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
    HX_RESULT handleRemoveTimeUpdate(CSmilElement* pElement, UINT32 ulRemoveTime);
    HX_RESULT handleExternalMediaMarkerFile(CSmilElement* pElement,
                                            const char*   pszID,
                                            const char*   pszExternalFileName,
                                            const char*   pszRelativeSource);
    HX_RESULT resolveGroupDurToOuterTimeContainerDur(UINT32 ulGroupIndex,
                                                     UINT32 ulGroupTimeContainerDuration);
    HX_RESULT GetCurGroupDuration(REF(UINT32) ulCurGrpDur);

    // CSmilEventHookResponse methods
    STDMETHOD(HandleMouseMove)        (THIS_ void*       pWindow,
                                             const char* pRegionID,
                                             const char* pMediaID,
                                             UINT16      uXPos,
                                             UINT16      uYPos,
                                             UINT32      kRMAEvent,
                                             REF(BOOL)   bHandleSetCursor);
    STDMETHOD(HandleLButtonUp)        (THIS_ const char* pRegionID,
                                             const char* pMediaID,
                                             UINT16      uXPos,
                                             UINT16      uYPos,
                                             REF(BOOL)   rbHandled);
    STDMETHOD(HandleGotFocus)         (THIS_ const char* pRegionID,
                                             const char* pMediaID);
    STDMETHOD(HandleLostFocus)        (THIS_ const char* pRegionID,
                                             const char* pMediaID);
    STDMETHOD(HandleCharEvent)        (THIS_ UINT16 uChar);
    STDMETHOD_(BOOL, HandleSetCursor) (THIS);
    STDMETHOD(AddShowEvents)          (THIS_ const char* pRegionName, IHXSite* pSite);

    // CSmilSiteUserResponse methods
    STDMETHOD(SiteUserAttachSite)  (THIS_ CSmilSiteUser* pUser, IHXSite* pSite);
    STDMETHOD(SiteUserDetachSite)  (THIS_ CSmilSiteUser* pUser);
    STDMETHOD(SiteUserHandleEvent) (THIS_ CSmilSiteUser* pUser, HXxEvent* pEvent);

    // CSmilPassiveSiteWatcherResponse methods
    STDMETHOD(SitePositionChanged) (THIS_ IHXSite* pSite, HXxPoint* pPoint);
    STDMETHOD(SiteSizeChanged)     (THIS_ IHXSite* pSite, HXxSize*  pSize);

    // CSmilDocumentRenderer public methods
    HX_RESULT            close(CSmilRenderer* pParent);
    HX_RESULT            setDocument(const char* pFragment);
    HX_RESULT            setupDummySource();
    HX_RESULT            onPacket(IHXBuffer* pBuffer, BOOL bIsFinal);
    HX_RESULT            handleNamedEvent(const char* pRegionID,
                                          const char* pMediaID,
                                          const char* pEventName);
    HX_RESULT            detachSite(IHXSite* pSite);
    double               getResizeXScale() { return m_dResizeXScale; }
    double               getResizeYScale() { return m_dResizeYScale; }
    HX_RESULT            onHeader(IHXValues* pHeader);
    HX_RESULT            onTimeSync(UINT32 ulTimeValue);
    HX_RESULT            onPreSeek(UINT32 ulOldTime, UINT32 ulNewTime);
    HX_RESULT            endStream();
    CSmilBasicRegion*    setupDefaultLayout();
    CSmilBasicRegion*    getRegionByID(const char* pID);
    UINT32               getNumRegionsByName(const char* pszName);
    CSmilBasicRegion*    getFirstRegionByName(const char* pszName);
    CSmilBasicRegion*    getNextRegionByName(const char* pszName);
    BOOL                 isAncestorRegion(CSmilBasicRegion* pPossibleParent,
                                          CSmilBasicRegion* pPossibleChild);
    HX_RESULT            getCommonAncestorRegion(CSmilBasicRegion*      pRegA,
                                                 CSmilBasicRegion*      pRegB,
                                                 REF(CSmilBasicRegion*) rpCommon);
    CSmilRegPoint*       getRegPoint(const char* pszID);
    CSmilSource*         getSource(const char* pszID);
    HX_RESULT            handleHyperlinkTraversal(CSmilAAnchorElement* pAnc,
                                                  BOOL bCalledFromCallback = FALSE);
#if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
    CSmilBasicViewport*  getViewport(const char* pszID);
    CSmilBasicViewport*  getViewportBySiteUser(CSmilSiteUser* pSiteUser);
    CSmilBasicViewport*  getViewportBySite(IHXSite* pSite);
    CSmilBasicViewport*  getViewportByDescendant(CSmilBasicRegion* pRegion);
#endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
    CSmilBasicBox*       getTopLevelBox(CSmilBasicRegion* pRegion);
    void                 resizeRegion(const char* pRegionName, HXxSize* pNewSize);
    void                 repositionRegion(const char* pRegionName, HXxPoint* pNewPosition);
    void                 setTopLevelSiteSize();
    HX_RESULT            getErrorInfo(REF(UINT32) ulErrorLine,
                                      REF(UINT32) ulErrorColumn,
                                      REF(IHXBuffer*) pErrorText);
    HX_RESULT            getErrorInterface(REF(IHXErrorMessages*) rpErrMsgs);
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
    CSmilTransitionInfo* getTransition(const char* pID);
    HX_RESULT            makeTransitionValues(CSmilTransitionInfo* pInfo,
                                              BOOL                 bTransIn,
                                              REF(IHXValues*)     rpValues);
    HX_RESULT            startTransition(UINT32               ulStartTime,
                                         CSmilTransitionInfo* pTransInfo,
                                         SMILSiteInfo*        pInfo,
                                         SMILPlayToAssoc*     pAssoc,
                                         IHXSite*            pSite,
                                         UINT32               ulActualTime,
                                         BOOL                 bBeginTransition);
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
#if defined(HELIX_FEATURE_SMIL2_ANIMATION)
    HX_RESULT            addAnimation(CAnimationSandwichLayer* pLayer);
    HX_RESULT            removeAnimation(CSmilAnimateElement* pAnimate);
    void                 removeAnimation(CSmilAnimateInfo* pInfo);
#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
    const char*          getDefaultNamespace();
    void                 setMediaNativeSize(const char* pszID, HXxSize cSize);
    HX_RESULT            processMediaRegionOverrides(const char* pszRegionID,
                                                     const char* pszMediaID,
                                                     BOOL        bMediaStart,
                                                     UINT32      ulTime);
    BOOL                 isTransparent(UINT32 ulColor) const;
    void                 resolveZOrder(CSmilBasicBox* pBox, UINT32 ulTime);
    HX_RESULT            getMostRecentInfo(IHXSite* pSite, UINT32 ulTime,
                                           REF(UINT32) rulStartTime,
                                           REF(UINT32) rulLexicalOrder);
    BOOL                 hasParamChildren(CSmilElement* pElement,
                                          BOOL          bServerOnly);
    void                 addParamProperties(CSmilElement* pElement,
                                            IHXValues*   pValues,
                                            IUnknown*     pContext,
                                            BOOL          bServerOnly);
    void                 checkAnimChildren(CSmilElement* pElement, UINT32 ulTrackEnd);
    void                 showAllSites(CSmilBasicBox* pBox, BOOL bShow);

    HX_RESULT            GetElementProperties(UINT16            uGroupID, 
                                              UINT16            uTrackID, 
                                              REF(IHXValues*)  pProperties);

    HX_RESULT            GetElementStatus(UINT16            uGroupID,
                                          UINT16            uTrackID,
                                          UINT32            ulCurrentTime,
                                          REF(IHXValues*)  pStatus);

    HX_RESULT		 AttachElementLayout(UINT16	    uGroupID,
					     UINT16	    uTrackID,
					     IHXRenderer*  pRenderer,