win32_loop.cpp
上传用户:riyaled888
上传日期:2009-03-27
资源大小:7338k
文件大小:10k
源码类别:

多媒体

开发平台:

MultiPlatform

  1. /*****************************************************************************
  2.  * win32_loop.cpp
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 VideoLAN
  5.  * $Id: win32_loop.cpp 9320 2004-11-14 17:32:25Z ipkiss $
  6.  *
  7.  * Authors: Cyril Deguet     <asmax@via.ecp.fr>
  8.  *          Olivier Teuli鑢e <ipkiss@via.ecp.fr>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  24. #ifdef WIN32_SKINS
  25. #include "win32_factory.hpp"
  26. #include "win32_loop.hpp"
  27. #include "../src/generic_window.hpp"
  28. #include "../events/evt_key.hpp"
  29. #include "../events/evt_leave.hpp"
  30. #include "../events/evt_motion.hpp"
  31. #include "../events/evt_mouse.hpp"
  32. #include "../events/evt_refresh.hpp"
  33. #include "../events/evt_scroll.hpp"
  34. #include "vlc_keys.h"
  35. // XXX: Cygwin (at least) doesn't define these macros. Too bad...
  36. #ifndef GET_X_LPARAM
  37.     #define GET_X_LPARAM(a) ((int16_t)(a))
  38.     #define GET_Y_LPARAM(a) ((int16_t)((a)>>16))
  39. #endif
  40. Win32Loop::Win32Loop( intf_thread_t *pIntf ): OSLoop( pIntf )
  41. {
  42.     // Initialize the map
  43.     virtKeyToVlcKey[VK_F1] = KEY_F1;
  44.     virtKeyToVlcKey[VK_F2] = KEY_F2;
  45.     virtKeyToVlcKey[VK_F3] = KEY_F3;
  46.     virtKeyToVlcKey[VK_F4] = KEY_F4;
  47.     virtKeyToVlcKey[VK_F5] = KEY_F5;
  48.     virtKeyToVlcKey[VK_F6] = KEY_F6;
  49.     virtKeyToVlcKey[VK_F7] = KEY_F7;
  50.     virtKeyToVlcKey[VK_F8] = KEY_F8;
  51.     virtKeyToVlcKey[VK_F9] = KEY_F9;
  52.     virtKeyToVlcKey[VK_F10] = KEY_F10;
  53.     virtKeyToVlcKey[VK_F11] = KEY_F11;
  54.     virtKeyToVlcKey[VK_F12] = KEY_F12;
  55.     virtKeyToVlcKey[VK_RETURN] = KEY_ENTER;
  56.     virtKeyToVlcKey[VK_SPACE] = KEY_SPACE;
  57.     virtKeyToVlcKey[VK_ESCAPE] = KEY_ESC;
  58.     virtKeyToVlcKey[VK_LEFT] = KEY_LEFT;
  59.     virtKeyToVlcKey[VK_RIGHT] = KEY_RIGHT;
  60.     virtKeyToVlcKey[VK_UP] = KEY_UP;
  61.     virtKeyToVlcKey[VK_DOWN] = KEY_DOWN;
  62.     virtKeyToVlcKey[VK_HOME] = KEY_HOME;
  63.     virtKeyToVlcKey[VK_END] = KEY_END;
  64.     virtKeyToVlcKey[VK_PRIOR] = KEY_PAGEUP;
  65.     virtKeyToVlcKey[VK_NEXT] = KEY_PAGEDOWN;
  66. }
  67. Win32Loop::~Win32Loop()
  68. {
  69. }
  70. OSLoop *Win32Loop::instance( intf_thread_t *pIntf )
  71. {
  72.     if( pIntf->p_sys->p_osLoop == NULL )
  73.     {
  74.         OSLoop *pOsLoop = new Win32Loop( pIntf );
  75.         pIntf->p_sys->p_osLoop = pOsLoop;
  76.     }
  77.     return pIntf->p_sys->p_osLoop;
  78. }
  79. void Win32Loop::destroy( intf_thread_t *pIntf )
  80. {
  81.     if( pIntf->p_sys->p_osLoop )
  82.     {
  83.         delete pIntf->p_sys->p_osLoop;
  84.         pIntf->p_sys->p_osLoop = NULL;
  85.     }
  86. }
  87. void Win32Loop::run()
  88. {
  89.     MSG msg;
  90.     // Compute windows message list
  91.     while( GetMessage( &msg, NULL, 0, 0 ) )
  92.     {
  93.         Win32Factory *pFactory =
  94.             (Win32Factory*)Win32Factory::instance( getIntf() );
  95.         GenericWindow *pWin = pFactory->m_windowMap[msg.hwnd];
  96.         if( pWin == NULL )
  97.         {
  98.             // We are probably getting a message for a tooltip (which has no
  99.             // associated GenericWindow), for a timer, or for the parent window
  100.             DispatchMessage( &msg );
  101.             continue;
  102.         }
  103.         GenericWindow &win = *pWin;
  104.         switch( msg.message )
  105.         {
  106.             case WM_PAINT:
  107.             {
  108.                 PAINTSTRUCT Infos;
  109.                 BeginPaint( msg.hwnd, &Infos );
  110.                 EvtRefresh evt( getIntf(),
  111.                                 Infos.rcPaint.left,
  112.                                 Infos.rcPaint.top,
  113.                                 Infos.rcPaint.right - Infos.rcPaint.left + 1,
  114.                                 Infos.rcPaint.bottom - Infos.rcPaint.top + 1 );
  115.                 EndPaint( msg.hwnd, &Infos );
  116.                 // Ignore all the painting events for the vout window,
  117.                 // otherwise we are going to screw up the colorkey
  118.                 if( win.getType() != "Vout" )
  119.                 {
  120.                     win.processEvent( evt );
  121.                 }
  122.                 break;
  123.             }
  124.             case WM_MOUSEMOVE:
  125.             {
  126.                 // Needed to generate WM_MOUSELEAVE events
  127.                 TRACKMOUSEEVENT TrackEvent;
  128.                 TrackEvent.cbSize      = sizeof( TRACKMOUSEEVENT );
  129.                 TrackEvent.dwFlags     = TME_LEAVE;
  130.                 TrackEvent.hwndTrack   = msg.hwnd;
  131.                 TrackEvent.dwHoverTime = 1;
  132.                 TrackMouseEvent( &TrackEvent );
  133.                 // Compute the absolute position of the mouse
  134.                 int x = GET_X_LPARAM( msg.lParam ) + win.getLeft();
  135.                 int y = GET_Y_LPARAM( msg.lParam ) + win.getTop();
  136.                 EvtMotion evt( getIntf(), x, y );
  137.                 win.processEvent( evt );
  138.                 break;
  139.             }
  140.             case WM_MOUSELEAVE:
  141.             {
  142.                 EvtLeave evt( getIntf() );
  143.                 win.processEvent( evt );
  144.                 break;
  145.             }
  146.             case WM_MOUSEWHEEL:
  147.             {
  148.                 int x = GET_X_LPARAM( msg.lParam ) - win.getLeft();
  149.                 int y = GET_Y_LPARAM( msg.lParam ) - win.getTop();
  150.                 int mod = getMod( msg.wParam );
  151.                 if( GET_WHEEL_DELTA_WPARAM( msg.wParam ) > 0 )
  152.                 {
  153.                     EvtScroll evt( getIntf(), x, y, EvtScroll::kUp, mod );
  154.                     win.processEvent( evt );
  155.                 }
  156.                 else
  157.                 {
  158.                     EvtScroll evt( getIntf(), x, y, EvtScroll::kDown, mod );
  159.                     win.processEvent( evt );
  160.                 }
  161.                 break;
  162.             }
  163.             case WM_LBUTTONDOWN:
  164.             {
  165.                 SetCapture( msg.hwnd );
  166.                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
  167.                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kLeft,
  168.                               EvtMouse::kDown, getMod( msg.wParam ) );
  169.                 win.processEvent( evt );
  170.                 break;
  171.             }
  172.             case WM_RBUTTONDOWN:
  173.             {
  174.                 SetCapture( msg.hwnd );
  175.                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
  176.                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kRight,
  177.                               EvtMouse::kDown, getMod( msg.wParam ) );
  178.                 win.processEvent( evt );
  179.                 break;
  180.             }
  181.             case WM_LBUTTONUP:
  182.             {
  183.                 ReleaseCapture();
  184.                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
  185.                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kLeft,
  186.                               EvtMouse::kUp, getMod( msg.wParam ) );
  187.                 win.processEvent( evt );
  188.                 break;
  189.             }
  190.             case WM_RBUTTONUP:
  191.             {
  192.                 ReleaseCapture();
  193.                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
  194.                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kRight,
  195.                               EvtMouse::kUp, getMod( msg.wParam ) );
  196.                 win.processEvent( evt );
  197.                 break;
  198.             }
  199.             case WM_LBUTTONDBLCLK:
  200.             {
  201.                 ReleaseCapture();
  202.                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
  203.                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kLeft,
  204.                               EvtMouse::kDblClick, getMod( msg.wParam ) );
  205.                 win.processEvent( evt );
  206.                 break;
  207.             }
  208.             case WM_RBUTTONDBLCLK:
  209.             {
  210.                 ReleaseCapture();
  211.                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
  212.                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kRight,
  213.                               EvtMouse::kDblClick, getMod( msg.wParam ) );
  214.                 win.processEvent( evt );
  215.                 break;
  216.             }
  217.             case WM_KEYDOWN:
  218.             case WM_SYSKEYDOWN:
  219.             case WM_KEYUP:
  220.             case WM_SYSKEYUP:
  221.             {
  222.                 // The key events are first processed here and not translated
  223.                 // into WM_CHAR events because we need to know the status of
  224.                 // the modifier keys.
  225.                 // Get VLC key code from the virtual key code
  226.                 int key = virtKeyToVlcKey[msg.wParam];
  227.                 if( !key )
  228.                 {
  229.                     // This appears to be a "normal" (ascii) key
  230.                     key = tolower( MapVirtualKey( msg.wParam, 2 ) );
  231.                 }
  232.                 if( key )
  233.                 {
  234.                     // Get the modifier
  235.                     int mod = 0;
  236.                     if( GetKeyState( VK_CONTROL ) & 0x8000 )
  237.                     {
  238.                         mod |= EvtInput::kModCtrl;
  239.                     }
  240.                     if( GetKeyState( VK_SHIFT ) & 0x8000 )
  241.                     {
  242.                         mod |= EvtInput::kModShift;
  243.                     }
  244.                     if( GetKeyState( VK_MENU ) & 0x8000 )
  245.                     {
  246.                         mod |= EvtInput::kModAlt;
  247.                     }
  248.                     // Get the state
  249.                     EvtKey::ActionType_t state;
  250.                     if( msg.message == WM_KEYDOWN ||
  251.                         msg.message == WM_SYSKEYDOWN )
  252.                     {
  253.                         state = EvtKey::kDown;
  254.                     }
  255.                     else
  256.                     {
  257.                         state = EvtKey::kUp;
  258.                     }
  259.                     EvtKey evt( getIntf(), key, state, mod );
  260.                     win.processEvent( evt );
  261.                 }
  262.                 break;
  263.             }
  264.             default:
  265.                 TranslateMessage( &msg );
  266.                 DispatchMessage( &msg );
  267.         }
  268.     }
  269. }
  270. int Win32Loop::getMod( WPARAM wParam ) const
  271. {
  272.     int mod = EvtInput::kModNone;
  273.     if( wParam & MK_CONTROL )
  274.         mod |= EvtInput::kModCtrl;
  275.     if( wParam & MK_SHIFT )
  276.         mod |= EvtInput::kModShift;
  277.     return mod;
  278. }
  279. void Win32Loop::exit()
  280. {
  281.     PostQuitMessage(0);
  282. }
  283. #endif