dlls/dinput/dinput_main.c

   1 /*              DirectInput
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  * Copyright 2000-2002 TransGaming Technologies Inc.
   6  * Copyright 2007 Vitaliy Margolen
   7  *
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library 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 GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23 /* Status:
  24  *
  25  * - Tomb Raider 2 Demo:
  26  *   Playable using keyboard only.
  27  * - WingCommander Prophecy Demo:
  28  *   Doesn't get Input Focus.
  29  *
  30  * - Fallout : works great in X and DGA mode
  31  */
  32
  33 #include <assert.h>
  34 #include <stdarg.h>
  35 #include <string.h>
  36
  37 #define COBJMACROS
  38 #define NONAMELESSUNION
  39
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "winuser.h"
  43 #include "winerror.h"
  44 #include "objbase.h"
  45 #include "rpcproxy.h"
  46 #include "devguid.h"
  47 #include "initguid.h"
  48 #include "dinputd.h"
  49
  50 #include "dinput_private.h"
  51 #include "device_private.h"
  52
  53 #include "wine/asm.h"
  54 #include "wine/debug.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  57
  58 static const IDirectInput7WVtbl dinput7_vtbl;
  59 static const IDirectInput8WVtbl dinput8_vtbl;
  60 static const IDirectInputJoyConfig8Vtbl joy_config_vtbl;
  61
  62 static inline struct dinput *impl_from_IDirectInput7W( IDirectInput7W *iface )
  63 {
  64     return CONTAINING_RECORD( iface, struct dinput, IDirectInput7W_iface );
  65 }
  66
  67 static inline struct dinput *impl_from_IDirectInput8W( IDirectInput8W *iface )
  68 {
  69     return CONTAINING_RECORD( iface, struct dinput, IDirectInput8W_iface );
  70 }
  71
  72 static inline struct dinput_device *impl_from_IDirectInputDevice8W( IDirectInputDevice8W *iface )
  73 {
  74     return CONTAINING_RECORD( iface, struct dinput_device, IDirectInputDevice8W_iface );
  75 }
  76
  77 HINSTANCE DINPUT_instance;
  78
  79 static HWND di_em_win;
  80
  81 static HANDLE dinput_thread;
  82 static DWORD dinput_thread_id;
  83
  84 static CRITICAL_SECTION dinput_hook_crit;
  85 static CRITICAL_SECTION_DEBUG dinput_critsect_debug =
  86 {
  87     0, 0, &dinput_hook_crit,
  88     { &dinput_critsect_debug.ProcessLocksList, &dinput_critsect_debug.ProcessLocksList },
  89       0, 0, { (DWORD_PTR)(__FILE__ ": dinput_hook_crit") }
  90 };
  91 static CRITICAL_SECTION dinput_hook_crit = { &dinput_critsect_debug, -1, 0, 0, 0, 0 };
  92
  93 static struct list acquired_mouse_list = LIST_INIT( acquired_mouse_list );
  94 static struct list acquired_rawmouse_list = LIST_INIT( acquired_rawmouse_list );
  95 static struct list acquired_keyboard_list = LIST_INIT( acquired_keyboard_list );
  96 static struct list acquired_device_list = LIST_INIT( acquired_device_list );
  97
  98 static HRESULT initialize_directinput_instance( struct dinput *impl, DWORD version );
  99 static void uninitialize_directinput_instance( struct dinput *impl );
 100
 101 void dinput_hooks_acquire_device( IDirectInputDevice8W *iface )
 102 {
 103     struct dinput_device *impl = impl_from_IDirectInputDevice8W( iface );
 104
 105     EnterCriticalSection( &dinput_hook_crit );
 106     if (IsEqualGUID( &impl->guid, &GUID_SysMouse ))
 107         list_add_tail( impl->use_raw_input ? &acquired_rawmouse_list : &acquired_mouse_list, &impl->entry );
 108     else if (IsEqualGUID( &impl->guid, &GUID_SysKeyboard ))
 109         list_add_tail( &acquired_keyboard_list, &impl->entry );
 110     else
 111         list_add_tail( &acquired_device_list, &impl->entry );
 112     LeaveCriticalSection( &dinput_hook_crit );
 113 }
 114
 115 void dinput_hooks_unacquire_device( IDirectInputDevice8W *iface )
 116 {
 117     struct dinput_device *impl = impl_from_IDirectInputDevice8W( iface );
 118
 119     EnterCriticalSection( &dinput_hook_crit );
 120     list_remove( &impl->entry );
 121     LeaveCriticalSection( &dinput_hook_crit );
 122 }
 123
 124 static void dinput_device_internal_unacquire( IDirectInputDevice8W *iface )
 125 {
 126     struct dinput_device *impl = impl_from_IDirectInputDevice8W( iface );
 127
 128     TRACE( "iface %p.\n", iface );
 129
 130     EnterCriticalSection( &impl->crit );
 131     if (impl->status == STATUS_ACQUIRED)
 132     {
 133         impl->vtbl->unacquire( iface );
 134         impl->status = STATUS_UNACQUIRED;
 135         list_remove( &impl->entry );
 136     }
 137     LeaveCriticalSection( &impl->crit );
 138 }
 139
 140 static HRESULT dinput_create( IUnknown **out )
 141 {
 142     struct dinput *impl;
 143
 144     if (!(impl = calloc( 1, sizeof(struct dinput) ))) return E_OUTOFMEMORY;
 145     impl->IDirectInput7A_iface.lpVtbl = &dinput7_a_vtbl;
 146     impl->IDirectInput7W_iface.lpVtbl = &dinput7_vtbl;
 147     impl->IDirectInput8A_iface.lpVtbl = &dinput8_a_vtbl;
 148     impl->IDirectInput8W_iface.lpVtbl = &dinput8_vtbl;
 149     impl->IDirectInputJoyConfig8_iface.lpVtbl = &joy_config_vtbl;
 150     impl->ref = 1;
 151
 152 #if DIRECTINPUT_VERSION == 0x0700
 153     *out = (IUnknown *)&impl->IDirectInput7W_iface;
 154 #else
 155     *out = (IUnknown *)&impl->IDirectInput8W_iface;
 156 #endif
 157     return DI_OK;
 158 }
 159
 160 /******************************************************************************
 161  *      DirectInputCreateEx (DINPUT.@)
 162  */
 163 HRESULT WINAPI DirectInputCreateEx( HINSTANCE hinst, DWORD version, REFIID iid, void **out, IUnknown *outer )
 164 {
 165     IUnknown *unknown;
 166     HRESULT hr;
 167
 168     TRACE( "hinst %p, version %#lx, iid %s, out %p, outer %p.\n", hinst, version, debugstr_guid( iid ), out, outer );
 169
 170     if (!IsEqualGUID( &IID_IDirectInputA, iid ) &&
 171         !IsEqualGUID( &IID_IDirectInputW, iid ) &&
 172         !IsEqualGUID( &IID_IDirectInput2A, iid ) &&
 173         !IsEqualGUID( &IID_IDirectInput2W, iid ) &&
 174         !IsEqualGUID( &IID_IDirectInput7A, iid ) &&
 175         !IsEqualGUID( &IID_IDirectInput7W, iid ))
 176         return DIERR_NOINTERFACE;
 177
 178     if (FAILED(hr = dinput_create( &unknown ))) return hr;
 179     hr = IUnknown_QueryInterface( unknown, iid, out );
 180     IUnknown_Release( unknown );
 181     if (FAILED(hr)) return hr;
 182
 183     if (outer || FAILED(hr = IDirectInput7_Initialize( (IDirectInput7W *)unknown, hinst, version )))
 184     {
 185         IUnknown_Release( unknown );
 186         *out = NULL;
 187         return hr;
 188     }
 189
 190     return DI_OK;
 191 }
 192
 193 /******************************************************************************
 194  *      DirectInput8Create (DINPUT8.@)
 195  */
 196 HRESULT WINAPI DECLSPEC_HOTPATCH DirectInput8Create( HINSTANCE hinst, DWORD version, REFIID iid, void **out, IUnknown *outer )
 197 {
 198     IUnknown *unknown;
 199     HRESULT hr;
 200
 201     TRACE( "hinst %p, version %#lx, iid %s, out %p, outer %p.\n", hinst, version, debugstr_guid( iid ), out, outer );
 202
 203     if (!out) return E_POINTER;
 204
 205     if (!IsEqualGUID( &IID_IDirectInput8A, iid ) &&
 206         !IsEqualGUID( &IID_IDirectInput8W, iid ) &&
 207         !IsEqualGUID( &IID_IUnknown, iid ))
 208     {
 209         *out = NULL;
 210         return DIERR_NOINTERFACE;
 211     }
 212
 213     if (FAILED(hr = dinput_create( &unknown ))) return hr;
 214     hr = IUnknown_QueryInterface( unknown, iid, out );
 215     IUnknown_Release( unknown );
 216     if (FAILED(hr)) return hr;
 217
 218     if (outer || FAILED(hr = IDirectInput8_Initialize( (IDirectInput8W *)unknown, hinst, version )))
 219     {
 220         IUnknown_Release( (IUnknown *)unknown );
 221         *out = NULL;
 222         return hr;
 223     }
 224
 225     return S_OK;
 226 }
 227
 228 /******************************************************************************
 229  *      DirectInputCreateA (DINPUT.@)
 230  */
 231 HRESULT WINAPI DECLSPEC_HOTPATCH DirectInputCreateA( HINSTANCE hinst, DWORD version, IDirectInputA **out, IUnknown *outer )
 232 {
 233     return DirectInputCreateEx( hinst, version, &IID_IDirectInput7A, (void **)out, outer );
 234 }
 235
 236 /******************************************************************************
 237  *      DirectInputCreateW (DINPUT.@)
 238  */
 239 HRESULT WINAPI DECLSPEC_HOTPATCH DirectInputCreateW( HINSTANCE hinst, DWORD version, IDirectInputW **out, IUnknown *outer )
 240 {
 241     return DirectInputCreateEx( hinst, version, &IID_IDirectInput7W, (void **)out, outer );
 242 }
 243
 244 static DWORD diactionformat_priorityW( DIACTIONFORMATW *action_format, DWORD genre )
 245 {
 246     int i;
 247     DWORD priorityFlags = 0;
 248
 249     /* If there's at least one action for the device it's priority 1 */
 250     for (i = 0; i < action_format->dwNumActions; i++)
 251         if ((action_format->rgoAction[i].dwSemantic & genre) == genre)
 252             priorityFlags |= DIEDBS_MAPPEDPRI1;
 253
 254     return priorityFlags;
 255 }
 256
 257 #if defined __i386__ && defined _MSC_VER
 258 __declspec(naked) BOOL enum_callback_wrapper(void *callback, const void *instance, void *ref)
 259 {
 260     __asm
 261     {
 262         push ebp
 263         mov ebp, esp
 264         push [ebp+16]
 265         push [ebp+12]
 266         call [ebp+8]
 267         leave
 268         ret
 269     }
 270 }
 271 #elif defined __i386__ && defined __GNUC__
 272 extern BOOL enum_callback_wrapper(void *callback, const void *instance, void *ref);
 273 __ASM_GLOBAL_FUNC( enum_callback_wrapper,
 274     "pushl %ebp\n\t"
 275     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 276     __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 277     "movl %esp,%ebp\n\t"
 278     __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 279     "pushl 16(%ebp)\n\t"
 280     "pushl 12(%ebp)\n\t"
 281     "call *8(%ebp)\n\t"
 282     "leave\n\t"
 283     __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 284     __ASM_CFI(".cfi_same_value %ebp\n\t")
 285     "ret" )
 286 #else
 287 #define enum_callback_wrapper(callback, instance, ref) (callback)((instance), (ref))
 288 #endif
 289
 290 /******************************************************************************
 291  *      IDirectInputW_EnumDevices
 292  */
 293 static HRESULT WINAPI dinput7_EnumDevices( IDirectInput7W *iface, DWORD type, LPDIENUMDEVICESCALLBACKW callback,
 294                                            void *context, DWORD flags )
 295 {
 296     struct dinput *impl = impl_from_IDirectInput7W( iface );
 297
 298     TRACE( "iface %p, type %#lx, callback %p, context %p, flags %#lx.\n", iface, type, callback, context, flags );
 299
 300     if (!callback) return DIERR_INVALIDPARAM;
 301
 302     if (type > DIDEVTYPE_JOYSTICK) return DIERR_INVALIDPARAM;
 303     if (flags & ~(DIEDFL_ATTACHEDONLY | DIEDFL_FORCEFEEDBACK | DIEDFL_INCLUDEALIASES | DIEDFL_INCLUDEPHANTOMS))
 304         return DIERR_INVALIDPARAM;
 305
 306     return IDirectInput8_EnumDevices( &impl->IDirectInput8W_iface, type, callback, context, flags );
 307 }
 308
 309 static ULONG WINAPI dinput7_AddRef( IDirectInput7W *iface )
 310 {
 311     struct dinput *impl = impl_from_IDirectInput7W( iface );
 312     ULONG ref = InterlockedIncrement( &impl->ref );
 313     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 314     return ref;
 315 }
 316
 317 static ULONG WINAPI dinput7_Release( IDirectInput7W *iface )
 318 {
 319     struct dinput *impl = impl_from_IDirectInput7W( iface );
 320     ULONG ref = InterlockedDecrement( &impl->ref );
 321
 322     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 323
 324     if (ref == 0)
 325     {
 326         uninitialize_directinput_instance( impl );
 327         free( impl );
 328     }
 329
 330     return ref;
 331 }
 332
 333 static HRESULT WINAPI dinput7_QueryInterface( IDirectInput7W *iface, REFIID iid, void **out )
 334 {
 335     struct dinput *impl = impl_from_IDirectInput7W( iface );
 336
 337     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 338
 339     if (!iid || !out) return E_POINTER;
 340
 341     *out = NULL;
 342
 343 #if DIRECTINPUT_VERSION == 0x0700
 344     if (IsEqualGUID( &IID_IDirectInputA, iid ) ||
 345         IsEqualGUID( &IID_IDirectInput2A, iid ) ||
 346         IsEqualGUID( &IID_IDirectInput7A, iid ))
 347         *out = &impl->IDirectInput7A_iface;
 348     else if (IsEqualGUID( &IID_IUnknown, iid ) ||
 349              IsEqualGUID( &IID_IDirectInputW, iid ) ||
 350              IsEqualGUID( &IID_IDirectInput2W, iid ) ||
 351              IsEqualGUID( &IID_IDirectInput7W, iid ))
 352         *out = &impl->IDirectInput7W_iface;
 353
 354 #else
 355     if (IsEqualGUID( &IID_IDirectInput8A, iid ))
 356         *out = &impl->IDirectInput8A_iface;
 357     else if (IsEqualGUID( &IID_IUnknown, iid ) ||
 358              IsEqualGUID( &IID_IDirectInput8W, iid ))
 359         *out = &impl->IDirectInput8W_iface;
 360
 361 #endif
 362
 363     if (IsEqualGUID( &IID_IDirectInputJoyConfig8, iid ))
 364         *out = &impl->IDirectInputJoyConfig8_iface;
 365
 366     if (*out)
 367     {
 368         IUnknown_AddRef( (IUnknown *)*out );
 369         return DI_OK;
 370     }
 371
 372     WARN( "Unsupported interface: %s\n", debugstr_guid( iid ) );
 373     return E_NOINTERFACE;
 374 }
 375
 376 static LRESULT WINAPI di_em_win_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 377 {
 378     struct dinput_device *impl;
 379     RAWINPUT ri;
 380     UINT size = sizeof(ri);
 381     int rim = GET_RAWINPUT_CODE_WPARAM( wparam );
 382
 383     TRACE( "%p %d %Ix %Ix\n", hwnd, msg, wparam, lparam );
 384
 385     if (msg == WM_INPUT && (rim == RIM_INPUT || rim == RIM_INPUTSINK))
 386     {
 387         size = GetRawInputData( (HRAWINPUT)lparam, RID_INPUT, &ri, &size, sizeof(RAWINPUTHEADER) );
 388         if (size == (UINT)-1 || size < sizeof(RAWINPUTHEADER))
 389             WARN( "Unable to read raw input data\n" );
 390         else if (ri.header.dwType == RIM_TYPEMOUSE)
 391         {
 392             EnterCriticalSection( &dinput_hook_crit );
 393             LIST_FOR_EACH_ENTRY( impl, &acquired_rawmouse_list, struct dinput_device, entry )
 394                 dinput_mouse_rawinput_hook( &impl->IDirectInputDevice8W_iface, wparam, lparam, &ri );
 395             LeaveCriticalSection( &dinput_hook_crit );
 396         }
 397     }
 398
 399     return DefWindowProcW( hwnd, msg, wparam, lparam );
 400 }
 401
 402 static void register_di_em_win_class(void)
 403 {
 404     WNDCLASSEXW class;
 405
 406     memset(&class, 0, sizeof(class));
 407     class.cbSize = sizeof(class);
 408     class.lpfnWndProc = di_em_win_wndproc;
 409     class.hInstance = DINPUT_instance;
 410     class.lpszClassName = L"DIEmWin";
 411
 412     if (!RegisterClassExW( &class ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
 413         WARN( "Unable to register message window class\n" );
 414 }
 415
 416 static void unregister_di_em_win_class(void)
 417 {
 418     if (!UnregisterClassW( L"DIEmWin", NULL ) && GetLastError() != ERROR_CLASS_DOES_NOT_EXIST)
 419         WARN( "Unable to unregister message window class\n" );
 420 }
 421
 422 static HRESULT initialize_directinput_instance( struct dinput *impl, DWORD version )
 423 {
 424     if (!impl->initialized)
 425     {
 426         impl->dwVersion = version;
 427         impl->evsequence = 1;
 428
 429         list_init( &impl->device_players );
 430
 431         impl->initialized = TRUE;
 432     }
 433
 434     return DI_OK;
 435 }
 436
 437 static void uninitialize_directinput_instance( struct dinput *impl )
 438 {
 439     if (impl->initialized)
 440     {
 441         struct DevicePlayer *device_player, *device_player2;
 442
 443         LIST_FOR_EACH_ENTRY_SAFE ( device_player, device_player2, &impl->device_players, struct DevicePlayer, entry )
 444             free( device_player );
 445
 446         impl->initialized = FALSE;
 447     }
 448 }
 449
 450 enum directinput_versions
 451 {
 452     DIRECTINPUT_VERSION_300 = 0x0300,
 453     DIRECTINPUT_VERSION_500 = 0x0500,
 454     DIRECTINPUT_VERSION_50A = 0x050A,
 455     DIRECTINPUT_VERSION_5B2 = 0x05B2,
 456     DIRECTINPUT_VERSION_602 = 0x0602,
 457     DIRECTINPUT_VERSION_61A = 0x061A,
 458     DIRECTINPUT_VERSION_700 = 0x0700,
 459 };
 460
 461 static HRESULT WINAPI dinput7_Initialize( IDirectInput7W *iface, HINSTANCE hinst, DWORD version )
 462 {
 463     struct dinput *impl = impl_from_IDirectInput7W( iface );
 464
 465     TRACE( "iface %p, hinst %p, version %#lx.\n", iface, hinst, version );
 466
 467     if (!hinst)
 468         return DIERR_INVALIDPARAM;
 469     else if (version == 0)
 470         return DIERR_NOTINITIALIZED;
 471     else if (version > DIRECTINPUT_VERSION_700)
 472         return DIERR_OLDDIRECTINPUTVERSION;
 473     else if (version != DIRECTINPUT_VERSION_300 && version != DIRECTINPUT_VERSION_500 &&
 474              version != DIRECTINPUT_VERSION_50A && version != DIRECTINPUT_VERSION_5B2 &&
 475              version != DIRECTINPUT_VERSION_602 && version != DIRECTINPUT_VERSION_61A &&
 476              version != DIRECTINPUT_VERSION_700 && version != DIRECTINPUT_VERSION)
 477         return DIERR_BETADIRECTINPUTVERSION;
 478
 479     return initialize_directinput_instance( impl, version );
 480 }
 481
 482 static HRESULT WINAPI dinput7_GetDeviceStatus( IDirectInput7W *iface, const GUID *guid )
 483 {
 484     struct dinput *impl = impl_from_IDirectInput7W( iface );
 485     HRESULT hr;
 486     IDirectInputDeviceW *device;
 487
 488     TRACE( "iface %p, guid %s.\n", iface, debugstr_guid( guid ) );
 489
 490     if (!guid) return E_POINTER;
 491     if (!impl->initialized) return DIERR_NOTINITIALIZED;
 492
 493     hr = IDirectInput_CreateDevice( iface, guid, &device, NULL );
 494     if (hr != DI_OK) return DI_NOTATTACHED;
 495
 496     IUnknown_Release( device );
 497
 498     return DI_OK;
 499 }
 500
 501 static HRESULT WINAPI dinput7_RunControlPanel( IDirectInput7W *iface, HWND owner, DWORD flags )
 502 {
 503     struct dinput *impl = impl_from_IDirectInput7W( iface );
 504     WCHAR control_exe[] = {L"control.exe"};
 505     STARTUPINFOW si = {0};
 506     PROCESS_INFORMATION pi;
 507
 508     TRACE( "iface %p, owner %p, flags %#lx.\n", iface, owner, flags );
 509
 510     if (owner && !IsWindow( owner )) return E_HANDLE;
 511     if (flags) return DIERR_INVALIDPARAM;
 512     if (!impl->initialized) return DIERR_NOTINITIALIZED;
 513
 514     if (!CreateProcessW( NULL, control_exe, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi ))
 515         return HRESULT_FROM_WIN32(GetLastError());
 516
 517     return DI_OK;
 518 }
 519
 520 static HRESULT WINAPI dinput7_FindDevice( IDirectInput7W *iface, const GUID *guid, const WCHAR *name, GUID *instance_guid )
 521 {
 522     FIXME( "iface %p, guid %s, name %s, instance_guid %s stub!\n", iface, debugstr_guid( guid ),
 523            debugstr_w(name), debugstr_guid( instance_guid ) );
 524     return DI_OK;
 525 }
 526
 527 static HRESULT WINAPI dinput7_CreateDeviceEx( IDirectInput7W *iface, const GUID *guid,
 528                                               REFIID iid, void **out, IUnknown *outer )
 529 {
 530     struct dinput *impl = impl_from_IDirectInput7W( iface );
 531     IDirectInputDevice8W *device;
 532     HRESULT hr;
 533
 534     TRACE( "iface %p, guid %s, iid %s, out %p, outer %p.\n", iface, debugstr_guid( guid ),
 535            debugstr_guid( iid ), out, outer );
 536
 537     if (!out) return E_POINTER;
 538     *out = NULL;
 539
 540     if (!guid) return E_POINTER;
 541     if (!impl->initialized) return DIERR_NOTINITIALIZED;
 542
 543     if (IsEqualGUID( &GUID_SysKeyboard, guid )) hr = keyboard_create_device( impl, guid, &device );
 544     else if (IsEqualGUID( &GUID_SysMouse, guid )) hr = mouse_create_device( impl, guid, &device );
 545     else hr = hid_joystick_create_device( impl, guid, &device );
 546
 547     if (FAILED(hr)) return hr;
 548
 549     if (FAILED(hr = dinput_device_init_device_format( device )))
 550     {
 551         IDirectInputDevice8_Release( device );
 552         return hr;
 553     }
 554
 555     hr = IDirectInputDevice8_QueryInterface( device, iid, out );
 556     IDirectInputDevice8_Release( device );
 557     return hr;
 558 }
 559
 560 static HRESULT WINAPI dinput7_CreateDevice( IDirectInput7W *iface, const GUID *guid,
 561                                             IDirectInputDeviceW **out, IUnknown *outer )
 562 {
 563     return IDirectInput7_CreateDeviceEx( iface, guid, &IID_IDirectInputDeviceW, (void **)out, outer );
 564 }
 565
 566 /*******************************************************************************
 567  *      DirectInput8
 568  */
 569
 570 static ULONG WINAPI dinput8_AddRef( IDirectInput8W *iface )
 571 {
 572     struct dinput *impl = impl_from_IDirectInput8W( iface );
 573     return IDirectInput7_AddRef( &impl->IDirectInput7W_iface );
 574 }
 575
 576 static HRESULT WINAPI dinput8_QueryInterface( IDirectInput8W *iface, REFIID iid, void **out )
 577 {
 578     struct dinput *impl = impl_from_IDirectInput8W( iface );
 579     return IDirectInput7_QueryInterface( &impl->IDirectInput7W_iface, iid, out );
 580 }
 581
 582 static ULONG WINAPI dinput8_Release( IDirectInput8W *iface )
 583 {
 584     struct dinput *impl = impl_from_IDirectInput8W( iface );
 585     return IDirectInput7_Release( &impl->IDirectInput7W_iface );
 586 }
 587
 588 static HRESULT WINAPI dinput8_CreateDevice( IDirectInput8W *iface, const GUID *guid,
 589                                             IDirectInputDevice8W **out, IUnknown *outer )
 590 {
 591     struct dinput *impl = impl_from_IDirectInput8W( iface );
 592     return IDirectInput7_CreateDeviceEx( &impl->IDirectInput7W_iface, guid,
 593                                          &IID_IDirectInputDevice8W, (void **)out, outer );
 594 }
 595
 596 static BOOL try_enum_device( DWORD type, LPDIENUMDEVICESCALLBACKW callback,
 597                              DIDEVICEINSTANCEW *instance, void *context, DWORD flags )
 598 {
 599     if (type && (instance->dwDevType & 0xff) != type) return DIENUM_CONTINUE;
 600     if ((flags & DIEDFL_FORCEFEEDBACK) && IsEqualGUID( &instance->guidFFDriver, &GUID_NULL ))
 601         return DIENUM_CONTINUE;
 602     return enum_callback_wrapper( callback, instance, context );
 603 }
 604
 605 static HRESULT WINAPI dinput8_EnumDevices( IDirectInput8W *iface, DWORD type, LPDIENUMDEVICESCALLBACKW callback, void *context,
 606                                            DWORD flags )
 607 {
 608     DIDEVICEINSTANCEW instance = {.dwSize = sizeof(DIDEVICEINSTANCEW)};
 609     struct dinput *impl = impl_from_IDirectInput8W( iface );
 610     DWORD device_class = 0, device_type = 0;
 611     unsigned int i = 0;
 612     HRESULT hr;
 613
 614     TRACE( "iface %p, type %#lx, callback %p, context %p, flags %#lx.\n", iface, type, callback, context, flags );
 615
 616     if (!callback) return DIERR_INVALIDPARAM;
 617
 618     if ((type > DI8DEVCLASS_GAMECTRL && type < DI8DEVTYPE_DEVICE) || type > DI8DEVTYPE_SUPPLEMENTAL)
 619         return DIERR_INVALIDPARAM;
 620     if (flags & ~(DIEDFL_ATTACHEDONLY | DIEDFL_FORCEFEEDBACK | DIEDFL_INCLUDEALIASES |
 621                   DIEDFL_INCLUDEPHANTOMS | DIEDFL_INCLUDEHIDDEN))
 622         return DIERR_INVALIDPARAM;
 623
 624     if (!impl->initialized) return DIERR_NOTINITIALIZED;
 625
 626     if (type <= DI8DEVCLASS_GAMECTRL) device_class = type;
 627     else device_type = type;
 628
 629     if (device_class == DI8DEVCLASS_ALL || device_class == DI8DEVCLASS_POINTER)
 630     {
 631         hr = mouse_enum_device( type, flags, &instance, impl->dwVersion );
 632         if (hr == DI_OK && try_enum_device( device_type, callback, &instance, context, flags ) == DIENUM_STOP)
 633             return DI_OK;
 634     }
 635
 636     if (device_class == DI8DEVCLASS_ALL || device_class == DI8DEVCLASS_KEYBOARD)
 637     {
 638         hr = keyboard_enum_device( type, flags, &instance, impl->dwVersion );
 639         if (hr == DI_OK && try_enum_device( device_type, callback, &instance, context, flags ) == DIENUM_STOP)
 640             return DI_OK;
 641     }
 642
 643     if (device_class == DI8DEVCLASS_ALL || device_class == DI8DEVCLASS_GAMECTRL)
 644     {
 645         do
 646         {
 647             hr = hid_joystick_enum_device( type, flags, &instance, impl->dwVersion, i++ );
 648             if (hr == DI_OK && try_enum_device( device_type, callback, &instance, context, flags ) == DIENUM_STOP)
 649                 return DI_OK;
 650         } while (SUCCEEDED(hr));
 651     }
 652
 653     return DI_OK;
 654 }
 655
 656 static HRESULT WINAPI dinput8_GetDeviceStatus( IDirectInput8W *iface, const GUID *guid )
 657 {
 658     struct dinput *impl = impl_from_IDirectInput8W( iface );
 659     return IDirectInput7_GetDeviceStatus( &impl->IDirectInput7W_iface, guid );
 660 }
 661
 662 static HRESULT WINAPI dinput8_RunControlPanel( IDirectInput8W *iface, HWND owner, DWORD flags )
 663 {
 664     struct dinput *impl = impl_from_IDirectInput8W( iface );
 665     return IDirectInput7_RunControlPanel( &impl->IDirectInput7W_iface, owner, flags );
 666 }
 667
 668 static HRESULT WINAPI dinput8_Initialize( IDirectInput8W *iface, HINSTANCE hinst, DWORD version )
 669 {
 670     struct dinput *impl = impl_from_IDirectInput8W( iface );
 671
 672     TRACE( "iface %p, hinst %p, version %#lx.\n", iface, hinst, version );
 673
 674     if (!hinst)
 675         return DIERR_INVALIDPARAM;
 676     else if (version == 0)
 677         return DIERR_NOTINITIALIZED;
 678     else if (version < DIRECTINPUT_VERSION)
 679         return DIERR_BETADIRECTINPUTVERSION;
 680     else if (version > DIRECTINPUT_VERSION)
 681         return DIERR_OLDDIRECTINPUTVERSION;
 682
 683     return initialize_directinput_instance( impl, version );
 684 }
 685
 686 static HRESULT WINAPI dinput8_FindDevice( IDirectInput8W *iface, const GUID *guid, const WCHAR *name, GUID *instance_guid )
 687 {
 688     struct dinput *impl = impl_from_IDirectInput8W( iface );
 689     return IDirectInput7_FindDevice( &impl->IDirectInput7W_iface, guid, name, instance_guid );
 690 }
 691
 692 static BOOL should_enumerate_device( const WCHAR *username, DWORD flags, struct list *device_players, const GUID *guid )
 693 {
 694     BOOL should_enumerate = TRUE;
 695     struct DevicePlayer *device_player;
 696
 697     /* Check if user owns impl device */
 698     if (flags & DIEDBSFL_THISUSER && username && *username)
 699     {
 700         should_enumerate = FALSE;
 701         LIST_FOR_EACH_ENTRY(device_player, device_players, struct DevicePlayer, entry)
 702         {
 703             if (IsEqualGUID(&device_player->instance_guid, guid))
 704             {
 705                 if (*device_player->username && !wcscmp( username, device_player->username ))
 706                     return TRUE; /* Device username matches */
 707                 break;
 708             }
 709         }
 710     }
 711
 712     /* Check if impl device is not owned by anyone */
 713     if (flags & DIEDBSFL_AVAILABLEDEVICES)
 714     {
 715         BOOL found = FALSE;
 716         should_enumerate = FALSE;
 717         LIST_FOR_EACH_ENTRY(device_player, device_players, struct DevicePlayer, entry)
 718         {
 719             if (IsEqualGUID(&device_player->instance_guid, guid))
 720             {
 721                 if (*device_player->username)
 722                     found = TRUE;
 723                 break;
 724             }
 725         }
 726         if (!found)
 727             return TRUE; /* Device does not have a username */
 728     }
 729
 730     return should_enumerate;
 731 }
 732
 733 struct enum_device_by_semantics_params
 734 {
 735     IDirectInput8W *iface;
 736     const WCHAR *username;
 737     DWORD flags;
 738
 739     DIDEVICEINSTANCEW *instances;
 740     DWORD instance_count;
 741 };
 742
 743 static BOOL CALLBACK enum_device_by_semantics( const DIDEVICEINSTANCEW *instance, void *context )
 744 {
 745     struct enum_device_by_semantics_params *params = context;
 746     struct dinput *impl = impl_from_IDirectInput8W( params->iface );
 747
 748     if (should_enumerate_device( params->username, params->flags, &impl->device_players, &instance->guidInstance ))
 749     {
 750         params->instance_count++;
 751         params->instances = realloc( params->instances, sizeof(DIDEVICEINSTANCEW) * params->instance_count );
 752         params->instances[params->instance_count - 1] = *instance;
 753     }
 754
 755     return DIENUM_CONTINUE;
 756 }
 757
 758 static HRESULT WINAPI dinput8_EnumDevicesBySemantics( IDirectInput8W *iface, const WCHAR *username, DIACTIONFORMATW *action_format,
 759                                                       LPDIENUMDEVICESBYSEMANTICSCBW callback, void *context, DWORD flags )
 760 {
 761     struct enum_device_by_semantics_params params = {.iface = iface, .username = username, .flags = flags};
 762     DWORD callbackFlags, enum_flags = DIEDFL_ATTACHEDONLY | (flags & DIEDFL_FORCEFEEDBACK);
 763     static const GUID *guids[2] = {&GUID_SysKeyboard, &GUID_SysMouse};
 764     static const DWORD actionMasks[] = { DIKEYBOARD_MASK, DIMOUSE_MASK };
 765     struct dinput *impl = impl_from_IDirectInput8W( iface );
 766     DIDEVICEINSTANCEW didevi;
 767     IDirectInputDevice8W *lpdid;
 768     unsigned int i = 0;
 769     HRESULT hr;
 770     int remain;
 771
 772     FIXME( "iface %p, username %s, action_format %p, callback %p, context %p, flags %#lx stub!\n",
 773            iface, debugstr_w(username), action_format, callback, context, flags );
 774
 775     didevi.dwSize = sizeof(didevi);
 776
 777     hr = IDirectInput8_EnumDevices( &impl->IDirectInput8W_iface, DI8DEVCLASS_GAMECTRL,
 778                                     enum_device_by_semantics, &params, enum_flags );
 779     if (FAILED(hr))
 780     {
 781         free( params.instances );
 782         return hr;
 783     }
 784
 785     remain = params.instance_count;
 786     /* Add keyboard and mouse to remaining device count */
 787     if (!(flags & DIEDBSFL_FORCEFEEDBACK))
 788     {
 789         for (i = 0; i < ARRAY_SIZE(guids); i++)
 790         {
 791             if (should_enumerate_device( username, flags, &impl->device_players, guids[i] )) remain++;
 792         }
 793     }
 794
 795     for (i = 0; i < params.instance_count; i++)
 796     {
 797         callbackFlags = diactionformat_priorityW( action_format, action_format->dwGenre );
 798         IDirectInput_CreateDevice( iface, &params.instances[i].guidInstance, &lpdid, NULL );
 799
 800         if (callback( &params.instances[i], lpdid, callbackFlags, --remain, context ) == DIENUM_STOP)
 801         {
 802             free( params.instances );
 803             IDirectInputDevice_Release(lpdid);
 804             return DI_OK;
 805         }
 806         IDirectInputDevice_Release(lpdid);
 807     }
 808
 809     free( params.instances );
 810
 811     if (flags & DIEDBSFL_FORCEFEEDBACK) return DI_OK;
 812
 813     /* Enumerate keyboard and mouse */
 814     for (i = 0; i < ARRAY_SIZE(guids); i++)
 815     {
 816         if (should_enumerate_device( username, flags, &impl->device_players, guids[i] ))
 817         {
 818             callbackFlags = diactionformat_priorityW( action_format, actionMasks[i] );
 819
 820             IDirectInput_CreateDevice(iface, guids[i], &lpdid, NULL);
 821             IDirectInputDevice_GetDeviceInfo(lpdid, &didevi);
 822
 823             if (callback( &didevi, lpdid, callbackFlags, --remain, context ) == DIENUM_STOP)
 824             {
 825                 IDirectInputDevice_Release(lpdid);
 826                 return DI_OK;
 827             }
 828             IDirectInputDevice_Release(lpdid);
 829         }
 830     }
 831
 832     return DI_OK;
 833 }
 834
 835 static HRESULT WINAPI dinput8_ConfigureDevices( IDirectInput8W *iface, LPDICONFIGUREDEVICESCALLBACK callback,
 836                                                 DICONFIGUREDEVICESPARAMSW *params, DWORD flags, void *context )
 837 {
 838     FIXME( "iface %p, callback %p, params %p, flags %#lx, context %p stub!\n", iface, callback,
 839            params, flags, context );
 840
 841     /* Call helper function in config.c to do the real work */
 842     return _configure_devices( iface, callback, params, flags, context );
 843 }
 844
 845 /*****************************************************************************
 846  * IDirectInputJoyConfig8 interface
 847  */
 848
 849 static inline struct dinput *impl_from_IDirectInputJoyConfig8( IDirectInputJoyConfig8 *iface )
 850 {
 851     return CONTAINING_RECORD( iface, struct dinput, IDirectInputJoyConfig8_iface );
 852 }
 853
 854 static HRESULT WINAPI joy_config_QueryInterface( IDirectInputJoyConfig8 *iface, REFIID iid, void **out )
 855 {
 856     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 857     return IDirectInput7_QueryInterface( &impl->IDirectInput7W_iface, iid, out );
 858 }
 859
 860 static ULONG WINAPI joy_config_AddRef( IDirectInputJoyConfig8 *iface )
 861 {
 862     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 863     return IDirectInput7_AddRef( &impl->IDirectInput7W_iface );
 864 }
 865
 866 static ULONG WINAPI joy_config_Release( IDirectInputJoyConfig8 *iface )
 867 {
 868     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 869     return IDirectInput7_Release( &impl->IDirectInput7W_iface );
 870 }
 871
 872 static HRESULT WINAPI joy_config_Acquire( IDirectInputJoyConfig8 *iface )
 873 {
 874     FIXME( "iface %p stub!\n", iface );
 875     return E_NOTIMPL;
 876 }
 877
 878 static HRESULT WINAPI joy_config_Unacquire( IDirectInputJoyConfig8 *iface )
 879 {
 880     FIXME( "iface %p stub!\n", iface );
 881     return E_NOTIMPL;
 882 }
 883
 884 static HRESULT WINAPI joy_config_SetCooperativeLevel( IDirectInputJoyConfig8 *iface, HWND hwnd, DWORD flags )
 885 {
 886     FIXME( "iface %p, hwnd %p, flags %#lx stub!\n", iface, hwnd, flags );
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI joy_config_SendNotify( IDirectInputJoyConfig8 *iface )
 891 {
 892     FIXME( "iface %p stub!\n", iface );
 893     return E_NOTIMPL;
 894 }
 895
 896 static HRESULT WINAPI joy_config_EnumTypes( IDirectInputJoyConfig8 *iface, LPDIJOYTYPECALLBACK callback, void *context )
 897 {
 898     FIXME( "iface %p, callback %p, context %p stub!\n", iface, callback, context );
 899     return E_NOTIMPL;
 900 }
 901
 902 static HRESULT WINAPI joy_config_GetTypeInfo( IDirectInputJoyConfig8 *iface, const WCHAR *name,
 903                                               DIJOYTYPEINFO *info, DWORD flags )
 904 {
 905     FIXME( "iface %p, name %s, info %p, flags %#lx stub!\n", iface, debugstr_w(name), info, flags );
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI joy_config_SetTypeInfo( IDirectInputJoyConfig8 *iface, const WCHAR *name,
 910                                               const DIJOYTYPEINFO *info, DWORD flags, WCHAR *new_name )
 911 {
 912     FIXME( "iface %p, name %s, info %p, flags %#lx, new_name %s stub!\n",
 913            iface, debugstr_w(name), info, flags, debugstr_w(new_name) );
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI joy_config_DeleteType( IDirectInputJoyConfig8 *iface, const WCHAR *name )
 918 {
 919     FIXME( "iface %p, name %s stub!\n", iface, debugstr_w(name) );
 920     return E_NOTIMPL;
 921 }
 922
 923 struct find_device_from_index_params
 924 {
 925     UINT index;
 926     DIDEVICEINSTANCEW instance;
 927 };
 928
 929 static BOOL CALLBACK find_device_from_index( const DIDEVICEINSTANCEW *instance, void *context )
 930 {
 931     struct find_device_from_index_params *params = context;
 932     params->instance = *instance;
 933     if (!params->index--) return DIENUM_STOP;
 934     return DIENUM_CONTINUE;
 935 }
 936
 937 static HRESULT WINAPI joy_config_GetConfig( IDirectInputJoyConfig8 *iface, UINT id, DIJOYCONFIG *info, DWORD flags )
 938 {
 939     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 940     struct find_device_from_index_params params = {.index = id};
 941     HRESULT hr;
 942
 943     FIXME( "iface %p, id %u, info %p, flags %#lx stub!\n", iface, id, info, flags );
 944
 945 #define X(x) if (flags & x) FIXME("\tflags |= "#x"\n");
 946     X(DIJC_GUIDINSTANCE)
 947     X(DIJC_REGHWCONFIGTYPE)
 948     X(DIJC_GAIN)
 949     X(DIJC_CALLOUT)
 950 #undef X
 951
 952     hr = IDirectInput8_EnumDevices( &impl->IDirectInput8W_iface, DI8DEVCLASS_GAMECTRL,
 953                                     find_device_from_index, &params, 0 );
 954     if (FAILED(hr)) return hr;
 955     if (params.index != ~0) return DIERR_NOMOREITEMS;
 956     if (flags & DIJC_GUIDINSTANCE) info->guidInstance = params.instance.guidInstance;
 957     return DI_OK;
 958 }
 959
 960 static HRESULT WINAPI joy_config_SetConfig( IDirectInputJoyConfig8 *iface, UINT id, const DIJOYCONFIG *info, DWORD flags )
 961 {
 962     FIXME( "iface %p, id %u, info %p, flags %#lx stub!\n", iface, id, info, flags );
 963     return E_NOTIMPL;
 964 }
 965
 966 static HRESULT WINAPI joy_config_DeleteConfig( IDirectInputJoyConfig8 *iface, UINT id )
 967 {
 968     FIXME( "iface %p, id %u stub!\n", iface, id );
 969     return E_NOTIMPL;
 970 }
 971
 972 static HRESULT WINAPI joy_config_GetUserValues( IDirectInputJoyConfig8 *iface, DIJOYUSERVALUES *info, DWORD flags )
 973 {
 974     FIXME( "iface %p, info %p, flags %#lx stub!\n", iface, info, flags );
 975     return E_NOTIMPL;
 976 }
 977
 978 static HRESULT WINAPI joy_config_SetUserValues( IDirectInputJoyConfig8 *iface, const DIJOYUSERVALUES *info, DWORD flags )
 979 {
 980     FIXME( "iface %p, info %p, flags %#lx stub!\n", iface, info, flags );
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI joy_config_AddNewHardware( IDirectInputJoyConfig8 *iface, HWND hwnd, const GUID *guid )
 985 {
 986     FIXME( "iface %p, hwnd %p, guid %s stub!\n", iface, hwnd, debugstr_guid( guid ) );
 987     return E_NOTIMPL;
 988 }
 989
 990 static HRESULT WINAPI joy_config_OpenTypeKey( IDirectInputJoyConfig8 *iface, const WCHAR *name, DWORD security, HKEY *key )
 991 {
 992     FIXME( "iface %p, name %s, security %lu, key %p stub!\n", iface, debugstr_w(name), security, key );
 993     return E_NOTIMPL;
 994 }
 995
 996 static HRESULT WINAPI joy_config_OpenAppStatusKey( IDirectInputJoyConfig8 *iface, HKEY *key )
 997 {
 998     FIXME( "iface %p, key %p stub!\n", iface, key );
 999     return E_NOTIMPL;
1000 }
1001
1002 static const IDirectInput7WVtbl dinput7_vtbl =
1003 {
1004     dinput7_QueryInterface,
1005     dinput7_AddRef,
1006     dinput7_Release,
1007     dinput7_CreateDevice,
1008     dinput7_EnumDevices,
1009     dinput7_GetDeviceStatus,
1010     dinput7_RunControlPanel,
1011     dinput7_Initialize,
1012     dinput7_FindDevice,
1013     dinput7_CreateDeviceEx,
1014 };
1015
1016 static const IDirectInput8WVtbl dinput8_vtbl =
1017 {
1018     dinput8_QueryInterface,
1019     dinput8_AddRef,
1020     dinput8_Release,
1021     dinput8_CreateDevice,
1022     dinput8_EnumDevices,
1023     dinput8_GetDeviceStatus,
1024     dinput8_RunControlPanel,
1025     dinput8_Initialize,
1026     dinput8_FindDevice,
1027     dinput8_EnumDevicesBySemantics,
1028     dinput8_ConfigureDevices,
1029 };
1030
1031 static const IDirectInputJoyConfig8Vtbl joy_config_vtbl =
1032 {
1033     joy_config_QueryInterface,
1034     joy_config_AddRef,
1035     joy_config_Release,
1036     joy_config_Acquire,
1037     joy_config_Unacquire,
1038     joy_config_SetCooperativeLevel,
1039     joy_config_SendNotify,
1040     joy_config_EnumTypes,
1041     joy_config_GetTypeInfo,
1042     joy_config_SetTypeInfo,
1043     joy_config_DeleteType,
1044     joy_config_GetConfig,
1045     joy_config_SetConfig,
1046     joy_config_DeleteConfig,
1047     joy_config_GetUserValues,
1048     joy_config_SetUserValues,
1049     joy_config_AddNewHardware,
1050     joy_config_OpenTypeKey,
1051     joy_config_OpenAppStatusKey,
1052 };
1053
1054 struct class_factory
1055 {
1056     IClassFactory IClassFactory_iface;
1057 };
1058
1059 static inline struct class_factory *impl_from_IClassFactory( IClassFactory *iface )
1060 {
1061     return CONTAINING_RECORD( iface, struct class_factory, IClassFactory_iface );
1062 }
1063
1064 static HRESULT WINAPI class_factory_QueryInterface( IClassFactory *iface, REFIID iid, void **out )
1065 {
1066     struct class_factory *impl = impl_from_IClassFactory(iface);
1067
1068     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1069
1070     if (IsEqualGUID(iid, &IID_IUnknown) ||
1071         IsEqualGUID(iid, &IID_IClassFactory))
1072         *out = &impl->IClassFactory_iface;
1073     else
1074     {
1075         *out = NULL;
1076         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
1077         return E_NOINTERFACE;
1078     }
1079
1080     IUnknown_AddRef((IUnknown *)*out);
1081     return S_OK;
1082 }
1083
1084 static ULONG WINAPI class_factory_AddRef( IClassFactory *iface )
1085 {
1086     return 2;
1087 }
1088
1089 static ULONG WINAPI class_factory_Release( IClassFactory *iface )
1090 {
1091     return 1;
1092 }
1093
1094 static HRESULT WINAPI class_factory_CreateInstance( IClassFactory *iface, IUnknown *outer, REFIID iid, void **out )
1095 {
1096     IUnknown *unknown;
1097     HRESULT hr;
1098
1099     TRACE( "iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid( iid ), out );
1100
1101     if (outer) return CLASS_E_NOAGGREGATION;
1102
1103     if (FAILED(hr = dinput_create( &unknown ))) return hr;
1104     hr = IUnknown_QueryInterface( unknown, iid, out );
1105     IUnknown_Release( unknown );
1106
1107     return hr;
1108 }
1109
1110 static HRESULT WINAPI class_factory_LockServer( IClassFactory *iface, BOOL lock )
1111 {
1112     FIXME( "iface %p, lock %d stub!\n", iface, lock );
1113     return S_OK;
1114 }
1115
1116 static const IClassFactoryVtbl class_factory_vtbl =
1117 {
1118     class_factory_QueryInterface,
1119     class_factory_AddRef,
1120     class_factory_Release,
1121     class_factory_CreateInstance,
1122     class_factory_LockServer,
1123 };
1124
1125 static struct class_factory class_factory = {{&class_factory_vtbl}};
1126
1127 /***********************************************************************
1128  *              DllGetClassObject (DINPUT.@)
1129  */
1130 HRESULT WINAPI DllGetClassObject( REFCLSID clsid, REFIID iid, void **out )
1131 {
1132     TRACE( "clsid %s, iid %s, out %p.\n", debugstr_guid( clsid ), debugstr_guid( iid ), out );
1133
1134 #if DIRECTINPUT_VERSION == 0x0700
1135     if (IsEqualCLSID( &CLSID_DirectInput, clsid ))
1136         return IClassFactory_QueryInterface( &class_factory.IClassFactory_iface, iid, out );
1137 #else
1138     if (IsEqualCLSID( &CLSID_DirectInput8, clsid ))
1139         return IClassFactory_QueryInterface( &class_factory.IClassFactory_iface, iid, out );
1140 #endif
1141
1142     WARN( "%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid( clsid ) );
1143     return CLASS_E_CLASSNOTAVAILABLE;
1144 }
1145
1146 /******************************************************************************
1147  *      DInput hook thread
1148  */
1149
1150 static LRESULT CALLBACK LL_hook_proc( int code, WPARAM wparam, LPARAM lparam )
1151 {
1152     struct dinput_device *impl;
1153     int skip = 0;
1154
1155     if (code != HC_ACTION) return CallNextHookEx( 0, code, wparam, lparam );
1156
1157     EnterCriticalSection( &dinput_hook_crit );
1158     LIST_FOR_EACH_ENTRY( impl, &acquired_mouse_list, struct dinput_device, entry )
1159     {
1160         TRACE( "calling dinput_mouse_hook (%p %Ix %Ix)\n", impl, wparam, lparam );
1161         skip |= dinput_mouse_hook( &impl->IDirectInputDevice8W_iface, wparam, lparam );
1162     }
1163     LIST_FOR_EACH_ENTRY( impl, &acquired_keyboard_list, struct dinput_device, entry )
1164     {
1165         if (impl->use_raw_input) continue;
1166         TRACE( "calling dinput_keyboard_hook (%p %Ix %Ix)\n", impl, wparam, lparam );
1167         skip |= dinput_keyboard_hook( &impl->IDirectInputDevice8W_iface, wparam, lparam );
1168     }
1169     LeaveCriticalSection( &dinput_hook_crit );
1170
1171     return skip ? 1 : CallNextHookEx( 0, code, wparam, lparam );
1172 }
1173
1174 static LRESULT CALLBACK callwndproc_proc( int code, WPARAM wparam, LPARAM lparam )
1175 {
1176     struct dinput_device *impl, *next;
1177     CWPSTRUCT *msg = (CWPSTRUCT *)lparam;
1178     HWND foreground;
1179
1180     if (code != HC_ACTION || (msg->message != WM_KILLFOCUS &&
1181         msg->message != WM_ACTIVATEAPP && msg->message != WM_ACTIVATE))
1182         return CallNextHookEx( 0, code, wparam, lparam );
1183
1184     foreground = GetForegroundWindow();
1185
1186     EnterCriticalSection( &dinput_hook_crit );
1187     LIST_FOR_EACH_ENTRY_SAFE( impl, next, &acquired_device_list, struct dinput_device, entry )
1188     {
1189         if (msg->hwnd == impl->win && msg->hwnd != foreground)
1190         {
1191             TRACE( "%p window is not foreground - unacquiring %p\n", impl->win, impl );
1192             dinput_device_internal_unacquire( &impl->IDirectInputDevice8W_iface );
1193         }
1194     }
1195     LIST_FOR_EACH_ENTRY_SAFE( impl, next, &acquired_mouse_list, struct dinput_device, entry )
1196     {
1197         if (msg->hwnd == impl->win && msg->hwnd != foreground)
1198         {
1199             TRACE( "%p window is not foreground - unacquiring %p\n", impl->win, impl );
1200             dinput_device_internal_unacquire( &impl->IDirectInputDevice8W_iface );
1201         }
1202     }
1203     LIST_FOR_EACH_ENTRY_SAFE( impl, next, &acquired_rawmouse_list, struct dinput_device, entry )
1204     {
1205         if (msg->hwnd == impl->win && msg->hwnd != foreground)
1206         {
1207             TRACE( "%p window is not foreground - unacquiring %p\n", impl->win, impl );
1208             dinput_device_internal_unacquire( &impl->IDirectInputDevice8W_iface );
1209         }
1210     }
1211     LIST_FOR_EACH_ENTRY_SAFE( impl, next, &acquired_keyboard_list, struct dinput_device, entry )
1212     {
1213         if (msg->hwnd == impl->win && msg->hwnd != foreground)
1214         {
1215             TRACE( "%p window is not foreground - unacquiring %p\n", impl->win, impl );
1216             dinput_device_internal_unacquire( &impl->IDirectInputDevice8W_iface );
1217         }
1218     }
1219     LeaveCriticalSection( &dinput_hook_crit );
1220
1221     return CallNextHookEx( 0, code, wparam, lparam );
1222 }
1223
1224 static DWORD WINAPI dinput_thread_proc( void *params )
1225 {
1226     HANDLE events[128], start_event = params;
1227     static HHOOK kbd_hook, mouse_hook;
1228     struct dinput_device *impl, *next;
1229     SIZE_T events_count = 0;
1230     HANDLE finished_event;
1231     DWORD ret;
1232     MSG msg;
1233
1234     di_em_win = CreateWindowW( L"DIEmWin", L"DIEmWin", 0, 0, 0, 0, 0, HWND_MESSAGE, 0, DINPUT_instance, NULL );
1235
1236     /* Force creation of the message queue */
1237     PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE );
1238     SetEvent( start_event );
1239
1240     while ((ret = MsgWaitForMultipleObjectsEx( events_count, events, INFINITE, QS_ALLINPUT, 0 )) <= events_count)
1241     {
1242         UINT kbd_cnt = 0, mice_cnt = 0;
1243
1244         if (ret < events_count)
1245         {
1246             EnterCriticalSection( &dinput_hook_crit );
1247             LIST_FOR_EACH_ENTRY_SAFE( impl, next, &acquired_device_list, struct dinput_device, entry )
1248             {
1249                 if (impl->read_event == events[ret])
1250                 {
1251                     if (FAILED( impl->vtbl->read( &impl->IDirectInputDevice8W_iface ) ))
1252                     {
1253                         dinput_device_internal_unacquire( &impl->IDirectInputDevice8W_iface );
1254                         impl->status = STATUS_UNPLUGGED;
1255                     }
1256                     break;
1257                 }
1258             }
1259             LeaveCriticalSection( &dinput_hook_crit );
1260         }
1261
1262         while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ))
1263         {
1264             if (msg.message != WM_USER+0x10)
1265             {
1266                 TranslateMessage(&msg);
1267                 DispatchMessageW(&msg);
1268                 continue;
1269             }
1270
1271             finished_event = (HANDLE)msg.lParam;
1272
1273             TRACE( "Processing hook change notification wparam %#Ix, lparam %#Ix.\n", msg.wParam, msg.lParam );
1274
1275             if (!msg.wParam)
1276             {
1277                 if (kbd_hook) UnhookWindowsHookEx( kbd_hook );
1278                 if (mouse_hook) UnhookWindowsHookEx( mouse_hook );
1279                 kbd_hook = mouse_hook = NULL;
1280                 goto done;
1281             }
1282
1283             EnterCriticalSection( &dinput_hook_crit );
1284             kbd_cnt = list_count( &acquired_keyboard_list );
1285             mice_cnt = list_count( &acquired_mouse_list );
1286             LeaveCriticalSection( &dinput_hook_crit );
1287
1288             if (kbd_cnt && !kbd_hook)
1289                 kbd_hook = SetWindowsHookExW( WH_KEYBOARD_LL, LL_hook_proc, DINPUT_instance, 0 );
1290             else if (!kbd_cnt && kbd_hook)
1291             {
1292                 UnhookWindowsHookEx( kbd_hook );
1293                 kbd_hook = NULL;
1294             }
1295
1296             if (mice_cnt && !mouse_hook)
1297                 mouse_hook = SetWindowsHookExW( WH_MOUSE_LL, LL_hook_proc, DINPUT_instance, 0 );
1298             else if (!mice_cnt && mouse_hook)
1299             {
1300                 UnhookWindowsHookEx( mouse_hook );
1301                 mouse_hook = NULL;
1302             }
1303
1304             SetEvent(finished_event);
1305         }
1306
1307         events_count = 0;
1308         EnterCriticalSection( &dinput_hook_crit );
1309         LIST_FOR_EACH_ENTRY( impl, &acquired_device_list, struct dinput_device, entry )
1310         {
1311             if (!impl->read_event || !impl->vtbl->read) continue;
1312             if (events_count >= ARRAY_SIZE(events)) break;
1313             events[events_count++] = impl->read_event;
1314         }
1315         LeaveCriticalSection( &dinput_hook_crit );
1316     }
1317
1318     if (ret != events_count) ERR("Unexpected termination, ret %#lx\n", ret);
1319
1320 done:
1321     DestroyWindow( di_em_win );
1322     di_em_win = NULL;
1323     return 0;
1324 }
1325
1326 static BOOL WINAPI dinput_thread_start_once( INIT_ONCE *once, void *param, void **context )
1327 {
1328     HANDLE start_event;
1329
1330     start_event = CreateEventW( NULL, FALSE, FALSE, NULL );
1331     if (!start_event) ERR( "failed to create start event, error %lu\n", GetLastError() );
1332
1333     dinput_thread = CreateThread( NULL, 0, dinput_thread_proc, start_event, 0, &dinput_thread_id );
1334     if (!dinput_thread) ERR( "failed to create internal thread, error %lu\n", GetLastError() );
1335
1336     WaitForSingleObject( start_event, INFINITE );
1337     CloseHandle( start_event );
1338
1339     return TRUE;
1340 }
1341
1342 static void dinput_thread_start(void)
1343 {
1344     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
1345     InitOnceExecuteOnce( &init_once, dinput_thread_start_once, NULL, NULL );
1346 }
1347
1348 static void dinput_thread_stop(void)
1349 {
1350     PostThreadMessageW( dinput_thread_id, WM_USER + 0x10, 0, 0 );
1351     if (WaitForSingleObject( dinput_thread, 500 ) == WAIT_TIMEOUT)
1352         WARN("Timeout while waiting for internal thread\n");
1353     CloseHandle( dinput_thread );
1354 }
1355
1356 void check_dinput_hooks( IDirectInputDevice8W *iface, BOOL acquired )
1357 {
1358     static HHOOK callwndproc_hook;
1359     static ULONG foreground_cnt;
1360     struct dinput_device *impl = impl_from_IDirectInputDevice8W( iface );
1361     HANDLE hook_change_finished_event = NULL;
1362
1363     dinput_thread_start();
1364
1365     EnterCriticalSection(&dinput_hook_crit);
1366
1367     if (impl->dwCoopLevel & DISCL_FOREGROUND)
1368     {
1369         if (acquired)
1370             foreground_cnt++;
1371         else
1372             foreground_cnt--;
1373     }
1374
1375     if (foreground_cnt && !callwndproc_hook)
1376         callwndproc_hook = SetWindowsHookExW( WH_CALLWNDPROC, callwndproc_proc,
1377                                               DINPUT_instance, GetCurrentThreadId() );
1378     else if (!foreground_cnt && callwndproc_hook)
1379     {
1380         UnhookWindowsHookEx( callwndproc_hook );
1381         callwndproc_hook = NULL;
1382     }
1383
1384     if (impl->use_raw_input)
1385     {
1386         if (acquired)
1387         {
1388             impl->raw_device.dwFlags = 0;
1389             if (impl->dwCoopLevel & DISCL_BACKGROUND)
1390                 impl->raw_device.dwFlags |= RIDEV_INPUTSINK;
1391             if (impl->dwCoopLevel & DISCL_EXCLUSIVE)
1392                 impl->raw_device.dwFlags |= RIDEV_NOLEGACY;
1393             if ((impl->dwCoopLevel & DISCL_EXCLUSIVE) && impl->raw_device.usUsage == 2)
1394                 impl->raw_device.dwFlags |= RIDEV_CAPTUREMOUSE;
1395             if ((impl->dwCoopLevel & DISCL_EXCLUSIVE) && impl->raw_device.usUsage == 6)
1396                 impl->raw_device.dwFlags |= RIDEV_NOHOTKEYS;
1397             impl->raw_device.hwndTarget = di_em_win;
1398         }
1399         else
1400         {
1401             impl->raw_device.dwFlags = RIDEV_REMOVE;
1402             impl->raw_device.hwndTarget = NULL;
1403         }
1404
1405         if (!RegisterRawInputDevices( &impl->raw_device, 1, sizeof(RAWINPUTDEVICE) ))
1406             WARN( "Unable to (un)register raw device %x:%x\n", impl->raw_device.usUsagePage, impl->raw_device.usUsage );
1407     }
1408
1409     hook_change_finished_event = CreateEventW( NULL, FALSE, FALSE, NULL );
1410     PostThreadMessageW( dinput_thread_id, WM_USER + 0x10, 1, (LPARAM)hook_change_finished_event );
1411
1412     LeaveCriticalSection(&dinput_hook_crit);
1413
1414     WaitForSingleObject(hook_change_finished_event, INFINITE);
1415     CloseHandle(hook_change_finished_event);
1416 }
1417
1418 void check_dinput_events(void)
1419 {
1420     /* Windows does not do that, but our current implementation of winex11
1421      * requires periodic event polling to forward events to the wineserver.
1422      *
1423      * We have to call this function from multiple places, because:
1424      * - some games do not explicitly poll for mouse events
1425      *   (for example Culpa Innata)
1426      * - some games only poll the device, and neither keyboard nor mouse
1427      *   (for example Civilization: Call to Power 2)
1428      * - some games do not explicitly poll for keyboard events
1429      *   (for example Morrowind in its key binding page)
1430      */
1431     MsgWaitForMultipleObjectsEx(0, NULL, 0, QS_ALLINPUT, 0);
1432 }
1433
1434 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, void *reserved )
1435 {
1436     TRACE( "inst %p, reason %lu, reserved %p.\n", inst, reason, reserved );
1437
1438     switch(reason)
1439     {
1440       case DLL_PROCESS_ATTACH:
1441         DisableThreadLibraryCalls(inst);
1442         DINPUT_instance = inst;
1443         register_di_em_win_class();
1444         break;
1445       case DLL_PROCESS_DETACH:
1446         if (reserved) break;
1447         dinput_thread_stop();
1448         unregister_di_em_win_class();
1449         break;
1450     }
1451     return TRUE;
1452 }