winsite.cpp

linux下的一款播放器

           goto leave;
       }
#endif
       case WM_CLOSE:
       {
           if (m_bInFullScreen && m_pUser)
           {
               HXxEvent event = {WM_CHAR, GetWindow()->window, (void*)VK_ESCAPE, 0, 0, 0};
               m_pUser->HandleEvent(&event);
               lResult = TRUE;
               retValue = TRUE;
               goto leave;
           }
           retValue = FALSE;
           goto leave;
       }

       case WM_SETFOCUS:
           lResult = 1;
           break;


       case WM_KILLFOCUS :
           lResult = 1;
           break;

    }

    if (event.window)
    {
        EventOccurred(&event);
        lResult = event.handled;
        retValue = event.handled;
        goto leave;
    }

    if (message == WM_SETCURSOR)
    {
        lResult = TRUE;
        retValue = TRUE;
        goto leave;
    }

    retValue = FALSE;
    goto leave;

  leave:
    Release();
    return retValue;
}

/************************************************************************
 *  Function:
 *    HXxHookSiteProc
 *
 */
LRESULT HXEXPORT
HXxHookSiteProc
(
    HWND hWnd,
    UINT message,
    WPARAM uParam,
    LPARAM lParam
    )
{
    LRESULT             lResult = 0;
    CHXWinSite*         pThis = 0;

    CHXWinSite::zm_SubclassedWnds.Lookup((void*)hWnd,(void*&)pThis);

    if (!pThis)
    {
        HX_ASSERT(0);
        return DefWindowProc(hWnd, message, uParam, lParam);
    }

    if (pThis->HandleWndProc(hWnd,message,uParam,lParam,lResult))
    {
        return (lResult);
    }

    return CallWindowProc(pThis->m_oldWndProc, hWnd, message, uParam, lParam);
}


/************************************************************************
 *  Function:
 *    HXxHookChar
 *
 *   Uhm, why is this function here?
 */
LRESULT HXEXPORT
HXxHookChar(int nCode,WPARAM wParam,LPARAM lParam)
{
    if (nCode <0 || nCode != HC_NOREMOVE)
    {
        int isKeyDown = (KF_UP & lParam);

        if (!isKeyDown)
        {
            LRESULT             lResult = 0;
            CHXWinSite*         pThis;

            CHXMapPtrToPtr::Iterator i = CHXWinSite::zm_SubclassedWnds.Begin();

            for(;i!= CHXWinSite::zm_SubclassedWnds.End(); ++i)
            {
                pThis = (CHXWinSite*) *i;
                if (pThis->IsFullScreen())
                {
                    if (pThis->HandleWndProc((HWND)i.get_key(),WM_CHAR,wParam,lParam,lResult))
                    {
                        return (lResult);
                    }
                }
            }
        }
    }

    /*
     *  Sweet Jesus. They do not give us a window handle. Ok. Call GetCurrentThreadId.
     */

    DWORD id = GetCurrentThreadId();
    CParentWindowThreadData* pData = NULL;

    if (CHXWinSite::zm_ParentsThreadList.Lookup((void*)id, (void*&) pData))
    {
        return CallNextHookEx(pData->m_hHook,nCode,wParam,lParam);
    }

    /*
     *  If we get here we are in some SERIOUS hurt.
     */

    HX_ASSERT(NO_HOOK_FOUND_RETURNING_WITH_ZERO);
    return 0;
}





void CHXWinSite::_GetDeviceCaps(void* h, UINT16& uBitesPerPixel, UINT16& uHorzRes, UINT16& uVertRes)
{
    HDC hdc = (HDC) h;

    if (!hdc)
    {
        hdc = GetDC(0);
    }

    uBitesPerPixel  = ::GetDeviceCaps(hdc, BITSPIXEL);
    uHorzRes        = ::GetDeviceCaps(hdc, HORZRES);
    uVertRes        = ::GetDeviceCaps(hdc, VERTRES);

    // did we create it? if so, release it as well
    if (hdc && hdc != h)
    {
        ReleaseDC(0, hdc);
    }
}



void CHXWinSite::_DestroySliders()
{
    if(m_hXSlider)
    {
        ::DestroyWindow(m_hXSlider);
        zm_ScrollBarWnds.RemoveKey(m_hXSlider);
        m_hXSlider = NULL;
    }

    if(m_hYSlider)
    {
        ::DestroyWindow(m_hYSlider);
        zm_ScrollBarWnds.RemoveKey(m_hYSlider);
        m_hYSlider = NULL;
    }
}

