winsite.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

       case WM_WINDOWPOSCHANGING:
#ifdef _CHECK_CREATE
       {
           RECT rect;
           ::GetWindowRect((HWND)GetWindow()->window, &rect);
           FILE* f1 = fopen("c:\\create.txt", "a+"); /* Flawfinder: ignore */
           fprintf(f1, "%p WM_SIZE: %p  hwnd: %p  internalSize: (%d, %d) external Size: (%d, %d)\n", GetCurrentThreadId(),this, GetWindow()->window, m_size.cx, m_size.cy, rect.right -rect.left, rect.bottom - rect.top);
           fclose(f1);
       }
#endif
       if (m_bInFullScreen)
       {
           lResult = DefWindowProc( hWnd, message, wParam, lParam); 
           retValue = TRUE;
           goto leave;
       }
       else
       {
           retValue = FALSE;
           goto leave;
       }
       break;
#ifndef _HAMEL
       case WM_ACTIVATE:
       case WM_ACTIVATEAPP:
       {
            
           DWORD fActive = LOWORD(wParam);           
            
           if (m_bInFullScreen && m_pUser && !fActive)
           {
               HXxEvent event = {WM_CHAR, GetWindow()->window, (void*)VK_ESCAPE, 0, 0, 0};
               m_pUser->HandleEvent(&event);
           }
           retValue = FALSE;
           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));