basesite.h

linux下的一款播放器

    STDMETHOD(DestroyChild) (THIS_ IHXSite*       /*IN*/  pChildSite);
    STDMETHOD(AttachWatcher) (THIS_ IHXSiteWatcher* /*IN*/ pWatcher);
    STDMETHOD(DetachWatcher) (THIS);
    STDMETHOD(SetPosition) (THIS_ HXxPoint position);
    STDMETHOD(GetPosition) (THIS_ REF(HXxPoint) position);
    STDMETHOD(SetSize) (THIS_ HXxSize size);
    STDMETHOD(GetSize) (THIS_ REF(HXxSize) size);
    STDMETHOD(DamageRect) (THIS_ HXxRect rect);
    STDMETHOD(DamageRegion) (THIS_ HXxRegion region);
    STDMETHOD(ForceRedraw) (THIS);

    //
    // IHXComposition methods
    //
    STDMETHOD(LockComposition) (THIS);
    STDMETHOD(UnlockComposition) (THIS);
    STDMETHOD(BltComposition) (THIS);
    STDMETHOD(SetCompositionMode) (THIS_ BOOL OnOrOff);
    STDMETHOD_(BOOL, IsCompositionLocked) (THIS);
    STDMETHOD_(BOOL, IsCompositionMode) (THIS);

    /*
     * IHXSite2 methods
     */

    STDMETHOD(UpdateSiteWindow) (THIS_ HXxWindow* /*IN*/ pWindow);
    STDMETHOD(ShowSite) (THIS_ BOOL    bShow);
    STDMETHOD_(BOOL, IsSiteVisible) (THIS);
    STDMETHOD(SetZOrder) (THIS_ INT32 lZOrder);
    STDMETHOD(GetZOrder) (THIS_ REF(INT32) lZOrder);
    STDMETHOD(MoveSiteToTop) (THIS);
    STDMETHOD(GetVideoSurface) (THIS_ REF(IHXVideoSurface*) pSurface);
    STDMETHOD_(UINT32,GetNumberOfChildSites) (THIS);
    STDMETHOD(AddPassiveSiteWatcher) (THIS_ IHXPassiveSiteWatcher* pWatcher);
    STDMETHOD(RemovePassiveSiteWatcher) (THIS_ IHXPassiveSiteWatcher* pWatcher);
    STDMETHOD(SetCursor) (THIS_ HXxCursor cursor, REF(HXxCursor) oldCursor);

    /*
     * IHXSiteTreeNavigation methods
     */

    STDMETHOD(GetParentSite) (THIS_ REF(IHXSite*) pParentSite);

    STDMETHOD(GetNthChildSite) (THIS_ ULONG32 ulIndex, REF(IHXSite*) pSite);

    /*
     *  IHXCallback methods
     */
    STDMETHOD(Func) (THIS);

    /*
     * IHXStatusMessage methods
     */
    
    STDMETHOD(SetStatus) (THIS_ const char* pText);

    /*
     * IHXSiteFullScreen methods
     */
    STDMETHOD(EnterFullScreen) (THIS);
    STDMETHOD(ExitFullScreen) (THIS);
    STDMETHOD(TestFullScreen) (THIS_ void* hTestBitmap,const char* pszStatusText);
    STDMETHOD_(BOOL, IsFullScreen) (THIS);
    
    /*
     * IHXVideoControls methods
     */

    STDMETHOD_(float, GetBrightness) (THIS);
    STDMETHOD(SetBrightness) (THIS_ float Brightness);
    STDMETHOD_(float, GetContrast) (THIS);
    STDMETHOD(SetContrast) (THIS_ float Contrast);
    STDMETHOD_(float, GetSaturation) (THIS);
    STDMETHOD(SetSaturation) (THIS_ float Saturation);
    STDMETHOD_(float, GetHue) (THIS);
    STDMETHOD(SetHue) (THIS_ float Hue);
    STDMETHOD_(float, GetSharpness) (THIS);
    STDMETHOD(SetSharpness) (THIS_ float Sharpness);
    STDMETHOD(SetModeSharpness) (THIS_ UINT16 dFlag);

    /************************************************************************
     *  Method:
     *      IHXInterruptSafe::IsInterruptSafe
     *  Purpose:
     *      This is the function that will be called to determine if
     *      interrupt time execution is supported.
     */
    STDMETHOD_(BOOL,IsInterruptSafe) (THIS);

    /*
     * IHXSiteTransition methods
     */

    STDMETHOD(Initialize) (THIS_ IHXValues* pParams) ;
    STDMETHOD(SetPercentage) (THIS_ UINT32 nThousandnthsComplete) ;

    /*
     * IHXKeyBoardFocus methods
     */

    STDMETHOD(SetKeyboardFocus)(THIS_ IHXSiteUser* pSiteUser );
    STDMETHOD(GetKeyboardFocus)(THIS_ IHXSiteUser* &pSiteUser );

    /*
     * IHXDrawFocus methods
     */

    STDMETHOD(SetStyle)(THIS_ IHXValues* pProperties);
    STDMETHOD(ClearFocus)(THIS);
    STDMETHOD(SetFocusPolygon)(THIS_  HXxPoint* pPoints, ULONG32 numPoints);
    STDMETHOD(SetFocusRect) (THIS_ HXxRect* pRect);
    STDMETHOD(SetFocusEllipse) (THIS_ HXxRect* pRect);

    /*
     * IHXSubRectSite methods
     */
    STDMETHOD(SendSubRectMessages) (THIS_ BOOL bRet );
    STDMETHOD(SubRectDamageRegion) (THIS_ HXxBoxRegion* pRegion );
    STDMETHOD(GetSubRectVideoSurface)(THIS_ REF(IHXSubRectVideoSurface*) pSurface );


    //
    // Debug methods...
    //

    void DisplaySiteData(const char *);
    void DisplayChildSiteData(const char *);
    void DisplayAllSiteData();
    void VerifyNoDups( CHXMapPtrToPtr& map, HXREGION* reg );

   
    //
    //InLine Methods
    //
    void SetOrigin(HXxPoint* pOrigin) {memcpy(&m_topleft, pOrigin, sizeof(HXxPoint));} /* Flawfinder: ignore */
    HXxPoint* GetOrigin() {return &m_topleft;}
    void SetInternalZOrder(INT32 lZOrder) {m_lZOrder = lZOrder;};
    void SetFocusSite(CHXBaseSite* pFocusSite) {m_pFocusSite = pFocusSite;}
    CHXBaseSite* GetFocusSite() {return m_pFocusSite;}
    BOOL IsMoving() {return FALSE;}//m_bMoving;}
   
    //
    // Internal Functions
    //
    CHXBaseSite(IUnknown* pContext, IUnknown* pUnkOuter = NULL, INT32 lZorder = 0);
    virtual         ~CHXBaseSite();

    CBaseRootSurface* GetRootSurface();

   
    void            SetParentSite(CHXBaseSite* pParentSite);
    void            SetTopLevelSite(CHXBaseSite* pTop);
    CHXBaseSite*    GetParentSite() {return m_pParentSite;}
    CHXBaseSite*    GetTopLevelSite();
    CHXBaseSite*    GetContainingCHXBaseSite();
    void            UpdateZOrder( CHXBaseSite* pUpdatedChildSite,
                                  INT32 lOldZOrder,
                                  INT32 lNewZOrder);
    HXxPoint        GetScreenOffset();
    void            SetXSliderRange(INT32);
    INT32           GetXSliderRange();
    void            SetYSliderRange(INT32);
    INT32           GetYSliderRange();
    INT32           GetXSliderPos();
    INT32           GetYSliderPos();
    INT32           GetSliderWidth();
    INT32           GetSliderHeight();
    void            GetWindowRect(HXxRect* pRect);
    void            GetExtentsWithoutChildren(HXxRect* pRect);
    void            RecursiveSizeSliders();
    void            SizeSliders();
    void            FuncSizeSliders();
    HX_RESULT       ConvertStringToXYDepth(const char* pszModeString,
                                           REF(INT32) x,
                                           REF(INT32) y,
                                           REF(INT32) depth);
    void            SetDisplayMode();
    BOOL            GenerateMouseLeaveMessage();
    void            CheckExposeEvents();
    BOOL            ComputeSubRects();
    void            BuildParnetClipping( HXREGION* hClip, CHXBaseSite* pChild );
    BOOL            m_bUsingList;
    void            SetClipping();
    BOOL            AreVideoControlsActive();
    BOOL            IsHigherZOrderTranstitionActive();
    void            FindLinkedSites();
   
    //Alpha blending support....
    CHXMapPtrToPtr  m_AlphaBlendSites;     //Who is under us that we blend with
    CHXMapPtrToPtr  m_AlphaBlendNotifiers; //who we notify when we change.
    BOOL            m_bSiteNeverBlts;
    BOOL            _CheckForVisibleChild();
    void            AlphaBlendComputeSubRects( CHXBaseSite* pIgnoredSite );
    void            AlphaBlendBuildParnetClipping( HXREGION* hClip,
                                                   CHXBaseSite* pChild,
                                                   CHXBaseSite* pIgnoredSite );
    void            _RemoveAllNotifiers();
    void            _RemoveAllYUVImageLists();

    void            _EmptyBlenderList();
    void            _EmptyNotifierList();
    void            _AlphaBlendAddNotifier(CHXBaseSite* it);

    void            _RemoveHigherOrderSiblings( HXREGION* hClip, CHXBaseSite* pChild );

    BOOL            _BlendedBordersActive();
    BOOL            _FadeTransitionActive();
    BOOL            _BordersActive();
    BOOL            _IsAlphaBlending();
   
    //End alpha support....

    //IHXComposition support
    BOOL            m_bCompositionLocked;
    BOOL            m_bCompositionMode;

    void            UpdateModes();
    BOOL            DoesPrefExist(INT32 resolutionX,
                                  INT32 resolutionY,
                                  INT32 colorDepth);
    void            UpdatePrefs(INT32 resolutionX,
                                INT32 resolutionY,
                                INT32 colorDepth,
                                ULONG32 ulBltTime,
                                BOOL bPassed,
                                BOOL bTested);
   
    void              ScheduleCallback( INT32 nWhichCallback,
                                        INT32 nMilliseconds,
                                        BOOL  bOverrideCompositionMode=FALSE);

    BOOL            IsPointInClippingRegion(HXxPoint* pPoint);
    void            SetEvent(REF(HXxEvent) theEvent,
                             ULONG32 event,
                             void* window,
                             void* param1,
                             void* param2);
    void            CheckDisplayMode(void* hdc);
    void            ChangeResolution();
    void            DestroySurfaces();
    void            ReInitSurfaces();
    void            RecomputeClip();
    void             FindVideoSites();

    INT32           GetTopMostSiteZOrder();
    void            SetParentWindow(HXxWindow* pWindow);
    void            SetRootSurface(CBaseRootSurface* pSurface);
    virtual void    CheckColorSettings();
    BOOL            SharpenImage( HXBitmapInfoHeader* pOptimizedFormat,
                                  UCHAR* pImageBits,
                                  REF(HXxRect) rSrcRect);
    void            SiteMoving(INT32 x, INT32 y);
    void            ResetOrigin();
    void            GetAbsoluteCords(REF(HXxPoint) point);
    void            AboutToBlt();
    void            FillColorKey();
    BOOL            SafeMoveWindow(void* hWnd,
                                   INT32 X,
                                   INT32 Y,
                                   INT32 nWidth,
                                   INT32 nHeight,
                                   BOOL bRepaint);
    BOOL            SafeUpdateWindow(void* hWnd);
    BOOL            SafeShowWindow(void* hWnd, INT32 nCmdShow);
    BOOL            SafeSetWindowPos(void* hWnd,
                                     void* hWndInsertAfter,
                                     INT32 X,
                                     INT32 Y,
                                     INT32 cx,
                                     INT32 cy,
                                     UINT uFlags);
    INT32           SafeSetWindowRgn(void* hWnd, HXREGION* hRgn, BOOL bRedraw);
    void            SafeSetXSliderRange(INT32 range);
    void            SafeSetYSliderRange(INT32 range);
    void            SafeSetFocus(HXxWindow* pWindow);
    HX_RESULT       _SafeSetSize(HXxSize size);
    HX_RESULT       _SafeSetPosition(HXxPoint position);
   
    void            ExecutePendingTasks();
    void            RemovePendingTasks(CHXBaseSite*);
    void            ResetUpdateOverlay();
    void            SiteNotMoving();

    void            _ForceRedrawAll();
    void            InternalForceRedraw();
    void            LockBlitters();
    void            UnlockBlitters();
    void            FlushSurfaces();
    
    void            DisableColorControls(float &fBrightness,
                                         float &fContrast,
                                         float &fSaturation,
                                         float &fHue);

    void            EnableColorControls(float fBrightness,
                                        float fContrast,
                                        float fSaturation,
                                        float fHue);
    /*
     *	Small HXColor support
     */
    void ColorConverterRequest(int CIDin, int CIDout, BOOL bFoundConverter);
    void InternalColorConverterRequest(int CIDin, int CIDout, BOOL bFoundConverter, CHXBaseSite* pSite);
    void ScheduleUpgrade();
    void InternalScheduleUpgrade(UINT32 CIDIn, UINT32 CIDOut, IHXSite* pSite);

    /*
     *  OS Specific Functions
     */

    /************************************************************************
     *  Method:
     *      _NeedWindowedSite
     *  Purpose:
     *      Create a windowed site
     */
    virtual void        _NeedWindowedSite() = 0;

    /************************************************************************
     *  Method:
     *      _AttachWindow
     *  Purpose:
     *      A window is assigned to the site so perform any required window
     *      initialization code.
     */
    virtual void        _AttachWindow() = 0;

    /************************************************************************
     *  Method:
     *      _DetachWindow
     *  Purpose:
     *      The window is removed from the site so perform any required window
     *      clean-up code.
     */
    virtual void        _DetachWindow() = 0;

    /************************************************************************
     *  Method:
     *      _Create
     *  Purpose:
     *      Create a window of type style with ParentWindow as its parent
     */
    virtual void*       _Create(void* ParentWindow, UINT32 style) = 0;

    /************************************************************************
     *  Method:
     *      _Destroy
     *  Purpose:
     *      Destroy this window
     */
    virtual void        _Destroy(HXxWindow* pWindow) = 0;

    /************************************************************************
     *  Method:
     *      _SetSize
     *  Purpose:
     *      Set the size of the window to size
     */
    virtual void        _SetSize(HXxSize size) = 0;

    /************************************************************************
     *  Method:
     *      _SetPosition
     *  Purpose:
     *      Set the position of the window to position
     */
    virtual void        _SetPosition(HXxPoint position) = 0;

    /************************************************************************
     *  Method:
     *      _DamageRect
     *  Purpose:
     *      Mark this area of the window for redrawing
     */
    virtual void        _DamageRect(HXxRect rect) = 0;

    /************************************************************************
     *  Method:
     *      _DamageRegion
     *  Purpose:
     *      Mark this area of the window for redrawing
     */
    virtual void        _DamageRegion(HXxRegion rect) = 0;

    /************************************************************************
     *  Method:
     *      _ShouldEnterForceRedraw
     *  Purpose:
     *      Serialize our drawing routines
     */
    virtual BOOL        _ShouldEnterForceRedraw() = 0;

    /************************************************************************
     *  Method: