dlls/dinput/dinput.c

   1 /*
   2  * Copyright 1998 Marcus Meissner
   3  * Copyright 1998,1999 Lionel Ulmer
   4  * Copyright 2000-2002 TransGaming Technologies Inc.
   5  * Copyright 2007 Vitaliy Margolen
   6  *
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stddef.h>
  24 #include <stdarg.h>
  25
  26 #define COBJMACROS
  27 #include "windef.h"
  28 #include "winbase.h"
  29
  30 #include "dinput_private.h"
  31 #include "device_private.h"
  32
  33 #include "wine/asm.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  37
  38 static inline struct dinput *impl_from_IDirectInput7W( IDirectInput7W *iface )
  39 {
  40     return CONTAINING_RECORD( iface, struct dinput, IDirectInput7W_iface );
  41 }
  42
  43 static inline struct dinput *impl_from_IDirectInput8W( IDirectInput8W *iface )
  44 {
  45     return CONTAINING_RECORD( iface, struct dinput, IDirectInput8W_iface );
  46 }
  47
  48 #if defined __i386__ && defined _MSC_VER
  49 __declspec(naked) BOOL enum_callback_wrapper(void *callback, const void *instance, void *ref)
  50 {
  51     __asm
  52     {
  53         push ebp
  54         mov ebp, esp
  55         push [ebp+16]
  56         push [ebp+12]
  57         call [ebp+8]
  58         leave
  59         ret
  60     }
  61 }
  62 #elif defined __i386__ && defined __GNUC__
  63 extern BOOL enum_callback_wrapper(void *callback, const void *instance, void *ref);
  64 __ASM_GLOBAL_FUNC( enum_callback_wrapper,
  65     "pushl %ebp\n\t"
  66     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
  67     __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
  68     "movl %esp,%ebp\n\t"
  69     __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
  70     "pushl 16(%ebp)\n\t"
  71     "pushl 12(%ebp)\n\t"
  72     "call *8(%ebp)\n\t"
  73     "leave\n\t"
  74     __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
  75     __ASM_CFI(".cfi_same_value %ebp\n\t")
  76     "ret" )
  77 #else
  78 #define enum_callback_wrapper(callback, instance, ref) (callback)((instance), (ref))
  79 #endif
  80
  81 static HRESULT WINAPI dinput7_EnumDevices( IDirectInput7W *iface, DWORD type, LPDIENUMDEVICESCALLBACKW callback,
  82                                            void *context, DWORD flags )
  83 {
  84     struct dinput *impl = impl_from_IDirectInput7W( iface );
  85
  86     TRACE( "iface %p, type %#lx, callback %p, context %p, flags %#lx.\n", iface, type, callback, context, flags );
  87
  88     if (!callback) return DIERR_INVALIDPARAM;
  89
  90     if (type > DIDEVTYPE_JOYSTICK) return DIERR_INVALIDPARAM;
  91     if (flags & ~(DIEDFL_ATTACHEDONLY | DIEDFL_FORCEFEEDBACK | DIEDFL_INCLUDEALIASES | DIEDFL_INCLUDEPHANTOMS))
  92         return DIERR_INVALIDPARAM;
  93
  94     return IDirectInput8_EnumDevices( &impl->IDirectInput8W_iface, type, callback, context, flags );
  95 }
  96
  97 void dinput_internal_addref( struct dinput *impl )
  98 {
  99     ULONG ref = InterlockedIncrement( &impl->internal_ref );
 100     TRACE( "impl %p, internal ref %lu.\n", impl, ref );
 101 }
 102
 103 void dinput_internal_release( struct dinput *impl )
 104 {
 105     ULONG ref = InterlockedDecrement( &impl->internal_ref );
 106     TRACE( "impl %p, internal ref %lu.\n", impl, ref );
 107
 108     if (!ref)
 109     {
 110         struct DevicePlayer *device_player, *device_player2;
 111
 112         LIST_FOR_EACH_ENTRY_SAFE( device_player, device_player2, &impl->device_players, struct DevicePlayer, entry )
 113             free( device_player );
 114
 115         free( impl );
 116     }
 117 }
 118
 119 static ULONG WINAPI dinput7_AddRef( IDirectInput7W *iface )
 120 {
 121     struct dinput *impl = impl_from_IDirectInput7W( iface );
 122     ULONG ref = InterlockedIncrement( &impl->ref );
 123     TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
 124     return ref;
 125 }
 126
 127 static ULONG WINAPI dinput7_Release( IDirectInput7W *iface )
 128 {
 129     struct dinput *impl = impl_from_IDirectInput7W( iface );
 130     ULONG ref = InterlockedDecrement( &impl->ref );
 131
 132     TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
 133
 134     if (!ref)
 135     {
 136         input_thread_remove_user();
 137         dinput_internal_release( impl );
 138     }
 139
 140     return ref;
 141 }
 142
 143 static HRESULT WINAPI dinput7_QueryInterface( IDirectInput7W *iface, REFIID iid, void **out )
 144 {
 145     struct dinput *impl = impl_from_IDirectInput7W( iface );
 146
 147     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 148
 149     if (!iid || !out) return E_POINTER;
 150
 151     *out = NULL;
 152
 153 #if DIRECTINPUT_VERSION == 0x0700
 154     if (IsEqualGUID( &IID_IDirectInputA, iid ) ||
 155         IsEqualGUID( &IID_IDirectInput2A, iid ) ||
 156         IsEqualGUID( &IID_IDirectInput7A, iid ))
 157         *out = &impl->IDirectInput7A_iface;
 158     else if (IsEqualGUID( &IID_IUnknown, iid ) ||
 159              IsEqualGUID( &IID_IDirectInputW, iid ) ||
 160              IsEqualGUID( &IID_IDirectInput2W, iid ) ||
 161              IsEqualGUID( &IID_IDirectInput7W, iid ))
 162         *out = &impl->IDirectInput7W_iface;
 163 #else
 164     if (IsEqualGUID( &IID_IDirectInput8A, iid ))
 165         *out = &impl->IDirectInput8A_iface;
 166     else if (IsEqualGUID( &IID_IUnknown, iid ) ||
 167              IsEqualGUID( &IID_IDirectInput8W, iid ))
 168         *out = &impl->IDirectInput8W_iface;
 169 #endif
 170
 171     if (IsEqualGUID( &IID_IDirectInputJoyConfig8, iid ))
 172         *out = &impl->IDirectInputJoyConfig8_iface;
 173
 174     if (*out)
 175     {
 176         IUnknown_AddRef( (IUnknown *)*out );
 177         return DI_OK;
 178     }
 179
 180     WARN( "Unsupported interface: %s\n", debugstr_guid( iid ) );
 181     return E_NOINTERFACE;
 182 }
 183
 184 enum directinput_versions
 185 {
 186     DIRECTINPUT_VERSION_300 = 0x0300,
 187     DIRECTINPUT_VERSION_500 = 0x0500,
 188     DIRECTINPUT_VERSION_50A = 0x050A,
 189     DIRECTINPUT_VERSION_5B2 = 0x05B2,
 190     DIRECTINPUT_VERSION_602 = 0x0602,
 191     DIRECTINPUT_VERSION_61A = 0x061A,
 192     DIRECTINPUT_VERSION_700 = 0x0700,
 193 };
 194
 195 static HRESULT WINAPI dinput7_Initialize( IDirectInput7W *iface, HINSTANCE hinst, DWORD version )
 196 {
 197     struct dinput *impl = impl_from_IDirectInput7W( iface );
 198
 199     TRACE( "iface %p, hinst %p, version %#lx.\n", iface, hinst, version );
 200
 201     if (!hinst)
 202         return DIERR_INVALIDPARAM;
 203     else if (version == 0)
 204         return DIERR_NOTINITIALIZED;
 205     else if (version > DIRECTINPUT_VERSION_700)
 206         return DIERR_OLDDIRECTINPUTVERSION;
 207     else if (version != DIRECTINPUT_VERSION_300 && version != DIRECTINPUT_VERSION_500 &&
 208              version != DIRECTINPUT_VERSION_50A && version != DIRECTINPUT_VERSION_5B2 &&
 209              version != DIRECTINPUT_VERSION_602 && version != DIRECTINPUT_VERSION_61A &&
 210              version != DIRECTINPUT_VERSION_700 && version != DIRECTINPUT_VERSION)
 211         return DIERR_BETADIRECTINPUTVERSION;
 212
 213     if (!impl->dwVersion)
 214     {
 215         impl->dwVersion = version;
 216         impl->evsequence = 1;
 217     }
 218
 219     return DI_OK;
 220 }
 221
 222 static HRESULT WINAPI dinput7_GetDeviceStatus( IDirectInput7W *iface, const GUID *guid )
 223 {
 224     struct dinput *impl = impl_from_IDirectInput7W( iface );
 225     HRESULT hr;
 226     IDirectInputDeviceW *device;
 227
 228     TRACE( "iface %p, guid %s.\n", iface, debugstr_guid( guid ) );
 229
 230     if (!guid) return E_POINTER;
 231     if (!impl->dwVersion) return DIERR_NOTINITIALIZED;
 232
 233     hr = IDirectInput_CreateDevice( iface, guid, &device, NULL );
 234     if (hr != DI_OK) return DI_NOTATTACHED;
 235
 236     IUnknown_Release( device );
 237
 238     return DI_OK;
 239 }
 240
 241 static HRESULT WINAPI dinput7_RunControlPanel( IDirectInput7W *iface, HWND owner, DWORD flags )
 242 {
 243     struct dinput *impl = impl_from_IDirectInput7W( iface );
 244     WCHAR control_exe[] = {L"control.exe"};
 245     STARTUPINFOW si = {0};
 246     PROCESS_INFORMATION pi;
 247
 248     TRACE( "iface %p, owner %p, flags %#lx.\n", iface, owner, flags );
 249
 250     if (owner && !IsWindow( owner )) return E_HANDLE;
 251     if (flags) return DIERR_INVALIDPARAM;
 252     if (!impl->dwVersion) return DIERR_NOTINITIALIZED;
 253
 254     if (!CreateProcessW( NULL, control_exe, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi ))
 255         return HRESULT_FROM_WIN32(GetLastError());
 256
 257     return DI_OK;
 258 }
 259
 260 static HRESULT WINAPI dinput7_FindDevice( IDirectInput7W *iface, const GUID *guid, const WCHAR *name, GUID *instance_guid )
 261 {
 262     FIXME( "iface %p, guid %s, name %s, instance_guid %s stub!\n", iface, debugstr_guid( guid ),
 263            debugstr_w(name), debugstr_guid( instance_guid ) );
 264     return DI_OK;
 265 }
 266
 267 static HRESULT WINAPI dinput7_CreateDeviceEx( IDirectInput7W *iface, const GUID *guid,
 268                                               REFIID iid, void **out, IUnknown *outer )
 269 {
 270     struct dinput *impl = impl_from_IDirectInput7W( iface );
 271     IDirectInputDevice8W *device;
 272     HRESULT hr;
 273
 274     TRACE( "iface %p, guid %s, iid %s, out %p, outer %p.\n", iface, debugstr_guid( guid ),
 275            debugstr_guid( iid ), out, outer );
 276
 277     if (!out) return E_POINTER;
 278     *out = NULL;
 279
 280     if (!guid) return E_POINTER;
 281     if (!impl->dwVersion) return DIERR_NOTINITIALIZED;
 282
 283     if (IsEqualGUID( &GUID_SysKeyboard, guid )) hr = keyboard_create_device( impl, guid, &device );
 284     else if (IsEqualGUID( &GUID_SysMouse, guid )) hr = mouse_create_device( impl, guid, &device );
 285     else hr = hid_joystick_create_device( impl, guid, &device );
 286
 287     if (FAILED(hr)) return hr;
 288
 289     hr = IDirectInputDevice8_QueryInterface( device, iid, out );
 290     IDirectInputDevice8_Release( device );
 291     return hr;
 292 }
 293
 294 static HRESULT WINAPI dinput7_CreateDevice( IDirectInput7W *iface, const GUID *guid,
 295                                             IDirectInputDeviceW **out, IUnknown *outer )
 296 {
 297     return IDirectInput7_CreateDeviceEx( iface, guid, &IID_IDirectInputDeviceW, (void **)out, outer );
 298 }
 299
 300 static ULONG WINAPI dinput8_AddRef( IDirectInput8W *iface )
 301 {
 302     struct dinput *impl = impl_from_IDirectInput8W( iface );
 303     return IDirectInput7_AddRef( &impl->IDirectInput7W_iface );
 304 }
 305
 306 static HRESULT WINAPI dinput8_QueryInterface( IDirectInput8W *iface, REFIID iid, void **out )
 307 {
 308     struct dinput *impl = impl_from_IDirectInput8W( iface );
 309     return IDirectInput7_QueryInterface( &impl->IDirectInput7W_iface, iid, out );
 310 }
 311
 312 static ULONG WINAPI dinput8_Release( IDirectInput8W *iface )
 313 {
 314     struct dinput *impl = impl_from_IDirectInput8W( iface );
 315     return IDirectInput7_Release( &impl->IDirectInput7W_iface );
 316 }
 317
 318 static HRESULT WINAPI dinput8_CreateDevice( IDirectInput8W *iface, const GUID *guid,
 319                                             IDirectInputDevice8W **out, IUnknown *outer )
 320 {
 321     struct dinput *impl = impl_from_IDirectInput8W( iface );
 322     return IDirectInput7_CreateDeviceEx( &impl->IDirectInput7W_iface, guid,
 323                                          &IID_IDirectInputDevice8W, (void **)out, outer );
 324 }
 325
 326 static BOOL try_enum_device( DWORD type, LPDIENUMDEVICESCALLBACKW callback,
 327                              DIDEVICEINSTANCEW *instance, void *context, DWORD flags )
 328 {
 329     if (type && (instance->dwDevType & 0xff) != type) return DIENUM_CONTINUE;
 330     if ((flags & DIEDFL_FORCEFEEDBACK) && IsEqualGUID( &instance->guidFFDriver, &GUID_NULL ))
 331         return DIENUM_CONTINUE;
 332     return enum_callback_wrapper( callback, instance, context );
 333 }
 334
 335 static HRESULT WINAPI dinput8_EnumDevices( IDirectInput8W *iface, DWORD type, LPDIENUMDEVICESCALLBACKW callback, void *context,
 336                                            DWORD flags )
 337 {
 338     DIDEVICEINSTANCEW instance = {.dwSize = sizeof(DIDEVICEINSTANCEW)};
 339     struct dinput *impl = impl_from_IDirectInput8W( iface );
 340     DWORD device_class = 0, device_type = 0;
 341     unsigned int i = 0;
 342     HRESULT hr;
 343
 344     TRACE( "iface %p, type %#lx, callback %p, context %p, flags %#lx.\n", iface, type, callback, context, flags );
 345
 346     if (!callback) return DIERR_INVALIDPARAM;
 347
 348     if ((type > DI8DEVCLASS_GAMECTRL && type < DI8DEVTYPE_DEVICE) || type > DI8DEVTYPE_SUPPLEMENTAL)
 349         return DIERR_INVALIDPARAM;
 350     if (flags & ~(DIEDFL_ATTACHEDONLY | DIEDFL_FORCEFEEDBACK | DIEDFL_INCLUDEALIASES |
 351                   DIEDFL_INCLUDEPHANTOMS | DIEDFL_INCLUDEHIDDEN))
 352         return DIERR_INVALIDPARAM;
 353
 354     if (!impl->dwVersion) return DIERR_NOTINITIALIZED;
 355
 356     if (type <= DI8DEVCLASS_GAMECTRL) device_class = type;
 357     else device_type = type;
 358
 359     if (device_class == DI8DEVCLASS_ALL || device_class == DI8DEVCLASS_POINTER)
 360     {
 361         hr = mouse_enum_device( type, flags, &instance, impl->dwVersion );
 362         if (hr == DI_OK && try_enum_device( device_type, callback, &instance, context, flags ) == DIENUM_STOP)
 363             return DI_OK;
 364     }
 365
 366     if (device_class == DI8DEVCLASS_ALL || device_class == DI8DEVCLASS_KEYBOARD)
 367     {
 368         hr = keyboard_enum_device( type, flags, &instance, impl->dwVersion );
 369         if (hr == DI_OK && try_enum_device( device_type, callback, &instance, context, flags ) == DIENUM_STOP)
 370             return DI_OK;
 371     }
 372
 373     if (device_class == DI8DEVCLASS_ALL || device_class == DI8DEVCLASS_GAMECTRL)
 374     {
 375         do
 376         {
 377             hr = hid_joystick_enum_device( type, flags, &instance, impl->dwVersion, i++ );
 378             if (hr == DI_OK && try_enum_device( device_type, callback, &instance, context, flags ) == DIENUM_STOP)
 379                 return DI_OK;
 380         } while (SUCCEEDED(hr));
 381     }
 382
 383     return DI_OK;
 384 }
 385
 386 static HRESULT WINAPI dinput8_GetDeviceStatus( IDirectInput8W *iface, const GUID *guid )
 387 {
 388     struct dinput *impl = impl_from_IDirectInput8W( iface );
 389     return IDirectInput7_GetDeviceStatus( &impl->IDirectInput7W_iface, guid );
 390 }
 391
 392 static HRESULT WINAPI dinput8_RunControlPanel( IDirectInput8W *iface, HWND owner, DWORD flags )
 393 {
 394     struct dinput *impl = impl_from_IDirectInput8W( iface );
 395     return IDirectInput7_RunControlPanel( &impl->IDirectInput7W_iface, owner, flags );
 396 }
 397
 398 static HRESULT WINAPI dinput8_Initialize( IDirectInput8W *iface, HINSTANCE hinst, DWORD version )
 399 {
 400     struct dinput *impl = impl_from_IDirectInput8W( iface );
 401
 402     TRACE( "iface %p, hinst %p, version %#lx.\n", iface, hinst, version );
 403
 404     if (!hinst)
 405         return DIERR_INVALIDPARAM;
 406     else if (version == 0)
 407         return DIERR_NOTINITIALIZED;
 408     else if (version < DIRECTINPUT_VERSION)
 409         return DIERR_BETADIRECTINPUTVERSION;
 410     else if (version > DIRECTINPUT_VERSION)
 411         return DIERR_OLDDIRECTINPUTVERSION;
 412
 413     if (!impl->dwVersion)
 414     {
 415         impl->dwVersion = version;
 416         impl->evsequence = 1;
 417     }
 418
 419     return DI_OK;
 420 }
 421
 422 static HRESULT WINAPI dinput8_FindDevice( IDirectInput8W *iface, const GUID *guid, const WCHAR *name, GUID *instance_guid )
 423 {
 424     struct dinput *impl = impl_from_IDirectInput8W( iface );
 425     return IDirectInput7_FindDevice( &impl->IDirectInput7W_iface, guid, name, instance_guid );
 426 }
 427
 428 struct enum_device_by_semantics_params
 429 {
 430     IDirectInput8W *iface;
 431     const WCHAR *username;
 432     DWORD flags;
 433
 434     IDirectInputDevice8W *devices[128];
 435     DWORD device_count;
 436 };
 437
 438 static BOOL CALLBACK enum_device_by_semantics( const DIDEVICEINSTANCEW *instance, void *context )
 439 {
 440     struct enum_device_by_semantics_params *params = context;
 441     DIDEVCAPS caps = {.dwSize = sizeof(caps)};
 442     DIPROPSTRING prop_username =
 443     {
 444         .diph =
 445         {
 446             .dwSize = sizeof(DIPROPSTRING),
 447             .dwHeaderSize = sizeof(DIPROPHEADER),
 448             .dwHow = DIPH_DEVICE,
 449         },
 450     };
 451     IDirectInputDevice8W *device;
 452     BOOL ret = DIENUM_CONTINUE;
 453     HRESULT hr;
 454
 455     if (params->device_count >= ARRAY_SIZE(params->devices)) return DIENUM_STOP;
 456
 457     if (FAILED(hr = IDirectInput8_CreateDevice( params->iface, &instance->guidInstance, &device, NULL )))
 458     {
 459         WARN( "Failed to create device, hr %#lx\n", hr );
 460         return DIENUM_CONTINUE;
 461     }
 462
 463     if (FAILED(hr = IDirectInputDevice8_GetCapabilities( device, &caps )))
 464         WARN( "Failed to get device capabilities, hr %#lx\n", hr );
 465     if ((params->flags & DIEDBSFL_FORCEFEEDBACK) && !caps.dwFFDriverVersion) goto done;
 466
 467     if (FAILED(hr = IDirectInputDevice8_GetProperty( device, DIPROP_USERNAME, &prop_username.diph )))
 468         WARN( "Failed to get device capabilities, hr %#lx\n", hr );
 469     else if ((params->flags & DIEDBSFL_THISUSER) && *params->username && wcscmp( params->username, prop_username.wsz ))
 470         goto done;
 471     else if ((params->flags & DIEDBSFL_AVAILABLEDEVICES) && *prop_username.wsz)
 472         goto done;
 473
 474     IDirectInputDevice_AddRef( device );
 475     params->devices[params->device_count++] = device;
 476
 477 done:
 478     IDirectInputDevice8_Release( device );
 479     return ret;
 480 }
 481
 482 struct enum_device_object_semantics_params
 483 {
 484     DIDEVICEINSTANCEW instance;
 485     DIACTIONFORMATW *format;
 486     DWORD flags;
 487 };
 488
 489 static BOOL CALLBACK enum_device_object_semantics( const DIDEVICEOBJECTINSTANCEW *obj, void *args )
 490 {
 491     struct enum_device_object_semantics_params *params = args;
 492     DIACTIONFORMATW *format = params->format;
 493     UINT i;
 494
 495     for (i = 0; format && i < format->dwNumActions; i++)
 496     {
 497         DIOBJECTDATAFORMAT object_format = {.dwType = obj->dwType, .dwOfs = obj->dwOfs};
 498         BYTE dev_type = params->instance.dwDevType & 0xf;
 499         DIACTIONW *action = format->rgoAction + i;
 500
 501         if (!device_object_matches_semantic( &params->instance, &object_format, action->dwSemantic, FALSE )) continue;
 502         if (!(action->dwSemantic & 0x4000)) params->flags |= DIEDBS_MAPPEDPRI1;
 503         else if (dev_type != DIDEVTYPE_KEYBOARD && dev_type != DIDEVTYPE_MOUSE) params->flags |= DIEDBS_MAPPEDPRI2;
 504     }
 505
 506     return DIENUM_CONTINUE;
 507 }
 508
 509 static HRESULT WINAPI dinput8_EnumDevicesBySemantics( IDirectInput8W *iface, const WCHAR *username, DIACTIONFORMATW *action_format,
 510                                                       LPDIENUMDEVICESBYSEMANTICSCBW callback, void *context, DWORD flags )
 511 {
 512     struct enum_device_by_semantics_params params = {.iface = iface, .username = username ? username : L"", .flags = flags};
 513     DWORD enum_flags = DIEDFL_ATTACHEDONLY | (flags & DIEDFL_FORCEFEEDBACK);
 514     struct dinput *impl = impl_from_IDirectInput8W( iface );
 515     unsigned int i = 0;
 516     HRESULT hr;
 517
 518     TRACE( "iface %p, username %s, action_format %p, callback %p, context %p, flags %#lx\n",
 519            iface, debugstr_w(username), action_format, callback, context, flags );
 520
 521     if (!action_format) return DIERR_INVALIDPARAM;
 522
 523     TRACE( "format guid %s, genre %#lx, name %s\n", debugstr_guid(&action_format->guidActionMap),
 524            action_format->dwGenre, debugstr_w(action_format->tszActionMap) );
 525     for (i = 0; i < action_format->dwNumActions; i++)
 526     {
 527         DIACTIONW *action = action_format->rgoAction + i;
 528         TRACE( "  %u: app_data %#Ix, semantic %#lx, flags %#lx, instance %s, obj_id %#lx, how %#lx, name %s\n",
 529                i, action->uAppData, action->dwSemantic, action->dwFlags, debugstr_guid(&action->guidInstance),
 530                action->dwObjID, action->dwHow, debugstr_w(action->lptszActionName) );
 531     }
 532
 533     if (FAILED(hr = IDirectInput8_EnumDevices( &impl->IDirectInput8W_iface, DI8DEVCLASS_ALL,
 534                                                enum_device_by_semantics, &params, enum_flags )))
 535     {
 536         WARN( "Failed to enumerate devices, hr %#lx\n", hr );
 537         goto cleanup;
 538     }
 539
 540     while (params.device_count--)
 541     {
 542         struct enum_device_object_semantics_params object_params = {.instance = {.dwSize = sizeof(DIDEVICEINSTANCEW)}, .format = action_format};
 543         IDirectInputDevice8W *device = params.devices[params.device_count];
 544         BOOL ret = DIENUM_STOP;
 545
 546         if (FAILED(hr = IDirectInputDevice8_GetDeviceInfo( device, &object_params.instance )))
 547             WARN( "Failed to get device %p info, hr %#lx\n", device, hr );
 548         else if (FAILED(hr = IDirectInputDevice8_EnumObjects( device, enum_device_object_semantics, &object_params, DIDFT_ALL )))
 549             WARN( "Failed to enumerate device %p objects, hr %#lx\n", device, hr );
 550         else
 551             ret = callback( &object_params.instance, device, object_params.flags, params.device_count, context );
 552
 553         IDirectInputDevice8_Release( device );
 554         if (ret == DIENUM_STOP) goto cleanup;
 555     }
 556
 557     return DI_OK;
 558
 559 cleanup:
 560     while (params.device_count--) IDirectInputDevice8_Release( params.devices[params.device_count] );
 561     return hr;
 562 }
 563
 564 static HRESULT WINAPI dinput8_ConfigureDevices( IDirectInput8W *iface, LPDICONFIGUREDEVICESCALLBACK callback,
 565                                                 DICONFIGUREDEVICESPARAMSW *params, DWORD flags, void *context )
 566 {
 567     FIXME( "iface %p, callback %p, params %p, flags %#lx, context %p stub!\n", iface, callback,
 568            params, flags, context );
 569
 570     /* Call helper function in config.c to do the real work */
 571     return _configure_devices( iface, callback, params, flags, context );
 572 }
 573
 574 static inline struct dinput *impl_from_IDirectInputJoyConfig8( IDirectInputJoyConfig8 *iface )
 575 {
 576     return CONTAINING_RECORD( iface, struct dinput, IDirectInputJoyConfig8_iface );
 577 }
 578
 579 static HRESULT WINAPI joy_config_QueryInterface( IDirectInputJoyConfig8 *iface, REFIID iid, void **out )
 580 {
 581     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 582     return IDirectInput7_QueryInterface( &impl->IDirectInput7W_iface, iid, out );
 583 }
 584
 585 static ULONG WINAPI joy_config_AddRef( IDirectInputJoyConfig8 *iface )
 586 {
 587     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 588     return IDirectInput7_AddRef( &impl->IDirectInput7W_iface );
 589 }
 590
 591 static ULONG WINAPI joy_config_Release( IDirectInputJoyConfig8 *iface )
 592 {
 593     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 594     return IDirectInput7_Release( &impl->IDirectInput7W_iface );
 595 }
 596
 597 static HRESULT WINAPI joy_config_Acquire( IDirectInputJoyConfig8 *iface )
 598 {
 599     FIXME( "iface %p stub!\n", iface );
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI joy_config_Unacquire( IDirectInputJoyConfig8 *iface )
 604 {
 605     FIXME( "iface %p stub!\n", iface );
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI joy_config_SetCooperativeLevel( IDirectInputJoyConfig8 *iface, HWND hwnd, DWORD flags )
 610 {
 611     FIXME( "iface %p, hwnd %p, flags %#lx stub!\n", iface, hwnd, flags );
 612     return E_NOTIMPL;
 613 }
 614
 615 static HRESULT WINAPI joy_config_SendNotify( IDirectInputJoyConfig8 *iface )
 616 {
 617     FIXME( "iface %p stub!\n", iface );
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI joy_config_EnumTypes( IDirectInputJoyConfig8 *iface, LPDIJOYTYPECALLBACK callback, void *context )
 622 {
 623     FIXME( "iface %p, callback %p, context %p stub!\n", iface, callback, context );
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI joy_config_GetTypeInfo( IDirectInputJoyConfig8 *iface, const WCHAR *name,
 628                                               DIJOYTYPEINFO *info, DWORD flags )
 629 {
 630     FIXME( "iface %p, name %s, info %p, flags %#lx stub!\n", iface, debugstr_w(name), info, flags );
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI joy_config_SetTypeInfo( IDirectInputJoyConfig8 *iface, const WCHAR *name,
 635                                               const DIJOYTYPEINFO *info, DWORD flags, WCHAR *new_name )
 636 {
 637     FIXME( "iface %p, name %s, info %p, flags %#lx, new_name %s stub!\n", iface, debugstr_w(name),
 638            info, flags, debugstr_w(new_name) );
 639     return E_NOTIMPL;
 640 }
 641
 642 static HRESULT WINAPI joy_config_DeleteType( IDirectInputJoyConfig8 *iface, const WCHAR *name )
 643 {
 644     FIXME( "iface %p, name %s stub!\n", iface, debugstr_w(name) );
 645     return E_NOTIMPL;
 646 }
 647
 648 struct find_device_from_index_params
 649 {
 650     UINT index;
 651     DIDEVICEINSTANCEW instance;
 652 };
 653
 654 static BOOL CALLBACK find_device_from_index( const DIDEVICEINSTANCEW *instance, void *context )
 655 {
 656     struct find_device_from_index_params *params = context;
 657     params->instance = *instance;
 658     if (!params->index--) return DIENUM_STOP;
 659     return DIENUM_CONTINUE;
 660 }
 661
 662 static HRESULT WINAPI joy_config_GetConfig( IDirectInputJoyConfig8 *iface, UINT id, DIJOYCONFIG *info, DWORD flags )
 663 {
 664     struct dinput *impl = impl_from_IDirectInputJoyConfig8( iface );
 665     struct find_device_from_index_params params = {.index = id};
 666     HRESULT hr;
 667
 668     FIXME( "iface %p, id %u, info %p, flags %#lx stub!\n", iface, id, info, flags );
 669
 670 #define X(x) if (flags & x) FIXME("\tflags |= "#x"\n");
 671     X(DIJC_GUIDINSTANCE)
 672     X(DIJC_REGHWCONFIGTYPE)
 673     X(DIJC_GAIN)
 674     X(DIJC_CALLOUT)
 675 #undef X
 676
 677     hr = IDirectInput8_EnumDevices( &impl->IDirectInput8W_iface, DI8DEVCLASS_GAMECTRL,
 678                                     find_device_from_index, &params, 0 );
 679     if (FAILED(hr)) return hr;
 680     if (params.index != ~0) return DIERR_NOMOREITEMS;
 681     if (flags & DIJC_GUIDINSTANCE) info->guidInstance = params.instance.guidInstance;
 682     return DI_OK;
 683 }
 684
 685 static HRESULT WINAPI joy_config_SetConfig( IDirectInputJoyConfig8 *iface, UINT id, const DIJOYCONFIG *info, DWORD flags )
 686 {
 687     FIXME( "iface %p, id %u, info %p, flags %#lx stub!\n", iface, id, info, flags );
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI joy_config_DeleteConfig( IDirectInputJoyConfig8 *iface, UINT id )
 692 {
 693     FIXME( "iface %p, id %u stub!\n", iface, id );
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI joy_config_GetUserValues( IDirectInputJoyConfig8 *iface, DIJOYUSERVALUES *info, DWORD flags )
 698 {
 699     FIXME( "iface %p, info %p, flags %#lx stub!\n", iface, info, flags );
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI joy_config_SetUserValues( IDirectInputJoyConfig8 *iface, const DIJOYUSERVALUES *info, DWORD flags )
 704 {
 705     FIXME( "iface %p, info %p, flags %#lx stub!\n", iface, info, flags );
 706     return E_NOTIMPL;
 707 }
 708
 709 static HRESULT WINAPI joy_config_AddNewHardware( IDirectInputJoyConfig8 *iface, HWND hwnd, const GUID *guid )
 710 {
 711     FIXME( "iface %p, hwnd %p, guid %s stub!\n", iface, hwnd, debugstr_guid( guid ) );
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI joy_config_OpenTypeKey( IDirectInputJoyConfig8 *iface, const WCHAR *name, DWORD security, HKEY *key )
 716 {
 717     FIXME( "iface %p, name %s, security %lu, key %p stub!\n", iface, debugstr_w(name), security, key );
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI joy_config_OpenAppStatusKey( IDirectInputJoyConfig8 *iface, HKEY *key )
 722 {
 723     FIXME( "iface %p, key %p stub!\n", iface, key );
 724     return E_NOTIMPL;
 725 }
 726
 727 static const IDirectInput7WVtbl dinput7_vtbl =
 728 {
 729     dinput7_QueryInterface,
 730     dinput7_AddRef,
 731     dinput7_Release,
 732     dinput7_CreateDevice,
 733     dinput7_EnumDevices,
 734     dinput7_GetDeviceStatus,
 735     dinput7_RunControlPanel,
 736     dinput7_Initialize,
 737     dinput7_FindDevice,
 738     dinput7_CreateDeviceEx,
 739 };
 740
 741 static const IDirectInput8WVtbl dinput8_vtbl =
 742 {
 743     dinput8_QueryInterface,
 744     dinput8_AddRef,
 745     dinput8_Release,
 746     dinput8_CreateDevice,
 747     dinput8_EnumDevices,
 748     dinput8_GetDeviceStatus,
 749     dinput8_RunControlPanel,
 750     dinput8_Initialize,
 751     dinput8_FindDevice,
 752     dinput8_EnumDevicesBySemantics,
 753     dinput8_ConfigureDevices,
 754 };
 755
 756 static const IDirectInputJoyConfig8Vtbl joy_config_vtbl =
 757 {
 758     joy_config_QueryInterface,
 759     joy_config_AddRef,
 760     joy_config_Release,
 761     joy_config_Acquire,
 762     joy_config_Unacquire,
 763     joy_config_SetCooperativeLevel,
 764     joy_config_SendNotify,
 765     joy_config_EnumTypes,
 766     joy_config_GetTypeInfo,
 767     joy_config_SetTypeInfo,
 768     joy_config_DeleteType,
 769     joy_config_GetConfig,
 770     joy_config_SetConfig,
 771     joy_config_DeleteConfig,
 772     joy_config_GetUserValues,
 773     joy_config_SetUserValues,
 774     joy_config_AddNewHardware,
 775     joy_config_OpenTypeKey,
 776     joy_config_OpenAppStatusKey,
 777 };
 778
 779 static HRESULT dinput_create( IUnknown **out )
 780 {
 781     struct dinput *impl;
 782
 783     if (!(impl = calloc( 1, sizeof(struct dinput) ))) return E_OUTOFMEMORY;
 784     impl->IDirectInput7A_iface.lpVtbl = &dinput7_a_vtbl;
 785     impl->IDirectInput7W_iface.lpVtbl = &dinput7_vtbl;
 786     impl->IDirectInput8A_iface.lpVtbl = &dinput8_a_vtbl;
 787     impl->IDirectInput8W_iface.lpVtbl = &dinput8_vtbl;
 788     impl->IDirectInputJoyConfig8_iface.lpVtbl = &joy_config_vtbl;
 789     impl->internal_ref = 1;
 790     impl->ref = 1;
 791
 792     list_init( &impl->device_players );
 793
 794 #if DIRECTINPUT_VERSION == 0x0700
 795     *out = (IUnknown *)&impl->IDirectInput7W_iface;
 796 #else
 797     *out = (IUnknown *)&impl->IDirectInput8W_iface;
 798 #endif
 799
 800     input_thread_add_user();
 801     return DI_OK;
 802 }
 803
 804 struct class_factory
 805 {
 806     IClassFactory IClassFactory_iface;
 807 };
 808
 809 static inline struct class_factory *impl_from_IClassFactory( IClassFactory *iface )
 810 {
 811     return CONTAINING_RECORD( iface, struct class_factory, IClassFactory_iface );
 812 }
 813
 814 static HRESULT WINAPI class_factory_QueryInterface( IClassFactory *iface, REFIID iid, void **out )
 815 {
 816     struct class_factory *impl = impl_from_IClassFactory( iface );
 817
 818     TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
 819
 820     if (IsEqualGUID( iid, &IID_IUnknown ) ||
 821         IsEqualGUID( iid, &IID_IClassFactory ))
 822         *out = &impl->IClassFactory_iface;
 823     else
 824     {
 825         *out = NULL;
 826         WARN( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
 827         return E_NOINTERFACE;
 828     }
 829
 830     IUnknown_AddRef( (IUnknown *)*out );
 831     return S_OK;
 832 }
 833
 834 static ULONG WINAPI class_factory_AddRef( IClassFactory *iface )
 835 {
 836     return 2;
 837 }
 838
 839 static ULONG WINAPI class_factory_Release( IClassFactory *iface )
 840 {
 841     return 1;
 842 }
 843
 844 static HRESULT WINAPI class_factory_CreateInstance( IClassFactory *iface, IUnknown *outer, REFIID iid, void **out )
 845 {
 846     IUnknown *unknown;
 847     HRESULT hr;
 848
 849     TRACE( "iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid( iid ), out );
 850
 851     if (outer) return CLASS_E_NOAGGREGATION;
 852
 853     if (FAILED(hr = dinput_create( &unknown ))) return hr;
 854     hr = IUnknown_QueryInterface( unknown, iid, out );
 855     IUnknown_Release( unknown );
 856
 857     return hr;
 858 }
 859
 860 static HRESULT WINAPI class_factory_LockServer( IClassFactory *iface, BOOL lock )
 861 {
 862     FIXME( "iface %p, lock %d stub!\n", iface, lock );
 863     return S_OK;
 864 }
 865
 866 static const IClassFactoryVtbl class_factory_vtbl =
 867 {
 868     class_factory_QueryInterface,
 869     class_factory_AddRef,
 870     class_factory_Release,
 871     class_factory_CreateInstance,
 872     class_factory_LockServer,
 873 };
 874
 875 static struct class_factory class_factory = {{&class_factory_vtbl}};
 876
 877 HRESULT WINAPI DllGetClassObject( REFCLSID clsid, REFIID iid, void **out )
 878 {
 879     TRACE( "clsid %s, iid %s, out %p.\n", debugstr_guid( clsid ), debugstr_guid( iid ), out );
 880
 881 #if DIRECTINPUT_VERSION == 0x0700
 882     if (IsEqualCLSID( &CLSID_DirectInput, clsid ))
 883         return IClassFactory_QueryInterface( &class_factory.IClassFactory_iface, iid, out );
 884 #else
 885     if (IsEqualCLSID( &CLSID_DirectInput8, clsid ))
 886         return IClassFactory_QueryInterface( &class_factory.IClassFactory_iface, iid, out );
 887 #endif
 888
 889     WARN( "%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid( clsid ) );
 890     return CLASS_E_CLASSNOTAVAILABLE;
 891 }
 892
 893 HRESULT WINAPI DirectInputCreateEx( HINSTANCE hinst, DWORD version, REFIID iid, void **out, IUnknown *outer )
 894 {
 895     IUnknown *unknown;
 896     HRESULT hr;
 897
 898     TRACE( "hinst %p, version %#lx, iid %s, out %p, outer %p.\n", hinst, version, debugstr_guid( iid ), out, outer );
 899
 900     if (!IsEqualGUID( &IID_IDirectInputA, iid ) &&
 901         !IsEqualGUID( &IID_IDirectInputW, iid ) &&
 902         !IsEqualGUID( &IID_IDirectInput2A, iid ) &&
 903         !IsEqualGUID( &IID_IDirectInput2W, iid ) &&
 904         !IsEqualGUID( &IID_IDirectInput7A, iid ) &&
 905         !IsEqualGUID( &IID_IDirectInput7W, iid ))
 906         return DIERR_NOINTERFACE;
 907
 908     if (FAILED(hr = dinput_create( &unknown ))) return hr;
 909     hr = IUnknown_QueryInterface( unknown, iid, out );
 910     IUnknown_Release( unknown );
 911     if (FAILED(hr)) return hr;
 912
 913     if (outer || FAILED(hr = IDirectInput7_Initialize( (IDirectInput7W *)unknown, hinst, version )))
 914     {
 915         IUnknown_Release( unknown );
 916         *out = NULL;
 917         return hr;
 918     }
 919
 920     return DI_OK;
 921 }
 922
 923 HRESULT WINAPI DECLSPEC_HOTPATCH DirectInput8Create( HINSTANCE hinst, DWORD version, REFIID iid, void **out, IUnknown *outer )
 924 {
 925     IUnknown *unknown;
 926     HRESULT hr;
 927
 928     TRACE( "hinst %p, version %#lx, iid %s, out %p, outer %p.\n", hinst, version, debugstr_guid( iid ), out, outer );
 929
 930     if (!out) return E_POINTER;
 931
 932     if (!IsEqualGUID( &IID_IDirectInput8A, iid ) &&
 933         !IsEqualGUID( &IID_IDirectInput8W, iid ) &&
 934         !IsEqualGUID( &IID_IUnknown, iid ))
 935     {
 936         *out = NULL;
 937         return DIERR_NOINTERFACE;
 938     }
 939
 940     if (FAILED(hr = dinput_create( &unknown ))) return hr;
 941     hr = IUnknown_QueryInterface( unknown, iid, out );
 942     IUnknown_Release( unknown );
 943     if (FAILED(hr)) return hr;
 944
 945     if (outer || FAILED(hr = IDirectInput8_Initialize( (IDirectInput8W *)unknown, hinst, version )))
 946     {
 947         IUnknown_Release( unknown );
 948         *out = NULL;
 949         return hr;
 950     }
 951
 952     return S_OK;
 953 }
 954
 955 HRESULT WINAPI DECLSPEC_HOTPATCH DirectInputCreateA( HINSTANCE hinst, DWORD version, IDirectInputA **out, IUnknown *outer )
 956 {
 957     return DirectInputCreateEx( hinst, version, &IID_IDirectInput7A, (void **)out, outer );
 958 }
 959
 960 HRESULT WINAPI DECLSPEC_HOTPATCH DirectInputCreateW( HINSTANCE hinst, DWORD version, IDirectInputW **out, IUnknown *outer )
 961 {
 962     return DirectInputCreateEx( hinst, version, &IID_IDirectInput7W, (void **)out, outer );
 963 }