git.sesse.net Git - vlc/blob - modules/gui/skins2/win32/win32_loop.cpp

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