basesite.cpp

linux下的一款播放器

    HXDestroyRegion(m_pDirtyRegion);
    m_pDirtyRegion = NULL;
}


/************************************************************************
 *  Method:
 *    CHXBaseSite::SetParentSite
 */
void
CHXBaseSite::SetParentSite(CHXBaseSite* pParentSite)
{
    m_pParentSite = pParentSite;
}

/************************************************************************
 *  Method:
 *    CHXBaseSite::SetTopLevelSite
 */
void
CHXBaseSite::SetTopLevelSite(CHXBaseSite* pTop)
{
    if (m_pTopLevelSite != this)
    {
        HX_RELEASE(m_pTopLevelSite);
    }

    m_pTopLevelSite = pTop;

    if (m_pTopLevelSite && m_pTopLevelSite != this)
        m_pTopLevelSite->AddRef();
}

/************************************************************************
 *  Method:
 *    IUnknown::QueryInterface
 */
STDMETHODIMP CHXBaseSite::QueryInterface(REFIID riid, void** ppvObj)
{
    return m_pUnkOuter->QueryInterface(riid,ppvObj);
}

/************************************************************************
 *  Method:
 *    IUnknown::AddRef
 */
STDMETHODIMP_(ULONG32) CHXBaseSite::AddRef()
{
    return m_pUnkOuter->AddRef();
}

/************************************************************************
 *  Method:
 *    IUnknown::Release
 */
STDMETHODIMP_(ULONG32) CHXBaseSite::Release()
{
    return m_pUnkOuter->Release();
}

/************************************************************************
 *  Method:
 *    IUnknown::QueryInterface
 */
STDMETHODIMP CHXBaseSite::SiteNonDelegatingQueryInterface(REFIID riid, void** ppvObj)
{
    if (IsEqualIID(riid, IID_IUnknown))
    {
        AddRef();
        *ppvObj = (IUnknown*)(IHXSite*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSite))
    {
        AddRef();
        *ppvObj = (IHXSite*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSite2))
    {
        AddRef();
        *ppvObj = (IHXSite2*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSiteTreeNavigation))
    {
        AddRef();
        *ppvObj = (IHXSiteTreeNavigation*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXInterruptSafe))
    {
        AddRef();
        *ppvObj = (IHXInterruptSafe*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSiteWindowless))
    {
        AddRef();
        *ppvObj = (IHXSiteWindowless*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSiteWindowed))
    {
        AddRef();
        *ppvObj = (IHXSiteWindowed*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXStatusMessage))
    {
        AddRef();
        *ppvObj = (IHXStatusMessage*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSiteFullScreen))
    {
        AddRef();
        *ppvObj = (IHXSiteFullScreen*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXVideoControl))
    {
        AddRef();
        *ppvObj = (IHXVideoControl*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSiteTransition))
    {
        AddRef();
        *ppvObj = (IHXSiteTransition*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSiteComposition))
    {
        AddRef();
        *ppvObj = (IHXSiteComposition*)this;
        return HXR_OK;
    }
    else if (m_pValues &&
             m_pValues->QueryInterface(riid, ppvObj) == HXR_OK)
    {
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXKeyBoardFocus))
    {
        AddRef();
        *ppvObj = (IHXKeyBoardFocus*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXDrawFocus))
    {
        AddRef();
        *ppvObj = (IHXDrawFocus*)this;
        return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXSubRectSite))
    {
        AddRef();
        *ppvObj = (IHXSubRectSite*)this;
        return HXR_OK;
    }

    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

/************************************************************************
 *  Method:
 *    IUnknown::AddRef
 */
STDMETHODIMP_(ULONG32) CHXBaseSite::SiteNonDelegatingAddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}


/************************************************************************
 *  Method:
 *    IUnknown::Release
 */
STDMETHODIMP_(ULONG32) CHXBaseSite::SiteNonDelegatingRelease()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }

    delete this;
    return 0;
}

/************************************************************************
 *  Method:
 *    IHXSite::AttachUser
 */
