smldoc.h

linux下的一款播放器

					     IHXStream*    pStream,
					     IHXValues*    pProps);
    HX_RESULT		 DetachElementLayout(IUnknown*	    pLSG);

    BOOL                 isRegionActive(const char* pszRegID, UINT16 usGroup, UINT32 ulTime);
    void                 handlePendingScheduling(void);

    HX_RESULT            AdjustSoundLevelsOfAllCurrentTracks(UINT16 uCurGroupIndex,
                                        UINT32 ulSoundLevelAdjustment_pct,
                                        CSmilSource* pSmilSourceDontAdjustMe);


    // CSmilDocumentRenderer static public methods
    static void          computeRegPoint(HXxRect       cRegionRect,
                                         RegPoint      cRegPointInfo,
                                         REF(HXxPoint) rcRegPoint);
    static HX_RESULT     computeMediaLayout(HXxRect      cRegionRect,
                                            Fit          eFit,
                                            HXxPoint     cRegPoint,
                                            RegAlign     eRegAlign,
                                            HXxSize      cMediaSize,
                                            REF(HXxRect) rcMediaRect,
                                            BOOL         bMediaIsBrush);
    static void          computeHalfBounds(INT32 lMid, INT32 lSpan,
                                           REF(INT32) rlMin, REF(INT32) rlMax);
    static void          computeFillHiddenScaling(Fit eFit, INT32 lRegPt, INT32 lMediaDim,
                                                  INT32 lRegionLo, INT32 lRegionHi,
                                                  REF(INT32) rlMediaLo,
                                                  REF(INT32) rlMediaHi);
    static void          computeMeetSliceScaling(BOOL   bIsMeet, UINT32 ulNumDim,
                                                 INT32 lA1, INT32 lA2, INT32 lA3,
                                                 INT32 lB1, INT32 lB2, INT32 lB3,
                                                 INT32 lC1, INT32 lC2, INT32 lC3,
                                                 INT32 lD1, INT32 lD2, INT32 lD3,
                                                 REF(INT32) rlA, REF(INT32) rlB,
                                                 REF(INT32) rlC, REF(INT32) rlD);
    static void          showSite(IHXSite* pSite, BOOL bShow);
    static BOOL          isSiteVisible(IHXSite* pSite);
    static void          setSiteZIndex(IHXSite* pSite, INT32 lZIndex);
    static INT32         getSiteZIndex(IHXSite* pSite);
    static UINT32        getNumberOfChildSites(IHXSite* pSite);
    static void          addStringProperty(IHXValues* pValues,
                                           IUnknown*   pContext,
                                           const char* pszName,
                                           const char* pszValue);


    // CSmilDocumentRenderer public members
    CHXString        m_metadata;
    CHXStack*        m_pPlayerResumeStack;
#if defined(BE_SITE_SUPPLIER_20010205)
    CHXString        m_XXXEH_HACK_regionId;
    IHXPlayer*      m_pIndependentPlayer;
    CHXMapLongToObj* m_pChildSiteInfoMap;
#endif

    friend class CSmilRenderer;
private:
    // CSmilDocumentRenderer private methods
    HX_RESULT            addSiteForRenderer(SMILPlayToAssoc* pPlayToAssoc,
                                            SMILSourceInfo*  pSMILSourceInfo,
                                            IHXRenderer*    pRenderer,
                                            BOOL             bNoRegion);
    HX_RESULT            addSiteForRendererByRegion(SMILPlayToAssoc*  pPlayToAssoc,
                                                    SMILSourceInfo*   pSMILSourceInfo,
                                                    IHXRenderer*     pRenderer,
                                                    BOOL              bNoRegion,
                                                    CSmilBasicRegion* pRegion);
    HX_RESULT            setSiteProperty(IHXSite*   pSite,
                                         const char* pszKey,
                                         const char* pszValue);
    HX_RESULT            setSitePropertyULONG32(IHXSite*   pSite,
                                                const char* pszKey,
                                                UINT32      ulValue);
    HX_RESULT            getSiteProperty(IHXSite*        pSite,
                                         const char*      pszKey,
                                         REF(IHXBuffer*) rpValueStr);
    void                 setPlayToAssoc(UINT16      uGroupIndex, 
                                        UINT16      uTrackIndex, 
                                        const char* pID,
                                        const char* pRepeatID,
                                        const char* pPlayTo,
                                        const char* pRegionName,
                                        const char* pBeginTransition,
                                        const char* pEndTransition,
                                        UINT32      regionZOrder,
                                        BOOL        bXMMSource = FALSE);
    HX_RESULT            doTransition(LISTPOSITION pos, UINT32 ulTime);
    HX_RESULT            moveHideEventForSiteBack(SMILSiteInfo* pInfo,
                                                  UINT32        ulEndTime,
                                                  UINT32        len, 
                                                  BOOL          bJustRenderer);
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
    HX_RESULT            checkSitesHideTime(SMILSiteInfo*        pOtherSiteInfo,
                                            SMILSiteInfo*        pSiteInfo,
                                            CSmilTransitionInfo* pTransInfo,
                                            REF(IHXSite*)       pSiteToTransition,
                                            BOOL                 bBeginTransition);
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
    HX_RESULT            ignoreLastHideEvent(UINT32 ulGroupIndex, SMILGroupInfo* pGroupInfo);
    BOOL                 SitesOverlap(IHXSite* pCanidate, IHXSite* pSite);
    SMILPlayToAssoc*     getPlayToAssoc(UINT16 uGroupIndex, UINT16 uTrackIndex);
    SMILPlayToAssoc*     getPlayToAssoc(const char* pName);
    SMILPlayToAssoc*     getPlayToAssocByMedia(const char* pszMediaID);
    void                 removeAllPlayToAssoc();
    void                 removeGroupsPlayToAssoc(UINT16 uGroupIndex);
    void                 removeTracksPlayToAssoc(UINT16 uGroupIndex, UINT16 uTrackIndex);
    void                 removeActiveTransitions();
    void                 removeViewports();
    void                 resetRendererSites(CSmilBasicRegion* pRegion);
    CSmilSiteWatcher*    getRendererSiteWatcher(const char* pszMediaID);
    void                 addRendererSiteWatcherToMap(const char* pszMediaID,
                                                     CSmilSiteWatcher* pWatch);
    void                 removeRendererSiteWatcherFromMap(const char* pszMediaID);
    void                 clearRendererSiteWatcherMap();
    HX_RESULT            getRendererSite(const char* pszMediaID, REF(IHXSite*) rpSite);
    void                 addRendererSiteToMap(const char* pszMediaID, IHXSite* pSite);
    void                 removeRendererSiteFromMap(const char* pszMediaID);
    void                 clearRendererSiteMap();
    HX_RESULT            getRenderer(const char* pszMediaID, REF(IHXRenderer*) rpRenderer);
    void                 addRendererToMap(const char* pszMediaID, IHXRenderer* pRenderer);
    void                 removeRendererFromMap(const char* pszMediaID);
    void                 clearRendererMap();
    HX_RESULT            actualRendererClosed(IHXRenderer* pRenderer,
                                              IHXValues*   pInfo);
    HX_RESULT            closeOldRenderers(BOOL bAll);
    HX_RESULT            addOldRendererHideEvents(UINT16 uGroupIndex);
    void                 removeSourcemap(SMILPlayToAssoc* pPlayToAssoc);
    HX_RESULT            insertEvent(CSmilLayoutEvent* pEvent);
    CSmilShowSiteEvent*  getShowHideEvent(const char* pszMediaID,
                                          const char* pszRegionID,
                                          BOOL        bShowEvent);
#if defined(HELIX_FEATURE_SMIL2_ANIMATION)
    void                 doAnimation(CSmilAnimateInfo* pInfo, UINT32 ulTime);
    HX_RESULT            getUnderlyingValue(CSmilAnimateInfo* pInfo, REF(CAttr*) rpValue);
    HX_RESULT            getDependentValue(CSmilAnimateInfo* pInfo, REF(CAttr*) rpDepend);
    HX_RESULT            setValue(CSmilAnimateInfo* pInfo, CAttr* pValue,
                                  CAttr* pDepend, BOOL bUnderlyingValue = FALSE);
    void                 removeActiveAnimations();
    CSmilAnimateEvent*   getAnimateEvent(CSmilAnimateElement* pAnim);
