git.sesse.net Git - vlc/blob - modules/video_output/msw/events.c

   1 /*****************************************************************************
   2  * events.c: Windows DirectX video output events handler
   3  *****************************************************************************
   4  * Copyright (C) 2001-2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24
  25 /*****************************************************************************
  26  * Preamble: This file contains the functions related to the creation of
  27  *             a window and the handling of its messages (events).
  28  *****************************************************************************/
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34 #include <vlc_vout_display.h>
  35 #include <vlc_vout_window.h>
  36
  37 #include <windows.h>
  38 #include <windowsx.h>
  39 #include <shellapi.h>
  40
  41 #include <ctype.h>
  42
  43 #ifdef MODULE_NAME_IS_directx
  44 #include <ddraw.h>
  45 #endif
  46 #ifdef MODULE_NAME_IS_direct3d
  47 #include <d3d9.h>
  48 #endif
  49 #ifdef MODULE_NAME_IS_glwin32
  50 #include "../opengl.h"
  51 #endif
  52
  53 #include <vlc_keys.h>
  54 #include "common.h"
  55
  56 #ifdef UNDER_CE
  57 #include <aygshell.h>
  58     //WINSHELLAPI BOOL WINAPI SHFullScreen(HWND hwndRequester, DWORD dwState);
  59
  60 UINT GetMenuState(HMENU hMenu, UINT id, UINT flags)
  61 {
  62     MENUITEMINFO info;
  63     memset(&info, 0, sizeof(info));
  64     info.cbSize = sizeof(info);
  65     info.fMask = MIIM_STATE;
  66     if (!GetMenuItemInfo(hMenu, id, (flags & MF_BYPOSITION) != 0, &info))
  67         return -1;
  68     /* XXX Submenu handling is missing... */
  69     return info.fState;
  70 }
  71 #endif
  72
  73 /*#if defined(UNDER_CE) && !defined(__PLUGIN__) --FIXME*/
  74 /*#   define SHFS_SHOWSIPBUTTON 0x0004
  75 #   define SHFS_HIDESIPBUTTON 0x0008
  76 #   define MENU_HEIGHT 26
  77     BOOL SHFullScreen(HWND hwndRequester, DWORD dwState);
  78 #endif*/
  79
  80 /*****************************************************************************
  81  * Local prototypes.
  82  *****************************************************************************/
  83 #define WM_VLC_HIDE_MOUSE   (WM_APP + 0)
  84 #define WM_VLC_CHANGE_TEXT  (WM_APP + 1)
  85
  86 struct event_thread_t
  87 {
  88     vout_display_t *vd;
  89
  90     /* */
  91     vlc_thread_t thread;
  92     vlc_mutex_t  lock;
  93     vlc_cond_t   wait;
  94     bool         b_ready;
  95     bool         b_done;
  96     bool         b_error;
  97
  98     /* */
  99     bool use_desktop;
 100     bool use_overlay;
 101
 102     /* Mouse */
 103     bool is_cursor_hidden;
 104     HCURSOR cursor_arrow;
 105     HCURSOR cursor_empty;
 106     unsigned button_pressed;
 107
 108     /* Title */
 109     char *psz_title;
 110
 111     int               i_window_style;
 112     vout_window_cfg_t wnd_cfg;
 113
 114     /* */
 115     vout_window_t *parent_window;
 116     TCHAR class_main[256];
 117     TCHAR class_video[256];
 118     HWND hparent;
 119     HWND hwnd;
 120     HWND hvideownd;
 121     HWND hfswnd;
 122     video_format_t       source;
 123     vout_display_place_t place;
 124
 125     bool has_moved;
 126 };
 127
 128 static int  DirectXCreateWindow( event_thread_t * );
 129 static void DirectXCloseWindow ( event_thread_t * );
 130 static long FAR PASCAL DirectXEventProc( HWND, UINT, WPARAM, LPARAM );
 131
 132 static int DirectXConvertKey( int i_key );
 133
 134 static inline bool isMouseEvent( WPARAM type )
 135 {
 136     return type >= WM_MOUSEFIRST &&
 137            type <= WM_MOUSELAST;
 138 }
 139
 140 static inline bool isKeyEvent( WPARAM type )
 141 {
 142     return type >= WM_KEYFIRST &&
 143            type <= WM_KEYLAST;
 144 }
 145
 146 static void UpdateCursor( event_thread_t *p_event, bool b_show )
 147 {
 148     if( p_event->is_cursor_hidden == !b_show )
 149         return;
 150     p_event->is_cursor_hidden = !b_show;
 151
 152 #if 1
 153     HCURSOR cursor = b_show ? p_event->cursor_arrow : p_event->cursor_empty;
 154     if( p_event->hvideownd )
 155         SetClassLongPtr( p_event->hvideownd, GCLP_HCURSOR, (LONG_PTR)cursor );
 156     if( p_event->hwnd )
 157         SetClassLongPtr( p_event->hwnd, GCLP_HCURSOR, (LONG_PTR)cursor );
 158 #endif
 159
 160     /* FIXME I failed to find a cleaner way to force a redraw of the cursor */
 161     POINT p;
 162     GetCursorPos(&p);
 163     HWND hwnd = WindowFromPoint(p);
 164     if( hwnd == p_event->hvideownd || hwnd == p_event->hwnd )
 165     {
 166         if( b_show )
 167             SetCursor( cursor );
 168         else
 169             SetCursorPos( p.x, p.y );
 170     }
 171 }
 172
 173 #ifndef UNDER_CE
 174 static HCURSOR EmptyCursor( HINSTANCE instance )
 175 {
 176     const int cw = GetSystemMetrics(SM_CXCURSOR);
 177     const int ch = GetSystemMetrics(SM_CYCURSOR);
 178
 179     HCURSOR cursor = NULL;
 180     uint8_t *and = malloc(cw * ch);
 181     uint8_t *xor = malloc(cw * ch);
 182     if( and && xor )
 183     {
 184         memset(and, 0xff, cw * ch );
 185         memset(xor, 0x00, cw * ch );
 186         cursor = CreateCursor( instance, 0, 0, cw, ch, and, xor);
 187     }
 188     free( and );
 189     free( xor );
 190
 191     return cursor;
 192 }
 193 #endif
 194
 195 static void MousePressed( event_thread_t *p_event, HWND hwnd, unsigned button )
 196 {
 197     if( !p_event->button_pressed )
 198         SetCapture( hwnd );
 199     p_event->button_pressed |= 1 << button;
 200     vout_display_SendEventMousePressed( p_event->vd, button );
 201 }
 202
 203 static void MouseReleased( event_thread_t *p_event, unsigned button )
 204 {
 205     p_event->button_pressed &= ~(1 << button);
 206     if( !p_event->button_pressed )
 207         ReleaseCapture();
 208     vout_display_SendEventMouseReleased( p_event->vd, button );
 209 }
 210 /*****************************************************************************
 211  * EventThread: Create video window & handle its messages
 212  *****************************************************************************
 213  * This function creates a video window and then enters an infinite loop
 214  * that handles the messages sent to that window.
 215  * The main goal of this thread is to isolate the Win32 PeekMessage function
 216  * because this one can block for a long time.
 217  *****************************************************************************/
 218 static void *EventThread( void *p_this )
 219 {
 220     event_thread_t *p_event = (event_thread_t *)p_this;
 221     vout_display_t *vd = p_event->vd;
 222     MSG msg;
 223     POINT old_mouse_pos = {0,0}, mouse_pos;
 224     HMODULE hkernel32;
 225     int canc = vlc_savecancel ();
 226
 227     bool b_mouse_support = var_InheritBool( p_event->vd, "mouse-events" );
 228     bool b_key_support = var_InheritBool( p_event->vd, "keyboard-events" );
 229
 230     vlc_mutex_lock( &p_event->lock );
 231     /* Create a window for the video */
 232     /* Creating a window under Windows also initializes the thread's event
 233      * message queue */
 234     if( DirectXCreateWindow( p_event ) )
 235         p_event->b_error = true;
 236
 237     p_event->b_ready = true;
 238     vlc_cond_signal( &p_event->wait );
 239
 240     const bool b_error = p_event->b_error;
 241     vlc_mutex_unlock( &p_event->lock );
 242
 243     if( b_error )
 244     {
 245         vlc_restorecancel( canc );
 246         return NULL;
 247     }
 248
 249 #ifndef UNDER_CE
 250     /* Set power management stuff */
 251     if( (hkernel32 = GetModuleHandle( _T("KERNEL32") ) ) )
 252     {
 253         ULONG (WINAPI* OurSetThreadExecutionState)( ULONG );
 254
 255         OurSetThreadExecutionState = (ULONG (WINAPI*)( ULONG ))
 256             GetProcAddress( hkernel32, _T("SetThreadExecutionState") );
 257
 258         if( OurSetThreadExecutionState )
 259             /* Prevent monitor from powering off */
 260             OurSetThreadExecutionState( ES_DISPLAY_REQUIRED | ES_CONTINUOUS );
 261         else
 262             msg_Dbg( vd, "no support for SetThreadExecutionState()" );
 263     }
 264 #endif
 265
 266     /* Main loop */
 267     /* GetMessage will sleep if there's no message in the queue */
 268     for( ;; )
 269     {
 270         vout_display_place_t place;
 271         video_format_t       source;
 272
 273         if( !GetMessage( &msg, 0, 0, 0 ) )
 274         {
 275             vlc_mutex_lock( &p_event->lock );
 276             p_event->b_done = true;
 277             vlc_mutex_unlock( &p_event->lock );
 278             break;
 279         }
 280
 281         /* Check if we are asked to exit */
 282         vlc_mutex_lock( &p_event->lock );
 283         const bool b_done = p_event->b_done;
 284         vlc_mutex_unlock( &p_event->lock );
 285         if( b_done )
 286             break;
 287
 288         if( !b_mouse_support && isMouseEvent( msg.message ) )
 289             continue;
 290
 291         if( !b_key_support && isKeyEvent( msg.message ) )
 292             continue;
 293
 294         /* Handle mouse state */
 295         if( msg.message == WM_MOUSEMOVE ||
 296             msg.message == WM_NCMOUSEMOVE )
 297         {
 298             GetCursorPos( &mouse_pos );
 299             /* FIXME, why this >2 limits ? */
 300             if( (abs(mouse_pos.x - old_mouse_pos.x) > 2 ||
 301                 (abs(mouse_pos.y - old_mouse_pos.y)) > 2 ) )
 302             {
 303                 old_mouse_pos = mouse_pos;
 304                 UpdateCursor( p_event, true );
 305             }
 306         }
 307         else if( isMouseEvent( msg.message ) )
 308         {
 309             UpdateCursor( p_event, true );
 310         }
 311         else if( msg.message == WM_VLC_HIDE_MOUSE )
 312         {
 313             UpdateCursor( p_event, false );
 314         }
 315
 316         /* */
 317         switch( msg.message )
 318         {
 319         case WM_MOUSEMOVE:
 320             vlc_mutex_lock( &p_event->lock );
 321             place  = p_event->place;
 322             source = p_event->source;
 323             vlc_mutex_unlock( &p_event->lock );
 324
 325             if( place.width > 0 && place.height > 0 )
 326             {
 327                 if( msg.hwnd == p_event->hvideownd )
 328                 {
 329                     /* Child window */
 330                     place.x = 0;
 331                     place.y = 0;
 332                 }
 333                 const int x = source.i_x_offset +
 334                     (int64_t)(GET_X_LPARAM(msg.lParam) - place.x) * source.i_width  / place.width;
 335                 const int y = source.i_y_offset +
 336                     (int64_t)(GET_Y_LPARAM(msg.lParam) - place.y) * source.i_height / place.height;
 337                 vout_display_SendEventMouseMoved(vd, x, y);
 338             }
 339             break;
 340         case WM_NCMOUSEMOVE:
 341             break;
 342
 343         case WM_VLC_HIDE_MOUSE:
 344             break;
 345
 346         case WM_LBUTTONDOWN:
 347             MousePressed( p_event, msg.hwnd, MOUSE_BUTTON_LEFT );
 348             break;
 349         case WM_LBUTTONUP:
 350             MouseReleased( p_event, MOUSE_BUTTON_LEFT );
 351             break;
 352         case WM_LBUTTONDBLCLK:
 353             vout_display_SendEventMouseDoubleClick(vd);
 354             break;
 355
 356         case WM_MBUTTONDOWN:
 357             MousePressed( p_event, msg.hwnd, MOUSE_BUTTON_CENTER );
 358             break;
 359         case WM_MBUTTONUP:
 360             MouseReleased( p_event, MOUSE_BUTTON_CENTER );
 361             break;
 362
 363         case WM_RBUTTONDOWN:
 364             MousePressed( p_event, msg.hwnd, MOUSE_BUTTON_RIGHT );
 365             break;
 366         case WM_RBUTTONUP:
 367             MouseReleased( p_event, MOUSE_BUTTON_RIGHT );
 368             break;
 369
 370         case WM_KEYDOWN:
 371         case WM_SYSKEYDOWN:
 372         {
 373             /* The key events are first processed here and not translated
 374              * into WM_CHAR events because we need to know the status of the
 375              * modifier keys. */
 376             int i_key = DirectXConvertKey( msg.wParam );
 377             if( !i_key )
 378             {
 379                 /* This appears to be a "normal" (ascii) key */
 380                 i_key = tolower( MapVirtualKey( msg.wParam, 2 ) );
 381             }
 382
 383             if( i_key )
 384             {
 385                 if( GetKeyState(VK_CONTROL) & 0x8000 )
 386                 {
 387                     i_key |= KEY_MODIFIER_CTRL;
 388                 }
 389                 if( GetKeyState(VK_SHIFT) & 0x8000 )
 390                 {
 391                     i_key |= KEY_MODIFIER_SHIFT;
 392                 }
 393                 if( GetKeyState(VK_MENU) & 0x8000 )
 394                 {
 395                     i_key |= KEY_MODIFIER_ALT;
 396                 }
 397
 398                 vout_display_SendEventKey(vd, i_key);
 399             }
 400             break;
 401         }
 402
 403         case WM_MOUSEWHEEL:
 404         {
 405             int i_key;
 406             if( GET_WHEEL_DELTA_WPARAM( msg.wParam ) > 0 )
 407             {
 408                 i_key = KEY_MOUSEWHEELUP;
 409             }
 410             else
 411             {
 412                 i_key = KEY_MOUSEWHEELDOWN;
 413             }
 414             if( i_key )
 415             {
 416                 if( GetKeyState(VK_CONTROL) & 0x8000 )
 417                 {
 418                     i_key |= KEY_MODIFIER_CTRL;
 419                 }
 420                 if( GetKeyState(VK_SHIFT) & 0x8000 )
 421                 {
 422                     i_key |= KEY_MODIFIER_SHIFT;
 423                 }
 424                 if( GetKeyState(VK_MENU) & 0x8000 )
 425                 {
 426                     i_key |= KEY_MODIFIER_ALT;
 427                 }
 428                 vout_display_SendEventKey(vd, i_key);
 429             }
 430             break;
 431         }
 432
 433         case WM_VLC_CHANGE_TEXT:
 434         {
 435             vlc_mutex_lock( &p_event->lock );
 436             wchar_t *pwz_title = NULL;
 437             if( p_event->psz_title )
 438             {
 439                 const size_t i_length = strlen(p_event->psz_title);
 440                 pwz_title = malloc( 2 * (i_length + 1) );
 441                 if( pwz_title )
 442                 {
 443                     mbstowcs( pwz_title, p_event->psz_title, 2 * i_length );
 444                     pwz_title[i_length] = 0;
 445                 }
 446             }
 447             vlc_mutex_unlock( &p_event->lock );
 448
 449             if( pwz_title )
 450             {
 451                 SetWindowTextW( p_event->hwnd, pwz_title );
 452                 if( p_event->hfswnd )
 453                     SetWindowTextW( p_event->hfswnd, pwz_title );
 454                 free( pwz_title );
 455             }
 456             break;
 457         }
 458
 459         default:
 460             /* Messages we don't handle directly are dispatched to the
 461              * window procedure */
 462             TranslateMessage(&msg);
 463             DispatchMessage(&msg);
 464             break;
 465
 466         } /* End Switch */
 467
 468     } /* End Main loop */
 469
 470     /* Check for WM_QUIT if we created the window */
 471     if( !p_event->hparent && msg.message == WM_QUIT )
 472     {
 473         msg_Warn( vd, "WM_QUIT... should not happen!!" );
 474         p_event->hwnd = NULL; /* Window already destroyed */
 475     }
 476
 477     msg_Dbg( vd, "DirectXEventThread terminating" );
 478
 479     DirectXCloseWindow( p_event );
 480     vlc_restorecancel(canc);
 481     return NULL;
 482 }
 483
 484
 485 /* following functions are local */
 486
 487 /*****************************************************************************
 488  * DirectXCreateWindow: create a window for the video.
 489  *****************************************************************************
 490  * Before creating a direct draw surface, we need to create a window in which
 491  * the video will be displayed. This window will also allow us to capture the
 492  * events.
 493  *****************************************************************************/
 494 static int DirectXCreateWindow( event_thread_t *p_event )
 495 {
 496     vout_display_t *vd = p_event->vd;
 497     HINSTANCE  hInstance;
 498     HMENU      hMenu;
 499     RECT       rect_window;
 500     WNDCLASS   wc;                            /* window class components */
 501     HICON      vlc_icon;
 502     char       vlc_path[MAX_PATH+1];
 503     int        i_style, i_stylex;
 504
 505     msg_Dbg( vd, "DirectXCreateWindow" );
 506
 507     /* Get this module's instance */
 508     hInstance = GetModuleHandle(NULL);
 509
 510     #ifdef MODULE_NAME_IS_direct3d
 511     if( !p_event->use_desktop )
 512     {
 513     #endif
 514         /* If an external window was specified, we'll draw in it. */
 515         p_event->parent_window = vout_display_NewWindow(vd, &p_event->wnd_cfg );
 516         if( p_event->parent_window )
 517             p_event->hparent = p_event->parent_window->handle.hwnd;
 518         else
 519             p_event->hparent = NULL;
 520     #ifdef MODULE_NAME_IS_direct3d
 521     }
 522     else
 523     {
 524         /* Find Program Manager */
 525         HWND hwnd = FindWindow( _T("Progman"), NULL );
 526         if( hwnd ) hwnd = FindWindowEx( hwnd, NULL, _T("SHELLDLL_DefView"), NULL );
 527         if( hwnd ) hwnd = FindWindowEx( hwnd, NULL, _T("SysListView32"), NULL );
 528         if( !hwnd )
 529             msg_Err( vd, "Couldn't find desktop icon window. Desktop mode can't be established." );
 530         p_event->parent_window = NULL;
 531         p_event->hparent = hwnd;
 532     }
 533     #endif
 534     p_event->cursor_arrow = LoadCursor(NULL, IDC_ARROW);
 535 #ifndef UNDER_CE
 536     p_event->cursor_empty = EmptyCursor(hInstance);
 537 #endif
 538
 539     /* Get the Icon from the main app */
 540     vlc_icon = NULL;
 541 #ifndef UNDER_CE
 542     if( GetModuleFileName( NULL, vlc_path, MAX_PATH ) )
 543     {
 544         vlc_icon = ExtractIcon( hInstance, vlc_path, 0 );
 545     }
 546 #endif
 547
 548     /* Fill in the window class structure */
 549     wc.style         = CS_OWNDC|CS_DBLCLKS;          /* style: dbl click */
 550     wc.lpfnWndProc   = (WNDPROC)DirectXEventProc;       /* event handler */
 551     wc.cbClsExtra    = 0;                         /* no extra class data */
 552     wc.cbWndExtra    = 0;                        /* no extra window data */
 553     wc.hInstance     = hInstance;                            /* instance */
 554     wc.hIcon         = vlc_icon;                /* load the vlc big icon */
 555     wc.hCursor       = p_event->is_cursor_hidden ? p_event->cursor_empty :
 556                                                    p_event->cursor_arrow;
 557     wc.hbrBackground = GetStockObject(BLACK_BRUSH);  /* background color */
 558     wc.lpszMenuName  = NULL;                                  /* no menu */
 559     wc.lpszClassName = p_event->class_main;       /* use a special class */
 560
 561     /* Register the window class */
 562     if( !RegisterClass(&wc) )
 563     {
 564         if( vlc_icon )
 565             DestroyIcon( vlc_icon );
 566
 567         msg_Err( vd, "DirectXCreateWindow RegisterClass FAILED (err=%lu)", GetLastError() );
 568         return VLC_EGENERIC;
 569     }
 570
 571     /* Register the video sub-window class */
 572     wc.lpszClassName = p_event->class_video;
 573     wc.hIcon = 0;
 574     wc.hbrBackground = NULL; /* no background color */
 575     if( !RegisterClass(&wc) )
 576     {
 577         msg_Err( vd, "DirectXCreateWindow RegisterClass FAILED (err=%lu)", GetLastError() );
 578         return VLC_EGENERIC;
 579     }
 580
 581     /* When you create a window you give the dimensions you wish it to
 582      * have. Unfortunatly these dimensions will include the borders and
 583      * titlebar. We use the following function to find out the size of
 584      * the window corresponding to the useable surface we want */
 585     rect_window.left   = 10;
 586     rect_window.top    = 10;
 587     rect_window.right  = rect_window.left + p_event->wnd_cfg.width;
 588     rect_window.bottom = rect_window.top  + p_event->wnd_cfg.height;
 589
 590     if( var_GetBool( vd, "video-deco" ) )
 591     {
 592         /* Open with window decoration */
 593         AdjustWindowRect( &rect_window, WS_OVERLAPPEDWINDOW|WS_SIZEBOX, 0 );
 594         i_style = WS_OVERLAPPEDWINDOW|WS_SIZEBOX|WS_VISIBLE|WS_CLIPCHILDREN;
 595         i_stylex = 0;
 596     }
 597     else
 598     {
 599         /* No window decoration */
 600         AdjustWindowRect( &rect_window, WS_POPUP, 0 );
 601         i_style = WS_POPUP|WS_VISIBLE|WS_CLIPCHILDREN;
 602         i_stylex = 0; // WS_EX_TOOLWINDOW; Is TOOLWINDOW really needed ?
 603                       // It messes up the fullscreen window.
 604     }
 605
 606     if( p_event->hparent )
 607     {
 608         i_style = WS_VISIBLE|WS_CLIPCHILDREN|WS_CHILD;
 609         i_stylex = 0;
 610     }
 611
 612     p_event->i_window_style = i_style;
 613
 614     /* Create the window */
 615     p_event->hwnd =
 616         CreateWindowEx( WS_EX_NOPARENTNOTIFY | i_stylex,
 617                     p_event->class_main,             /* name of window class */
 618                     _T(VOUT_TITLE) _T(" (DirectX Output)"),  /* window title */
 619                     i_style,                                 /* window style */
 620                     (!p_event->wnd_cfg.x) ? CW_USEDEFAULT :
 621                         (UINT)p_event->wnd_cfg.x,   /* default X coordinate */
 622                     (!p_event->wnd_cfg.y) ? CW_USEDEFAULT :
 623                         (UINT)p_event->wnd_cfg.y,   /* default Y coordinate */
 624                     rect_window.right - rect_window.left,    /* window width */
 625                     rect_window.bottom - rect_window.top,   /* window height */
 626                     p_event->hparent,                       /* parent window */
 627                     NULL,                          /* no menu in this window */
 628                     hInstance,            /* handle of this program instance */
 629                     (LPVOID)p_event );           /* send vd to WM_CREATE */
 630
 631     if( !p_event->hwnd )
 632     {
 633         msg_Warn( vd, "DirectXCreateWindow create window FAILED (err=%lu)", GetLastError() );
 634         return VLC_EGENERIC;
 635     }
 636
 637     if( p_event->hparent )
 638     {
 639         LONG i_style;
 640
 641         /* We don't want the window owner to overwrite our client area */
 642         i_style = GetWindowLong( p_event->hparent, GWL_STYLE );
 643
 644         if( !(i_style & WS_CLIPCHILDREN) )
 645             /* Hmmm, apparently this is a blocking call... */
 646             SetWindowLong( p_event->hparent, GWL_STYLE,
 647                            i_style | WS_CLIPCHILDREN );
 648
 649         /* Create our fullscreen window */
 650         p_event->hfswnd =
 651             CreateWindowEx( WS_EX_APPWINDOW, p_event->class_main,
 652                             _T(VOUT_TITLE) _T(" (DirectX Output)"),
 653                             WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|WS_SIZEBOX,
 654                             CW_USEDEFAULT, CW_USEDEFAULT,
 655                             CW_USEDEFAULT, CW_USEDEFAULT,
 656                             NULL, NULL, hInstance, NULL );
 657     }
 658     else
 659     {
 660         p_event->hfswnd = NULL;
 661     }
 662
 663     /* Append a "Always On Top" entry in the system menu */
 664     hMenu = GetSystemMenu( p_event->hwnd, FALSE );
 665     AppendMenu( hMenu, MF_SEPARATOR, 0, _T("") );
 666     AppendMenu( hMenu, MF_STRING | MF_UNCHECKED,
 667                        IDM_TOGGLE_ON_TOP, _T("Always on &Top") );
 668
 669     /* Create video sub-window. This sub window will always exactly match
 670      * the size of the video, which allows us to use crazy overlay colorkeys
 671      * without having them shown outside of the video area. */
 672     /* FIXME vd->source.i_width/i_height seems wrong */
 673     p_event->hvideownd =
 674     CreateWindow( p_event->class_video, _T(""),   /* window class */
 675         WS_CHILD,                   /* window style, not visible initially */
 676         0, 0,
 677         vd->source.i_width,          /* default width */
 678         vd->source.i_height,        /* default height */
 679         p_event->hwnd,               /* parent window */
 680         NULL, hInstance,
 681         (LPVOID)p_event );    /* send vd to WM_CREATE */
 682
 683     if( !p_event->hvideownd )
 684         msg_Warn( vd, "can't create video sub-window" );
 685     else
 686         msg_Dbg( vd, "created video sub-window" );
 687
 688     /* Now display the window */
 689     ShowWindow( p_event->hwnd, SW_SHOW );
 690
 691     return VLC_SUCCESS;
 692 }
 693
 694 /*****************************************************************************
 695  * DirectXCloseWindow: close the window created by DirectXCreateWindow
 696  *****************************************************************************
 697  * This function returns all resources allocated by DirectXCreateWindow.
 698  *****************************************************************************/
 699 static void DirectXCloseWindow( event_thread_t *p_event )
 700 {
 701     vout_display_t *vd = p_event->vd;
 702     msg_Dbg( vd, "DirectXCloseWindow" );
 703
 704     DestroyWindow( p_event->hwnd );
 705     if( p_event->hfswnd )
 706         DestroyWindow( p_event->hfswnd );
 707
 708     #ifdef MODULE_NAME_IS_direct3d
 709     if( !p_event->use_desktop )
 710     #endif
 711         vout_display_DeleteWindow( vd, p_event->parent_window );
 712     p_event->hwnd = NULL;
 713
 714     HINSTANCE hInstance = GetModuleHandle(NULL);
 715     UnregisterClass( p_event->class_video, hInstance );
 716     UnregisterClass( p_event->class_main, hInstance );
 717
 718 #ifndef UNDER_CE
 719     DestroyCursor( p_event->cursor_empty );
 720 #endif
 721 }
 722
 723 /*****************************************************************************
 724  * DirectXEventProc: This is the window event processing function.
 725  *****************************************************************************
 726  * On Windows, when you create a window you have to attach an event processing
 727  * function to it. The aim of this function is to manage "Queued Messages" and
 728  * "Nonqueued Messages".
 729  * Queued Messages are those picked up and retransmitted by vout_Manage
 730  * (using the GetMessage and DispatchMessage functions).
 731  * Nonqueued Messages are those that Windows will send directly to this
 732  * procedure (like WM_DESTROY, WM_WINDOWPOSCHANGED...)
 733  *****************************************************************************/
 734 static long FAR PASCAL DirectXEventProc( HWND hwnd, UINT message,
 735                                          WPARAM wParam, LPARAM lParam )
 736 {
 737     event_thread_t *p_event;
 738
 739     if( message == WM_CREATE )
 740     {
 741         /* Store vd for future use */
 742         p_event = (event_thread_t *)((CREATESTRUCT *)lParam)->lpCreateParams;
 743         SetWindowLongPtr( hwnd, GWLP_USERDATA, (LONG_PTR)p_event );
 744         return TRUE;
 745     }
 746     else
 747     {
 748         LONG_PTR p_user_data = GetWindowLongPtr( hwnd, GWLP_USERDATA );
 749         p_event = (event_thread_t *)p_user_data;
 750         if( !p_event )
 751         {
 752             /* Hmmm mozilla does manage somehow to save the pointer to our
 753              * windowproc and still calls it after the vout has been closed. */
 754             return DefWindowProc(hwnd, message, wParam, lParam);
 755         }
 756     }
 757     vout_display_t *vd = p_event->vd;
 758
 759 #ifndef UNDER_CE
 760     /* Catch the screensaver and the monitor turn-off */
 761     if( message == WM_SYSCOMMAND &&
 762         ( (wParam & 0xFFF0) == SC_SCREENSAVE || (wParam & 0xFFF0) == SC_MONITORPOWER ) )
 763     {
 764         //if( vd ) msg_Dbg( vd, "WinProc WM_SYSCOMMAND screensaver" );
 765         return 0; /* this stops them from happening */
 766     }
 767 #endif
 768 #if 0
 769     if( message == WM_SETCURSOR )
 770     {
 771         msg_Err(vd, "WM_SETCURSOR: %d (t2)", p_event->is_cursor_hidden);
 772         SetCursor( p_event->is_cursor_hidden ? p_event->cursor_empty : p_event->cursor_arrow );
 773         return 1;
 774     }
 775 #endif
 776     if( message == WM_CAPTURECHANGED )
 777     {
 778         for( int button = 0; p_event->button_pressed; button++ )
 779         {
 780             unsigned m = 1 << button;
 781             if( p_event->button_pressed & m )
 782                 vout_display_SendEventMouseReleased( p_event->vd, button );
 783             p_event->button_pressed &= ~m;
 784         }
 785         p_event->button_pressed = 0;
 786         return 0;
 787     }
 788
 789     if( hwnd == p_event->hvideownd )
 790     {
 791 #ifdef MODULE_NAME_IS_directx
 792         vlc_mutex_lock( &p_event->lock );
 793         const bool use_overlay = p_event->use_overlay;
 794         vlc_mutex_unlock( &p_event->lock );
 795 #endif
 796
 797         switch( message )
 798         {
 799 #ifdef MODULE_NAME_IS_directx
 800         case WM_ERASEBKGND:
 801         /* For overlay, we need to erase background */
 802             return !use_overlay ? 1 : DefWindowProc(hwnd, message, wParam, lParam);
 803         case WM_PAINT:
 804         /*
 805         ** For overlay, DefWindowProc() will erase dirty regions
 806         ** with colorkey.
 807         ** For non-overlay, vout will paint the whole window at
 808         ** regular interval, therefore dirty regions can be ignored
 809         ** to minimize repaint.
 810         */
 811             if( !use_overlay )
 812             {
 813                 ValidateRect(hwnd, NULL);
 814             }
 815             // fall through to default
 816 #else
 817         /*
 818         ** For OpenGL and Direct3D, vout will update the whole
 819         ** window at regular interval, therefore dirty region
 820         ** can be ignored to minimize repaint.
 821         */
 822         case WM_ERASEBKGND:
 823             /* nothing to erase */
 824             return 1;
 825         case WM_PAINT:
 826             /* nothing to repaint */
 827             ValidateRect(hwnd, NULL);
 828             // fall through
 829 #endif
 830         default:
 831             return DefWindowProc(hwnd, message, wParam, lParam);
 832         }
 833     }
 834
 835     switch( message )
 836     {
 837
 838     case WM_WINDOWPOSCHANGED:
 839         vlc_mutex_lock( &p_event->lock );
 840         p_event->has_moved = true;
 841         vlc_mutex_unlock( &p_event->lock );
 842         return 0;
 843
 844     /* the user wants to close the window */
 845     case WM_CLOSE:
 846         vout_display_SendEventClose(vd);
 847         return 0;
 848
 849     /* the window has been closed so shut down everything now */
 850     case WM_DESTROY:
 851         msg_Dbg( vd, "WinProc WM_DESTROY" );
 852         /* just destroy the window */
 853         PostQuitMessage( 0 );
 854         return 0;
 855
 856     case WM_SYSCOMMAND:
 857         switch (wParam)
 858         {
 859         case IDM_TOGGLE_ON_TOP:            /* toggle the "on top" status */
 860         {
 861             msg_Dbg(vd, "WinProc WM_SYSCOMMAND: IDM_TOGGLE_ON_TOP");
 862             HMENU hMenu = GetSystemMenu(vd->sys->hwnd, FALSE);
 863             vout_display_SendWindowState(vd, (GetMenuState(hMenu, IDM_TOGGLE_ON_TOP, MF_BYCOMMAND) & MF_CHECKED) ?
 864                     VOUT_WINDOW_STATE_NORMAL : VOUT_WINDOW_STATE_ABOVE);
 865             return 0;
 866         }
 867         default:
 868             break;
 869         }
 870         break;
 871
 872     case WM_PAINT:
 873     case WM_NCPAINT:
 874     case WM_ERASEBKGND:
 875         return DefWindowProc(hwnd, message, wParam, lParam);
 876
 877     case WM_KILLFOCUS:
 878 #ifdef MODULE_NAME_IS_wingapi
 879         GXSuspend();
 880 #endif
 881 #ifdef UNDER_CE
 882         if( hwnd == p_event->hfswnd )
 883         {
 884             HWND htbar = FindWindow( _T("HHTaskbar"), NULL );
 885             ShowWindow( htbar, SW_SHOW );
 886         }
 887
 888         if( !p_event->hparent ||
 889             hwnd == p_event->hfswnd )
 890         {
 891             SHFullScreen( hwnd, SHFS_SHOWSIPBUTTON );
 892         }
 893 #endif
 894         return 0;
 895
 896     case WM_SETFOCUS:
 897 #ifdef MODULE_NAME_IS_wingapi
 898         GXResume();
 899 #endif
 900 #ifdef UNDER_CE
 901         /* FIXME vd->cfg is not lock[ed/able] */
 902 #warning "FIXME: race condition"
 903         if( p_event->hparent &&
 904             hwnd != p_event->hfswnd && vd->cfg->is_fullscreen )
 905             vout_display_SendEventFullscreen(vd, false);
 906
 907         if( hwnd == p_event->hfswnd )
 908         {
 909             HWND htbar = FindWindow( _T("HHTaskbar"), NULL );
 910             ShowWindow( htbar, SW_HIDE );
 911         }
 912
 913         if( !p_event->hparent ||
 914             hwnd == p_event->hfswnd )
 915         {
 916             SHFullScreen( hwnd, SHFS_HIDESIPBUTTON );
 917         }
 918 #endif
 919         return 0;
 920
 921     default:
 922         //msg_Dbg( vd, "WinProc WM Default %i", message );
 923         break;
 924     }
 925
 926     /* Let windows handle the message */
 927     return DefWindowProc(hwnd, message, wParam, lParam);
 928 }
 929
 930 static struct
 931 {
 932     int i_dxkey;
 933     int i_vlckey;
 934
 935 } dxkeys_to_vlckeys[] =
 936 {
 937     { VK_F1, KEY_F1 }, { VK_F2, KEY_F2 }, { VK_F3, KEY_F3 }, { VK_F4, KEY_F4 },
 938     { VK_F5, KEY_F5 }, { VK_F6, KEY_F6 }, { VK_F7, KEY_F7 }, { VK_F8, KEY_F8 },
 939     { VK_F9, KEY_F9 }, { VK_F10, KEY_F10 }, { VK_F11, KEY_F11 },
 940     { VK_F12, KEY_F12 },
 941
 942     { VK_RETURN, KEY_ENTER },
 943     { VK_SPACE, ' ' },
 944     { VK_ESCAPE, KEY_ESC },
 945
 946     { VK_LEFT, KEY_LEFT },
 947     { VK_RIGHT, KEY_RIGHT },
 948     { VK_UP, KEY_UP },
 949     { VK_DOWN, KEY_DOWN },
 950
 951     { VK_HOME, KEY_HOME },
 952     { VK_END, KEY_END },
 953     { VK_PRIOR, KEY_PAGEUP },
 954     { VK_NEXT, KEY_PAGEDOWN },
 955
 956     { VK_INSERT, KEY_INSERT },
 957     { VK_DELETE, KEY_DELETE },
 958
 959     { VK_CONTROL, 0 },
 960     { VK_SHIFT, 0 },
 961     { VK_MENU, 0 },
 962
 963     { VK_BROWSER_BACK, KEY_BROWSER_BACK },
 964     { VK_BROWSER_FORWARD, KEY_BROWSER_FORWARD },
 965     { VK_BROWSER_REFRESH, KEY_BROWSER_REFRESH },
 966     { VK_BROWSER_STOP, KEY_BROWSER_STOP },
 967     { VK_BROWSER_SEARCH, KEY_BROWSER_SEARCH },
 968     { VK_BROWSER_FAVORITES, KEY_BROWSER_FAVORITES },
 969     { VK_BROWSER_HOME, KEY_BROWSER_HOME },
 970     { VK_VOLUME_MUTE, KEY_VOLUME_MUTE },
 971     { VK_VOLUME_DOWN, KEY_VOLUME_DOWN },
 972     { VK_VOLUME_UP, KEY_VOLUME_UP },
 973     { VK_MEDIA_NEXT_TRACK, KEY_MEDIA_NEXT_TRACK },
 974     { VK_MEDIA_PREV_TRACK, KEY_MEDIA_PREV_TRACK },
 975     { VK_MEDIA_STOP, KEY_MEDIA_STOP },
 976     { VK_MEDIA_PLAY_PAUSE, KEY_MEDIA_PLAY_PAUSE },
 977
 978     { 0, 0 }
 979 };
 980
 981 static int DirectXConvertKey( int i_key )
 982 {
 983     int i;
 984
 985     for( i = 0; dxkeys_to_vlckeys[i].i_dxkey != 0; i++ )
 986     {
 987         if( dxkeys_to_vlckeys[i].i_dxkey == i_key )
 988         {
 989             return dxkeys_to_vlckeys[i].i_vlckey;
 990         }
 991     }
 992
 993     return 0;
 994 }
 995
 996 void EventThreadMouseHide( event_thread_t *p_event )
 997 {
 998     PostMessage( p_event->hwnd, WM_VLC_HIDE_MOUSE, 0, 0 );
 999 }