void CHXWinSite::_GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2)
{
    //  Give all of those crappy renderers (you know who I am talking
    //  about flash!)  a WM_ message.
    HXxEvent winDozEvent;

    if(NULL==m_pUser)
        return;

    memcpy(&winDozEvent, pEvent, sizeof(HXxEvent)); /* Flawfinder: ignore */
    winDozEvent.param1 = pEvent->param2;
    winDozEvent.param2 = (void*) ((INT32) ((HXxPoint*)pEvent->param1)->y << 16 | ((HXxPoint*)pEvent->param1)->x);
    switch(pEvent2->event)
    {
       case HX_CONTEXT_BUTTON_DOWN:
           winDozEvent.event  = WM_RBUTTONDOWN;
           break;
       case HX_CONTEXT_BUTTON_UP:
           winDozEvent.event  = WM_RBUTTONUP;
           break;
       case HX_PRIMARY_BUTTON_DOWN:
           winDozEvent.event  = WM_LBUTTONDOWN;
           break;
       case HX_PRIMARY_BUTTON_UP:
           winDozEvent.event  = WM_LBUTTONUP;
           break;
       case HX_MOUSE_MOVE:
           winDozEvent.event  = WM_MOUSEMOVE;
           break;
       case HX_PRIMARY_DBLCLK:
           winDozEvent.event = WM_LBUTTONDBLCLK;
           break;
       case HX_CONTEXT_DBLCLK:
           winDozEvent.event = WM_RBUTTONDBLCLK;
           break;
       default:
           HX_ASSERT( "invalid RMA event for translation" );
           break;
    }

    m_pUser->HandleEvent(&winDozEvent);
    pEvent2->handled = winDozEvent.handled;
}


void CHXWinSite::_GenerateSetCursorEvent()
{
    HXxEvent setCursorEvent = {WM_SETCURSOR, GetWindow()->window, 0, 0, 0, FALSE};
    m_pUser->HandleEvent(&setCursorEvent);
}