#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
    void                 removeEvent(CSmilLayoutEvent* pEvent);
    HX_RESULT            insertSiteInfo(void* pInfo);
    void                 removeSiteInfo(SMILSiteInfo* pSiteInfo);
    void                 removeGroupEvents(UINT16 uGroupIndex);
    BOOL                 draw(HXxEvent* pEvent, IHXSite* pSite, UINT32 ulBgColor);
    HX_RESULT            insertIntoZOrderList(CHXSimpleList* pList,
                                              SMILSiteInfo*  pSiteInfo);
    HX_RESULT            setRendererZOrder(SMILSiteInfo* pSiteInfo);
    HX_RESULT            handleElements();
    HX_RESULT            postParseSetup();
    void                 setProperty(IHXValues* pValues, 
                                     const char* pName, 
                                     const char* pValue);
    HX_RESULT            parseDimension(const char* pDimensionString,
                                        REF(UINT32) ulValue,
                                        REF(BOOL)   bIsPercent);
    HX_RESULT            computeBoxDimension(CSmilBasicBox* pBox, BoxDimension eDim);
    void                 clearResolvedFlags(CSmilBasicBox* pBox);
    void                 resetSites(CSmilBasicBox* pBox, BOOL bOptimizeRedraws);
    void                 resizeTopLevelBox(CSmilBasicBox* pBox, HXxSize cOrigSize, HXxSize cSize);
    void                 zoomRect(CSmilBasicBox* pBox, double dScaleX, double dScaleY);
    void                 recomputeBoxLayout(CSmilBasicBox* pBox, BOOL bOptimizeRedraws);
    BOOL                 isMediaPausedAndDisabled(const char* pID);
    BOOL                 reenablePausedAndDisabledMedia(const char* pID,
                                UINT16 iGroupIndex);

    CSmilAAnchorElement* findHyperlinkElement(const char* pRegionID,
                                              const char* pMediaID,
                                              UINT16      uXPos,
                                              UINT16      uYPos,
                                              BOOL        bResolveTargetBeginIfFragment = FALSE);
    CSmilElement*        findIfCurElementHasAltOrLongdesc(const char* pID,
                                            UINT16 ulXPos, UINT16 ulYPos);
    HX_RESULT            convertURL(const char* pszBaseRoot, const char* pszBasePrefix,
                                    const char* pURL, CHXString& newURL);
    HX_RESULT            doSourceUpdate(SMILPlayToAssoc*   pPlayToAssoc,
                                        CSmilSourceUpdate* pUpdateElement);
    HX_RESULT            updateStreamTiming(const char* pElementID,
                                            UINT32      ulDuration);
    HX_RESULT            updateStreamDelay(UINT16 uGroupIndex, UINT32 ulDelay);
    HX_RESULT            updateSiteEvents(UINT16 uGroupIndex);
    HX_RESULT            seekTo(const char* pElementID);
    HX_RESULT            setRegionParentChild(CSmilBasicRegion* pRegion);
    HX_RESULT            createRegionSites(CHXSimpleList* pChildList);
    HX_RESULT            createRegionSite(CSmilBasicRegion* pRegion);
    void                 destroyRegionSites(CHXSimpleList* pChildList);
    CSmilBasicRegion*    getRegionByName(const char* pszName);
    void                 RemoveEvents(UINT32 ulGroupIndex, IHXSite* pSite);
    HX_RESULT            flushAllEvents(UINT32 ulFlushToTime, BOOL bBreak = FALSE);
    HX_RESULT            flushAllEvents () { return flushAllEvents(m_ulCurrentTime); }
    BOOL                 IsFullScreen();
    BOOL                 isAttributeAnimated(const char* pszElementID, UINT32 ulAttrName);
    BOOL                 isRegionBackgroundColorOverridden(CSmilBasicRegion* pRegion);
#if defined(HELIX_FEATURE_SMIL2_ANIMATION)
    void                 startSoundLevelAnimation(CSmilAnimateInfo* pInfo);
    void                 finishSoundLevelAnimation(CSmilAnimateInfo* pInfo,
                                                   BOOL bUseCurrentLevel = FALSE);
    CSmilAnimateElement* getFirstAnimationElement(const char* pszElementID, UINT32 ulAttrName);
    CSmilAnimateElement* getNextAnimationElement(const char* pszElementID, UINT32 ulAttrName);
#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
    BOOL                 getGroupDuration(UINT16 usGroupIndex, REF(UINT32) rulDuration);
    HX_RESULT            getTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, REF(IHXTrack*) rpTrack);
    void                 forceFullRedraw(IHXSite* pSite);
    void                 forceFullRecursiveRedraw(CSmilBasicBox* pBox);
    void                 destroyRendererSites(CSmilBasicBox* pBox);
    HX_RESULT            setupRootLayout(BOOL bAssignDefaults);
#if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
    HX_RESULT            setupViewports();
    HX_RESULT            finishOneViewportSetup(CSmilBasicViewport* pPort);
    HX_RESULT            setupViewportsDone(HX_RESULT status);
    void                 closeViewports();
    void                 showHideViewport(const char* pszID, BOOL bShow);
    void                 showHideViewport(CSmilBasicViewport* pPort, BOOL bShow);
#ifdef XXXMEH_DO_VIEWPORT_TLC
    void                 clearViewportMap();
#endif