1000
1001 void EventThreadUpdateTitle( event_thread_t *p_event, const char *psz_fallback )
1002 {
1003     char *psz_title = var_GetNonEmptyString( p_event->vd, "video-title" );
1004     if( !psz_title )
1005         psz_title = strdup( psz_fallback );
1006     if( !psz_title )
1007         return;
1008
1009     vlc_mutex_lock( &p_event->lock );
1010     free( p_event->psz_title );
1011     p_event->psz_title = psz_title;
1012     vlc_mutex_unlock( &p_event->lock );
1013
1014     PostMessage( p_event->hwnd, WM_VLC_CHANGE_TEXT, 0, 0 );
1015 }
1016 int EventThreadGetWindowStyle( event_thread_t *p_event )
1017 {
1018     /* No need to lock, it is serialized by EventThreadStart */
1019     return p_event->i_window_style;
1020 }
1021
1022 void EventThreadUpdateWindowPosition( event_thread_t *p_event,
1023                                       bool *pb_moved, bool *pb_resized,
1024                                       int x, int y, int w, int h )
1025 {
1026     vlc_mutex_lock( &p_event->lock );
1027     *pb_moved   = x != p_event->wnd_cfg.x ||
1028                   y != p_event->wnd_cfg.y;
1029     *pb_resized = w != p_event->wnd_cfg.width ||
1030                   h != p_event->wnd_cfg.height;
1031
1032     p_event->wnd_cfg.x      = x;
1033     p_event->wnd_cfg.y      = y;
1034     p_event->wnd_cfg.width  = w;
1035     p_event->wnd_cfg.height = h;
1036     vlc_mutex_unlock( &p_event->lock );
1037 }
1038
1039 void EventThreadUpdateSourceAndPlace( event_thread_t *p_event,
1040                                       const video_format_t *p_source,
1041                                       const vout_display_place_t *p_place )
1042 {
1043     vlc_mutex_lock( &p_event->lock );
1044     p_event->source = *p_source;
1045     p_event->place  = *p_place;
1046     vlc_mutex_unlock( &p_event->lock );
1047 }
1048
1049 void EventThreadUseOverlay( event_thread_t *p_event, bool b_used )
1050 {
1051     vlc_mutex_lock( &p_event->lock );
1052     p_event->use_overlay = b_used;
1053     vlc_mutex_unlock( &p_event->lock );
1054 }
1055 bool EventThreadGetAndResetHasMoved( event_thread_t *p_event )
1056 {
1057     vlc_mutex_lock( &p_event->lock );
1058     const bool has_moved = p_event->has_moved;
1059     p_event->has_moved = false;
1060     vlc_mutex_unlock( &p_event->lock );
1061
1062     return has_moved;
1063 }
1064
1065 event_thread_t *EventThreadCreate( vout_display_t *vd)
1066 {
1067      /* Create the Vout EventThread, this thread is created by us to isolate
1068      * the Win32 PeekMessage function calls. We want to do this because
1069      * Windows can stay blocked inside this call for a long time, and when
1070      * this happens it thus blocks vlc's video_output thread.
1071      * Vout EventThread will take care of the creation of the video
1072      * window (because PeekMessage has to be called from the same thread which
1073      * created the window). */
1074     msg_Dbg( vd, "creating Vout EventThread" );
1075     event_thread_t *p_event = malloc( sizeof(*p_event) );
1076     if( !p_event )
1077         return NULL;
1078
1079     p_event->vd = vd;
1080     vlc_mutex_init( &p_event->lock );
1081     vlc_cond_init( &p_event->wait );
1082
1083     p_event->is_cursor_hidden = false;
1084     p_event->button_pressed = 0;
1085     p_event->psz_title = NULL;
1086     p_event->source = vd->source;
1087     vout_display_PlacePicture(&p_event->place, &vd->source, vd->cfg, false);
1088
1089     _snprintf( p_event->class_main, sizeof(p_event->class_main)/sizeof(*p_event->class_main),
1090                _T("VLC MSW %p"), p_event );
1091     _snprintf( p_event->class_video, sizeof(p_event->class_video)/sizeof(*p_event->class_video),
1092                _T("VLC MSW video %p"), p_event );
1093     return p_event;
1094 }
1095
1096 void EventThreadDestroy( event_thread_t *p_event )
1097 {
1098     free( p_event->psz_title );
1099     vlc_cond_destroy( &p_event->wait );
1100     vlc_mutex_destroy( &p_event->lock );
1101     free( p_event );
1102 }
1103
1104 int EventThreadStart( event_thread_t *p_event, event_hwnd_t *p_hwnd, const event_cfg_t *p_cfg )
1105 {
1106     p_event->use_desktop = p_cfg->use_desktop;
1107     p_event->use_overlay = p_cfg->use_overlay;
1108     p_event->wnd_cfg     = p_cfg->win;
1109
1110     p_event->has_moved = false;
1111
1112     p_event->b_ready = false;
1113     p_event->b_done  = false;
1114     p_event->b_error = false;
1115
1116     if( vlc_clone( &p_event->thread, EventThread, p_event,
1117                    VLC_THREAD_PRIORITY_LOW ) )
1118     {
1119         msg_Err( p_event->vd, "cannot create Vout EventThread" );
1120         return VLC_EGENERIC;
1121     }
1122
1123     vlc_mutex_lock( &p_event->lock );
1124     while( !p_event->b_ready )
1125         vlc_cond_wait( &p_event->wait, &p_event->lock );
1126     const bool b_error = p_event->b_error;
1127     vlc_mutex_unlock( &p_event->lock );
1128
1129     if( b_error )
1130     {
1131         vlc_join( p_event->thread, NULL );
1132         p_event->b_ready = false;
1133         return VLC_EGENERIC;
1134     }
1135     msg_Dbg( p_event->vd, "Vout EventThread running" );
1136
1137     /* */
1138     p_hwnd->parent_window = p_event->parent_window;
1139     p_hwnd->hparent       = p_event->hparent;
1140     p_hwnd->hwnd          = p_event->hwnd;
1141     p_hwnd->hvideownd     = p_event->hvideownd;
1142     p_hwnd->hfswnd        = p_event->hfswnd;
1143     return VLC_SUCCESS;
1144 }
1145
1146 void EventThreadStop( event_thread_t *p_event )
1147 {
1148     if( !p_event->b_ready )
1149         return;
1150
1151     vlc_mutex_lock( &p_event->lock );
1152     p_event->b_done = true;
1153     vlc_mutex_unlock( &p_event->lock );
1154
1155     /* we need to be sure Vout EventThread won't stay stuck in
1156      * GetMessage, so we send a fake message */
1157     if( p_event->hwnd )
1158         PostMessage( p_event->hwnd, WM_NULL, 0, 0);
1159
1160     vlc_join( p_event->thread, NULL );
1161     p_event->b_ready = false;
1162 }
1163