HX_RESULT CHXWinSite::_EnterFullScreen()
{
    /* for the moment this will be COMPLETLY OS Specific */

    m_windowParent = GetParent((HWND) GetWindow()->window);

    HWND hParent = (HWND) GetWindow()->window;
    HWND hNextParent = NULL;

    while ((hNextParent = GetParent(hParent)) != NULL)
    {
        hParent = hNextParent;
    }

    // ask if it is topmost
    m_bWasTopMost = (GetWindowLong(hParent, GWL_EXSTYLE) & WS_EX_TOPMOST);

    if (m_bWasTopMost)
    {
        SafeSetWindowPos(hParent, HWND_NOTOPMOST, 0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
    }

    POINT point;
    memset(&point, 0, sizeof(POINT));
    MapWindowPoints( (HWND) GetWindow()->window, m_windowParent, &point, 1);

    RECT rect;
    ::GetWindowRect( (HWND) GetWindow()->window, &rect);

    m_windowPosition.x = point.x;
    m_windowPosition.y = point.y;
    m_windowSize.cx = rect.right - rect.left;
    m_windowSize.cy = rect.bottom - rect.top;

    m_bDisableForceRedraw = TRUE;

    if (zm_bInFullScreenTest)
    {
        HWND retVal = SetParent( (HWND) GetWindow()->window, NULL);
    }
    else
    {
        m_pContainingWindow = new CHXWinFullScreenWindow(this);
        m_pContainingWindow->Create();
        m_pContainingWindow->Show();
        HWND retVal = SetParent( (HWND) GetWindow()->window, m_pContainingWindow->GetWindow());
    }

    SetDisplayMode();

    // calculate new position

//      double stretchRatio, xRatio, yRatio;
//      IHXPreferences*        pPreferences    = NULL;
//      IHXBuffer*             pBuffer         = NULL;
//      BOOL            bPostageStamp   = FALSE;
//      char            szBuffer[255];

//      xRatio = (double)GetSystemMetrics(SM_CXSCREEN)/ (double)m_size.cx ;
//      yRatio = (double)GetSystemMetrics(SM_CYSCREEN)/ (double)m_size.cy ;

//      if (xRatio<yRatio)
//      {
//      stretchRatio = xRatio;
//      }
//      else
//      {
//      stretchRatio = yRatio;
//      }

//      m_screenOffset.x = (GetSystemMetrics(SM_CXSCREEN) - (int)((double)m_size.cx*stretchRatio))/2;
//      m_screenOffset.y = (GetSystemMetrics(SM_CYSCREEN) - (int)((double)m_size.cy*stretchRatio))/2;

//      HXxSize size;
//      size.cx = (int) ((double) m_size.cx * stretchRatio + 0.5);
//      size.cy = (int) ((double) m_size.cy * stretchRatio + 0.5);

    //Say we are in full screen mode
    m_bInFullScreen = TRUE;

    //Set up the windowing
    HXxSize newsize;
    newsize.cx = GetSystemMetrics(SM_CXSCREEN);
    newsize.cy = GetSystemMetrics(SM_CYSCREEN);

    //Tell the top level site that it has changed.
//    SetSize(size);
    SetSize(m_size);

    if (zm_bInFullScreenTest)
    {
        SafeSetWindowPos((HWND) GetWindow()->window, HWND_TOPMOST, 0, 0, newsize.cx, newsize.cy, NULL);
    }
    else
    {
        SafeMoveWindow((HWND) GetWindow()->window, 0, 0, newsize.cx, newsize.cy, FALSE);
    }

    /*
     * Get rid of all child windows.
     */

    zm_ListOfHiddenWindows.RemoveAll();
    EnumChildWindows( (HWND) GetWindow()->window, (WNDENUMPROC)HXxRemoveWindows, NULL);

    /*
     * Tell all renderers to repaint themselves
     */
    m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
    ((CWinBaseRootSurface*)m_pRootSurface)->PrepareFullScreen();
    _ForceRedrawAll();
    ((CWinBaseRootSurface*)m_pRootSurface)->SetFullScreen();
    ((CWinBaseRootSurface*)m_pRootSurface)->FillBorders();


    if (zm_ListOfHiddenWindows.GetCount())
    {
        CHXMapPtrToPtr::Iterator i = zm_ListOfHiddenWindows.Begin();
        for(;i!=zm_ListOfHiddenWindows.End();++i)
        {
            SafeShowWindow((HWND) i.get_key(), SW_SHOW);
        }
        zm_ListOfHiddenWindows.RemoveAll();
    }

    m_nDelayFillBorders = 3;
    ScheduleCallback(MOUSE, 0);

    SetFocus((HWND)GetWindow()->window);

    /*
     * Now tell the status text that it's parent has changed size.
     */

    if (m_pStatusText)
    {
        m_pStatusText->ParentChangedSize();
    }

    return HXR_OK;
}

HX_RESULT CHXWinSite::_ExitFullScreen()
{
    m_pTopLevelSite->m_bDisableForceRedraw = TRUE;
    memset(&m_screenOffset, 0, sizeof(HXxPoint));
    //  SetSize(m_windowSize);
    ((CWinBaseRootSurface*)m_pRootSurface)->PrepareExitFullScreen();

    EnterCriticalSection(&(((CHXWinSite*)m_pTopLevelSite)->m_CriticalSection));

    DestroySurfaces();
    ((CWinBaseRootSurface*)m_pRootSurface)->RestoreResolution();
    ReInitSurfaces();

    LeaveCriticalSection(&(((CHXWinSite*)m_pTopLevelSite)->m_CriticalSection));


    HWND retVal = SetParent((HWND)GetWindow()->window, m_windowParent);
    if (!zm_bInFullScreenTest)
    {
        m_pContainingWindow->Hide();
        m_pContainingWindow->Destroy();
        HX_DELETE(m_pContainingWindow);
    }

    SafeSetWindowPos((HWND) GetWindow()->window, HWND_TOP, 0,0,0,0,SWP_NOMOVE  | SWP_NOSIZE );

    SafeMoveWindow((HWND) GetWindow()->window, m_windowPosition.x, m_windowPosition.y, m_windowSize.cx, m_windowSize.cy, FALSE);

    m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
    memset(&m_screenOffset, 0, sizeof(HXxPoint));

    HWND hParent = (HWND) GetWindow()->window;
    HWND hNextParent = NULL;

    while ((hNextParent = GetParent(hParent)) != NULL)
    {
        hParent = hNextParent;
    }

    if (m_bWasTopMost)
    {
        /*
         *  Check to see if the player is playing, if it is then reset the player window to
         *   topmost.
         */

        IHXClientEngine* pEngine;
        IUnknown* pUnknown;
        IHXPlayer* pPlayer;

        BOOL bIsDone  = TRUE;

        if (HXR_OK == m_pContext->QueryInterface(IID_IHXClientEngine, (void**) &pEngine))
        {
            UINT16 count = pEngine->GetPlayerCount();
            while(count)
            {
                count--;
                if (HXR_OK == pEngine->GetPlayer(count, pUnknown))
                {