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] = ' ';
  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_INSERT] = KEY_INSERT;
  70     virtKeyToVlcKey[VK_DELETE] = KEY_DELETE;
  71     virtKeyToVlcKey[VK_HOME] = KEY_HOME;
  72     virtKeyToVlcKey[VK_END] = KEY_END;
  73     virtKeyToVlcKey[VK_PRIOR] = KEY_PAGEUP;
  74     virtKeyToVlcKey[VK_NEXT] = KEY_PAGEDOWN;
  75     virtKeyToVlcKey[VK_BROWSER_BACK] = KEY_BROWSER_BACK;
  76     virtKeyToVlcKey[VK_BROWSER_FORWARD] = KEY_BROWSER_FORWARD;
  77     virtKeyToVlcKey[VK_BROWSER_REFRESH] = KEY_BROWSER_REFRESH;
  78     virtKeyToVlcKey[VK_BROWSER_STOP] = KEY_BROWSER_STOP;
  79     virtKeyToVlcKey[VK_BROWSER_SEARCH] = KEY_BROWSER_SEARCH;
  80     virtKeyToVlcKey[VK_BROWSER_FAVORITES] = KEY_BROWSER_FAVORITES;
  81     virtKeyToVlcKey[VK_BROWSER_HOME] = KEY_BROWSER_HOME;
  82     virtKeyToVlcKey[VK_VOLUME_MUTE] = KEY_VOLUME_MUTE;
  83     virtKeyToVlcKey[VK_VOLUME_DOWN] = KEY_VOLUME_DOWN;
  84     virtKeyToVlcKey[VK_VOLUME_UP] = KEY_VOLUME_UP;
  85     virtKeyToVlcKey[VK_MEDIA_NEXT_TRACK] = KEY_MEDIA_NEXT_TRACK;
  86     virtKeyToVlcKey[VK_MEDIA_PREV_TRACK] = KEY_MEDIA_PREV_TRACK;
  87     virtKeyToVlcKey[VK_MEDIA_STOP] = KEY_MEDIA_STOP;
  88     virtKeyToVlcKey[VK_MEDIA_PLAY_PAUSE] = KEY_MEDIA_PLAY_PAUSE;
  89 }
  90
  91
  92 Win32Loop::~Win32Loop()
  93 {
  94 }
  95
  96
  97 OSLoop *Win32Loop::instance( intf_thread_t *pIntf )
  98 {
  99     if( pIntf->p_sys->p_osLoop == NULL )
 100     {
 101         OSLoop *pOsLoop = new Win32Loop( pIntf );
 102         pIntf->p_sys->p_osLoop = pOsLoop;
 103     }
 104     return pIntf->p_sys->p_osLoop;
 105 }
 106
 107
 108 void Win32Loop::destroy( intf_thread_t *pIntf )
 109 {
 110     delete pIntf->p_sys->p_osLoop;
 111     pIntf->p_sys->p_osLoop = NULL;
 112 }
 113
 114
 115 void Win32Loop::run()
 116 {
 117     MSG msg;
 118
 119     // Compute windows message list
 120     while( GetMessage( &msg, NULL, 0, 0 ) )
 121     {
 122         Win32Factory *pFactory =
 123             (Win32Factory*)Win32Factory::instance( getIntf() );
 124         GenericWindow *pWin = pFactory->m_windowMap[msg.hwnd];
 125         if( pWin == NULL )
 126         {
 127             // We are probably getting a message for a tooltip (which has no
 128             // associated GenericWindow), for a timer, or for the parent window
 129             DispatchMessage( &msg );
 130             continue;
 131         }
 132
 133         GenericWindow &win = *pWin;
 134         switch( msg.message )
 135         {
 136             case WM_PAINT:
 137             {
 138                 PAINTSTRUCT Infos;
 139                 BeginPaint( msg.hwnd, &Infos );
 140                 EvtRefresh evt( getIntf(),
 141                                 Infos.rcPaint.left,
 142                                 Infos.rcPaint.top,
 143                                 Infos.rcPaint.right - Infos.rcPaint.left + 1,
 144                                 Infos.rcPaint.bottom - Infos.rcPaint.top + 1 );
 145                 EndPaint( msg.hwnd, &Infos );
 146                 win.processEvent( evt );
 147                 break;
 148             }
 149             case WM_COMMAND:
 150             {
 151                 EvtMenu evt( getIntf(), LOWORD( msg.wParam ) );
 152                 win.processEvent( evt );
 153                 break;
 154             }
 155             case WM_MOUSEMOVE:
 156             {
 157                 // Needed to generate WM_MOUSELEAVE events
 158                 TRACKMOUSEEVENT TrackEvent;
 159                 TrackEvent.cbSize      = sizeof( TRACKMOUSEEVENT );
 160                 TrackEvent.dwFlags     = TME_LEAVE;
 161                 TrackEvent.hwndTrack   = msg.hwnd;
 162                 TrackEvent.dwHoverTime = 1;
 163                 TrackMouseEvent( &TrackEvent );
 164
 165                 // Compute the absolute position of the mouse
 166                 int x = GET_X_LPARAM( msg.lParam ) + win.getLeft();
 167                 int y = GET_Y_LPARAM( msg.lParam ) + win.getTop();
 168                 EvtMotion evt( getIntf(), x, y );
 169                 win.processEvent( evt );
 170                 break;
 171             }
 172             case WM_MOUSELEAVE:
 173             {
 174                 EvtLeave evt( getIntf() );
 175                 win.processEvent( evt );
 176                 break;
 177             }
 178             case WM_MOUSEWHEEL:
 179             {
 180                 int x = GET_X_LPARAM( msg.lParam ) - win.getLeft();
 181                 int y = GET_Y_LPARAM( msg.lParam ) - win.getTop();
 182                 int mod = getMod( msg.wParam );
 183                 if( GET_WHEEL_DELTA_WPARAM( msg.wParam ) > 0 )
 184                 {
 185                     EvtScroll evt( getIntf(), x, y, EvtScroll::kUp, mod );
 186                     win.processEvent( evt );
 187                 }
 188                 else
 189                 {
 190                     EvtScroll evt( getIntf(), x, y, EvtScroll::kDown, mod );
 191                     win.processEvent( evt );
 192                 }
 193                 break;
 194             }
 195             case WM_LBUTTONDOWN:
 196             {
 197                 SetCapture( msg.hwnd );
 198                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
 199                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kLeft,
 200                               EvtMouse::kDown, getMod( msg.wParam ) );
 201                 win.processEvent( evt );
 202                 break;
 203             }
 204             case WM_RBUTTONDOWN:
 205             {
 206                 SetCapture( msg.hwnd );
 207                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
 208                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kRight,
 209                               EvtMouse::kDown, getMod( msg.wParam ) );
 210                 win.processEvent( evt );
 211                 break;
 212             }
 213             case WM_LBUTTONUP:
 214             {
 215                 ReleaseCapture();
 216                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
 217                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kLeft,
 218                               EvtMouse::kUp, getMod( msg.wParam ) );
 219                 win.processEvent( evt );
 220                 break;
 221             }
 222             case WM_RBUTTONUP:
 223             {
 224                 ReleaseCapture();
 225                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
 226                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kRight,
 227                               EvtMouse::kUp, getMod( msg.wParam ) );
 228                 win.processEvent( evt );
 229                 break;
 230             }
 231             case WM_LBUTTONDBLCLK:
 232             {
 233                 ReleaseCapture();
 234                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
 235                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kLeft,
 236                               EvtMouse::kDblClick, getMod( msg.wParam ) );
 237                 win.processEvent( evt );
 238                 break;
 239             }
 240             case WM_RBUTTONDBLCLK:
 241             {
 242                 ReleaseCapture();
 243                 EvtMouse evt( getIntf(), GET_X_LPARAM( msg.lParam ),
 244                               GET_Y_LPARAM( msg.lParam ), EvtMouse::kRight,
 245                               EvtMouse::kDblClick, getMod( msg.wParam ) );
 246                 win.processEvent( evt );
 247                 break;
 248             }
 249             case WM_KEYDOWN:
 250             case WM_SYSKEYDOWN:
 251             case WM_KEYUP:
 252             case WM_SYSKEYUP:
 253             {
 254                 // The key events are first processed here and not translated
 255                 // into WM_CHAR events because we need to know the status of
 256                 // the modifier keys.
 257
 258                 // Get VLC key code from the virtual key code
 259                 int key = virtKeyToVlcKey[msg.wParam];
 260                 if( !key )
 261                 {
 262                     // This appears to be a "normal" (ascii) key
 263                     key = tolower( MapVirtualKey( msg.wParam, 2 ) );
 264                 }
 265
 266                 if( key )
 267                 {
 268                     // Get the modifier
 269                     int mod = 0;
 270                     if( GetKeyState( VK_CONTROL ) & 0x8000 )
 271                     {
 272                         mod |= EvtInput::kModCtrl;
 273                     }
 274                     if( GetKeyState( VK_SHIFT ) & 0x8000 )
 275                     {
 276                         mod |= EvtInput::kModShift;
 277                     }
 278                     if( GetKeyState( VK_MENU ) & 0x8000 )
 279                     {
 280                         mod |= EvtInput::kModAlt;
 281                     }
 282
 283                     // Get the state
 284                     EvtKey::ActionType_t state;
 285                     if( msg.message == WM_KEYDOWN ||
 286                         msg.message == WM_SYSKEYDOWN )
 287                     {
 288                         state = EvtKey::kDown;
 289                     }
 290                     else
 291                     {
 292                         state = EvtKey::kUp;
 293                     }
 294
 295                     EvtKey evt( getIntf(), key, state, mod );
 296                     win.processEvent( evt );
 297                 }
 298                 break;
 299             }
 300             default:
 301                 TranslateMessage( &msg );
 302                 DispatchMessage( &msg );
 303         }
 304     }
 305 }
 306
 307
 308 int Win32Loop::getMod( WPARAM wParam ) const
 309 {
 310     int mod = EvtInput::kModNone;
 311     if( wParam & MK_CONTROL )
 312         mod |= EvtInput::kModCtrl;
 313     if( wParam & MK_SHIFT )
 314         mod |= EvtInput::kModShift;
 315
 316     return mod;
 317 }
 318
 319
 320 void Win32Loop::exit()
 321 {
 322     PostQuitMessage(0);
 323 }
 324
 325 #endif