STDMETHODIMP CHXBaseSite::AttachUser(IHXSiteUser* /*IN*/ pUser)
{
    if (m_pUser) return HXR_UNEXPECTED;

#ifndef _DEBUG_WINDOWED_SITES
    if (m_pParentSite && pUser->NeedsWindowedSites())
    {
        _NeedWindowedSite();
    }
#endif

    m_pUser = pUser;
    m_pUser->AddRef();

    //if (!m_pTopLevelSite->m_pKeyBoardFocusUser && m_pTopLevelSite->m_pUser)
    //{
    //    m_pTopLevelSite->m_pKeyBoardFocusUser = m_pTopLevelSite->m_pUser;
    //    m_pTopLevelSite->m_pKeyBoardFocusUser->AddRef();
    //}

    m_pUser->AttachSite(this);

    if (m_bAttachWindowPending)
    {
        m_bAttachWindowPending = FALSE;
        m_bDetachWndMsgPending = TRUE;
        // send HX_ATTACH_WINDOW msg to the renderers
        void *  lpParam1 = NULL;
        void *  lpParam2 = NULL;

        HXxEvent event = {HX_ATTACH_WINDOW, m_pWindow ? m_pWindow->window : NULL, lpParam1, lpParam2, 0, 0};
        m_pUser->HandleEvent(&event);
    }

    /* XXXRA
     * Mac one does scale to full screen and also forces and update message
     * should not need it!
     */

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite::DetachUser
 */
STDMETHODIMP CHXBaseSite::DetachUser()
{
    if (!m_pUser) return HXR_UNEXPECTED;

    /*
     *  SetCapture
     */

    if (m_pTopLevelSite->m_pLastUser == m_pUser)
    {
        m_pTopLevelSite->m_pLastUser = NULL;
    }

    if (m_pTopLevelSite->m_pCaptureUser == m_pUser)
    {
        m_pTopLevelSite->m_pCaptureUser= NULL;
        m_bSetCaptureOn = FALSE;
    }

    if (m_CallbackHandle)
    {
        m_pScheduler->Remove(m_CallbackHandle);
        m_CallbackHandle = 0;
    }
    if (m_ScrollSiteCallbackHandle)
    {
        m_pScheduler->Remove(m_ScrollSiteCallbackHandle);
        m_ScrollSiteCallbackHandle = 0;
    }

    if (m_pUser && m_bDetachWndMsgPending)
    {
        // send HX_DETACH_WINDOW msg to the renderers
        void *  lpParam1 = NULL;
        void *  lpParam2 = NULL;

        HXxEvent event = {HX_DETACH_WINDOW, m_pWindow ? m_pWindow->window : NULL, lpParam1, lpParam2, 0, 0};

        m_bDetachWndMsgPending = FALSE;
        m_pUser->HandleEvent(&event);
    }

    AddRef();
    if (HXR_OK == m_pUser->DetachSite())
    {
        if (m_pTopLevelSite->m_pKeyBoardFocusUser == m_pUser)
            HX_RELEASE(m_pTopLevelSite->m_pKeyBoardFocusUser);

        HX_RELEASE(m_pUser);
    }
    Release();

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite::GetUser
 */
STDMETHODIMP CHXBaseSite::GetUser(REF(IHXSiteUser*) /*OUT*/ pUser)
{
    if (!m_pUser) return HXR_UNEXPECTED;

    pUser = m_pUser;
    pUser->AddRef();

    return HXR_OK;
}


/************************************************************************
 *  Method:
 *    IHXSite::CreateChild
 */
STDMETHODIMP CHXBaseSite::CreateChild(REF(IHXSite*) /*OUT*/ pChildSite)
{
    _TLSLock();

    HRESULT result = HXR_OK;

    // Create an instance of CHXBaseSite, let it know it's in child
    // window mode.
    CHXBaseSite* pChildSiteWindowless = CHXBaseSite::CreateSite(m_pContext, NULL, m_ChildrenMap.GetCount());
    pChildSiteWindowless->AddRef();
    pChildSiteWindowless->SetParentSite(this);
    pChildSiteWindowless->SetTopLevelSite(m_pTopLevelSite);
    pChildSiteWindowless->SetRootSurface(m_pRootSurface);
    pChildSiteWindowless->SetParentWindow(&m_TopLevelWindow);

#ifdef _WIN32
    //this is to give the windows sites a chance to hook themselves
    //into wm_move madness.
    CHXWinSite* pSiteIt = (CHXWinSite*)pChildSiteWindowless;
    pSiteIt->HookParents();
#endif

    // Get the IHXSite interface from the child to return to the
    // outside world.
    pChildSiteWindowless->QueryInterface(IID_IHXSite, (void**)&pChildSite);

    // Store the CHXBaseSite in a list of child windows, always keep
    //a reference to it.  ExSiteInfo does an AddRef in constructor
    m_ChildrenMap.SetAt(pChildSite, pChildSiteWindowless);
    pChildSite->AddRef();

    //Now add the child into or ZOrder sorted list.
    m_ChildrenInZOrder.AddTail( (void*)pChildSiteWindowless );


    //Set the child's origin
    pChildSiteWindowless->SetOrigin(&m_topleft);

    if(m_pTopLevelSite)
        m_pTopLevelSite->ScheduleCallback(CLIP, 0);

    HXxWindow* pWindow = GetWindow();
    //XXXgfw this focus code is disabled for the beamer release.
    //SafeSetFocus(pWindow);

    _TLSUnlock();


    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXSite::DestroyChild
 */
STDMETHODIMP CHXBaseSite::DestroyChild(IHXSite* /*IN*/ pChildSite)
{
    // Avoid dead-lock in vidsurf2
    LockBlitters();
    FlushSurfaces();

    _TLSLock();

    //Check and see if we are in the YUV Site list. If so, remove ourselves.
    LISTPOSITION pPos = zm_YUVSiteList.Find(this);
    if(pPos)
    {
        zm_YUVSiteList.RemoveAt(pPos);
    }

    //Verify that the site is actually a child site and find its
    //position in the list in the event that it is a child.
    HX_RESULT retVal = HXR_FAIL;
    CHXBaseSite* pChildSiteWindowless=NULL;

    if (m_ChildrenMap.Lookup(pChildSite, (void*&) pChildSiteWindowless))
    {
        m_ChildrenMap.RemoveKey(pChildSite);
        pChildSiteWindowless->Destroy();
        pChildSiteWindowless->SetParentSite(NULL);
        //Remove it from our child z-order list.
        LISTPOSITION pos,posNext = m_ChildrenInZOrder.GetHeadPosition();
        while (posNext)
        {
            pos = posNext;
            CHXBaseSite* pSite = (CHXBaseSite*)m_ChildrenInZOrder.GetNext(posNext);
            if( pSite == pChildSiteWindowless )
            {
                m_ChildrenInZOrder.RemoveAt(pos);
                while (posNext)
                {
		    pSite = (CHXBaseSite*)m_ChildrenInZOrder.GetNext(posNext);

		    INT32 zOrder;
		    pSite->GetZOrder(zOrder);
		    pSite->SetInternalZOrder(zOrder - 1);
                }
                break;
            }
        }
        HX_RELEASE(pChildSite);
        HX_RELEASE(pChildSiteWindowless);
        retVal = HXR_OK;
    }
    HX_ASSERT( m_ChildrenInZOrder.GetCount() == m_ChildrenMap.GetCount() );

    if (m_pTopLevelSite==this)
    {
        m_pTopLevelSite->RecomputeClip();
    }
    else
    {
        if (m_pTopLevelSite)
        {
            m_pTopLevelSite->ScheduleCallback(CLIP, 0);
        }
    }

    _TLSUnlock();
    UnlockBlitters();

    return retVal;
}

/************************************************************************
 *  Method:
 *    IHXSite::AttachWatcher
 */
STDMETHODIMP CHXBaseSite::AttachWatcher(IHXSiteWatcher* /*IN*/ pWatcher)
{
    if (m_pWatcher) return HXR_UNEXPECTED;

    m_pWatcher = pWatcher;

    if (m_pWatcher)
    {
        m_pWatcher->AddRef();
        m_pWatcher->AttachSite(this);