dlls/dinput/device.c

   1 /*              DirectInput Device
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  *
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* This file contains all the Device specific functions that can be used as stubs
  23    by real device implementations.
  24
  25    It also contains all the helper functions.
  26 */
  27 #include "config.h"
  28
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winerror.h"
  36 #include "dinput.h"
  37 #include "device_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  40
  41 /******************************************************************************
  42  *      Various debugging tools
  43  */
  44 void _dump_cooperativelevel_DI(DWORD dwFlags) {
  45     if (TRACE_ON(dinput)) {
  46         unsigned int   i;
  47         static const struct {
  48             DWORD       mask;
  49             const char  *name;
  50         } flags[] = {
  51 #define FE(x) { x, #x}
  52             FE(DISCL_BACKGROUND),
  53             FE(DISCL_EXCLUSIVE),
  54             FE(DISCL_FOREGROUND),
  55             FE(DISCL_NONEXCLUSIVE)
  56 #undef FE
  57         };
  58         for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++)
  59             if (flags[i].mask & dwFlags)
  60                 DPRINTF("%s ",flags[i].name);
  61         DPRINTF("\n");
  62     }
  63 }
  64
  65 void _dump_EnumObjects_flags(DWORD dwFlags) {
  66     if (TRACE_ON(dinput)) {
  67         unsigned int   i;
  68         DWORD type, instance;
  69         static const struct {
  70             DWORD       mask;
  71             const char  *name;
  72         } flags[] = {
  73 #define FE(x) { x, #x}
  74             FE(DIDFT_RELAXIS),
  75             FE(DIDFT_ABSAXIS),
  76             FE(DIDFT_PSHBUTTON),
  77             FE(DIDFT_TGLBUTTON),
  78             FE(DIDFT_POV),
  79             FE(DIDFT_COLLECTION),
  80             FE(DIDFT_NODATA),
  81             FE(DIDFT_FFACTUATOR),
  82             FE(DIDFT_FFEFFECTTRIGGER),
  83             FE(DIDFT_OUTPUT)
  84 #undef FE
  85         };
  86         type = (dwFlags & 0xFF0000FF);
  87         instance = ((dwFlags >> 8) & 0xFFFF);
  88         DPRINTF("Type:");
  89         if (type == DIDFT_ALL) {
  90             DPRINTF(" DIDFT_ALL");
  91         } else {
  92             for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++) {
  93                 if (flags[i].mask & type) {
  94                     type &= ~flags[i].mask;
  95                     DPRINTF(" %s",flags[i].name);
  96                 }
  97             }
  98             if (type) {
  99                 DPRINTF(" (unhandled: %08lx)", type);
 100             }
 101         }
 102         DPRINTF(" / Instance: ");
 103         if (instance == ((DIDFT_ANYINSTANCE >> 8) & 0xFFFF)) {
 104             DPRINTF("DIDFT_ANYINSTANCE");
 105         } else {
 106             DPRINTF("%3ld", instance);
 107         }
 108     }
 109 }
 110
 111 void _dump_DIPROPHEADER(LPCDIPROPHEADER diph) {
 112     if (TRACE_ON(dinput)) {
 113         DPRINTF("  - dwObj = 0x%08lx\n", diph->dwObj);
 114         DPRINTF("  - dwHow = %s\n",
 115                 ((diph->dwHow == DIPH_DEVICE) ? "DIPH_DEVICE" :
 116                  ((diph->dwHow == DIPH_BYOFFSET) ? "DIPH_BYOFFSET" :
 117                   ((diph->dwHow == DIPH_BYID)) ? "DIPH_BYID" : "unknown")));
 118     }
 119 }
 120
 121 void _dump_OBJECTINSTANCEA(DIDEVICEOBJECTINSTANCEA *ddoi) {
 122     if (TRACE_ON(dinput)) {
 123         DPRINTF("    - enumerating : %s ('%s') - %2ld - 0x%08lx - %s\n",
 124                 debugstr_guid(&ddoi->guidType), _dump_dinput_GUID(&ddoi->guidType), ddoi->dwOfs, ddoi->dwType, ddoi->tszName);
 125     }
 126 }
 127
 128 void _dump_OBJECTINSTANCEW(DIDEVICEOBJECTINSTANCEW *ddoi) {
 129     if (TRACE_ON(dinput)) {
 130         DPRINTF("    - enumerating : %s ('%s'), - %2ld - 0x%08lx - %s\n",
 131                 debugstr_guid(&ddoi->guidType), _dump_dinput_GUID(&ddoi->guidType), ddoi->dwOfs, ddoi->dwType, debugstr_w(ddoi->tszName));
 132     }
 133 }
 134
 135 /* This function is a helper to convert a GUID into any possible DInput GUID out there */
 136 const char *_dump_dinput_GUID(const GUID *guid) {
 137     unsigned int i;
 138     static const struct {
 139         const GUID *guid;
 140         const char *name;
 141     } guids[] = {
 142 #define FE(x) { &x, #x}
 143         FE(GUID_XAxis),
 144         FE(GUID_YAxis),
 145         FE(GUID_ZAxis),
 146         FE(GUID_RxAxis),
 147         FE(GUID_RyAxis),
 148         FE(GUID_RzAxis),
 149         FE(GUID_Slider),
 150         FE(GUID_Button),
 151         FE(GUID_Key),
 152         FE(GUID_POV),
 153         FE(GUID_Unknown),
 154         FE(GUID_SysMouse),
 155         FE(GUID_SysKeyboard),
 156         FE(GUID_Joystick),
 157         FE(GUID_ConstantForce),
 158         FE(GUID_RampForce),
 159         FE(GUID_Square),
 160         FE(GUID_Sine),
 161         FE(GUID_Triangle),
 162         FE(GUID_SawtoothUp),
 163         FE(GUID_SawtoothDown),
 164         FE(GUID_Spring),
 165         FE(GUID_Damper),
 166         FE(GUID_Inertia),
 167         FE(GUID_Friction),
 168         FE(GUID_CustomForce)
 169 #undef FE
 170     };
 171     if (guid == NULL)
 172         return "null GUID";
 173     for (i = 0; i < (sizeof(guids) / sizeof(guids[0])); i++) {
 174         if (IsEqualGUID(guids[i].guid, guid)) {
 175             return guids[i].name;
 176         }
 177     }
 178     return "Unknown GUID";
 179 }
 180
 181 void _dump_DIDATAFORMAT(const DIDATAFORMAT *df) {
 182     unsigned int i;
 183
 184     TRACE("Dumping DIDATAFORMAT structure:\n");
 185     TRACE("  - dwSize: %ld\n", df->dwSize);
 186     if (df->dwSize != sizeof(DIDATAFORMAT)) {
 187         WARN("Non-standard DIDATAFORMAT structure size (%ld instead of %d).\n", df->dwSize, sizeof(DIDATAFORMAT));
 188     }
 189     TRACE("  - dwObjsize: %ld\n", df->dwObjSize);
 190     if (df->dwObjSize != sizeof(DIOBJECTDATAFORMAT)) {
 191         WARN("Non-standard DIOBJECTDATAFORMAT structure size (%ld instead of %d).\n", df->dwObjSize, sizeof(DIOBJECTDATAFORMAT));
 192     }
 193     TRACE("  - dwFlags: 0x%08lx (", df->dwFlags);
 194     switch (df->dwFlags) {
 195         case DIDF_ABSAXIS: TRACE("DIDF_ABSAXIS"); break;
 196         case DIDF_RELAXIS: TRACE("DIDF_RELAXIS"); break;
 197         default: TRACE("unknown"); break;
 198     }
 199     TRACE(")\n");
 200     TRACE("  - dwDataSize: %ld\n", df->dwDataSize);
 201     TRACE("  - dwNumObjs: %ld\n", df->dwNumObjs);
 202
 203     for (i = 0; i < df->dwNumObjs; i++) {
 204         TRACE("  - Object %d:\n", i);
 205         TRACE("      * GUID: %s ('%s')\n", debugstr_guid(df->rgodf[i].pguid), _dump_dinput_GUID(df->rgodf[i].pguid));
 206         TRACE("      * dwOfs: %ld\n", df->rgodf[i].dwOfs);
 207         TRACE("      * dwType: 0x%08lx\n", df->rgodf[i].dwType);
 208         TRACE("        "); _dump_EnumObjects_flags(df->rgodf[i].dwType); TRACE("\n");
 209         TRACE("      * dwFlags: 0x%08lx\n", df->rgodf[i].dwFlags);
 210     }
 211 }
 212
 213 /* Conversion between internal data buffer and external data buffer */
 214 void fill_DataFormat(void *out, const void *in, DataFormat *df) {
 215     int i;
 216     char *in_c = (char *) in;
 217     char *out_c = (char *) out;
 218
 219     if (df->dt == NULL) {
 220         /* This means that the app uses Wine's internal data format */
 221         memcpy(out, in, df->internal_format_size);
 222     } else {
 223         for (i = 0; i < df->size; i++) {
 224             if (df->dt[i].offset_in >= 0) {
 225                 switch (df->dt[i].size) {
 226                     case 1:
 227                         TRACE("Copying (c) to %d from %d (value %d)\n",
 228                               df->dt[i].offset_out, df->dt[i].offset_in, *((char *) (in_c + df->dt[i].offset_in)));
 229                         *((char *) (out_c + df->dt[i].offset_out)) = *((char *) (in_c + df->dt[i].offset_in));
 230                         break;
 231
 232                     case 2:
 233                         TRACE("Copying (s) to %d from %d (value %d)\n",
 234                               df->dt[i].offset_out, df->dt[i].offset_in, *((short *) (in_c + df->dt[i].offset_in)));
 235                         *((short *) (out_c + df->dt[i].offset_out)) = *((short *) (in_c + df->dt[i].offset_in));
 236                         break;
 237
 238                     case 4:
 239                         TRACE("Copying (i) to %d from %d (value %d)\n",
 240                               df->dt[i].offset_out, df->dt[i].offset_in, *((int *) (in_c + df->dt[i].offset_in)));
 241                         *((int *) (out_c + df->dt[i].offset_out)) = *((int *) (in_c + df->dt[i].offset_in));
 242                         break;
 243
 244                     default:
 245                         memcpy((out_c + df->dt[i].offset_out), (in_c + df->dt[i].offset_in), df->dt[i].size);
 246                         break;
 247                 }
 248             } else {
 249                 switch (df->dt[i].size) {
 250                     case 1:
 251                         TRACE("Copying (c) to %d default value %d\n",
 252                               df->dt[i].offset_out, df->dt[i].value);
 253                         *((char *) (out_c + df->dt[i].offset_out)) = (char) df->dt[i].value;
 254                         break;
 255
 256                     case 2:
 257                         TRACE("Copying (s) to %d default value %d\n",
 258                               df->dt[i].offset_out, df->dt[i].value);
 259                         *((short *) (out_c + df->dt[i].offset_out)) = (short) df->dt[i].value;
 260                         break;
 261
 262                     case 4:
 263                         TRACE("Copying (i) to %d default value %d\n",
 264                               df->dt[i].offset_out, df->dt[i].value);
 265                         *((int *) (out_c + df->dt[i].offset_out)) = (int) df->dt[i].value;
 266                         break;
 267
 268                     default:
 269                         memset((out_c + df->dt[i].offset_out), df->dt[i].size, 0);
 270                         break;
 271                 }
 272             }
 273         }
 274     }
 275 }
 276
 277 void release_DataFormat(DataFormat * format)
 278 {
 279     TRACE("Deleting DataTransform : \n");
 280
 281     HeapFree(GetProcessHeap(), 0, format->dt);
 282 }
 283
 284 DataFormat *create_DataFormat(const DIDATAFORMAT *wine_format, LPCDIDATAFORMAT asked_format, int *offset) {
 285     DataFormat *ret;
 286     DataTransform *dt;
 287     unsigned int i, j;
 288     int same = 1;
 289     int *done;
 290     int index = 0;
 291     DWORD next = 0;
 292
 293     ret = (DataFormat *) HeapAlloc(GetProcessHeap(), 0, sizeof(DataFormat));
 294
 295     done = (int *) HeapAlloc(GetProcessHeap(), 0, sizeof(int) * asked_format->dwNumObjs);
 296     memset(done, 0, sizeof(int) * asked_format->dwNumObjs);
 297
 298     dt = (DataTransform *) HeapAlloc(GetProcessHeap(), 0, asked_format->dwNumObjs * sizeof(DataTransform));
 299
 300     TRACE("Creating DataTransform : \n");
 301
 302     for (i = 0; i < wine_format->dwNumObjs; i++) {
 303         offset[i] = -1;
 304
 305         for (j = 0; j < asked_format->dwNumObjs; j++) {
 306             if (done[j] == 1)
 307                 continue;
 308
 309             if (/* Check if the application either requests any GUID and if not, it if matches
 310                  * the GUID of the Wine object.
 311                  */
 312                 ((asked_format->rgodf[j].pguid == NULL) ||
 313                  (IsEqualGUID(wine_format->rgodf[i].pguid, asked_format->rgodf[j].pguid)))
 314                 &&
 315                 (/* Then check if it accepts any instance id, and if not, if it matches Wine's
 316                   * instance id.
 317                   */
 318                  ((asked_format->rgodf[j].dwType & 0x00FFFF00) == DIDFT_ANYINSTANCE) ||
 319                  (DIDFT_GETINSTANCE(wine_format->rgodf[i].dwType) == DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType)))) {
 320
 321                 done[j] = 1;
 322
 323                 TRACE("Matching : \n");
 324                 TRACE("   - Asked (%d) :\n", j);
 325                 TRACE("       * GUID: %s ('%s')\n",
 326                       debugstr_guid(asked_format->rgodf[j].pguid),
 327                       _dump_dinput_GUID(asked_format->rgodf[j].pguid));
 328                 TRACE("       * Offset: %3ld\n", asked_format->rgodf[j].dwOfs);
 329                 TRACE("       * dwType: %08lx\n", asked_format->rgodf[j].dwType);
 330                 TRACE("         "); _dump_EnumObjects_flags(asked_format->rgodf[j].dwType); TRACE("\n");
 331
 332                 TRACE("   - Wine  (%d) :\n", j);
 333                 TRACE("       * GUID: %s ('%s')\n",
 334                       debugstr_guid(wine_format->rgodf[j].pguid),
 335                       _dump_dinput_GUID(wine_format->rgodf[j].pguid));
 336                 TRACE("       * Offset: %3ld\n", wine_format->rgodf[j].dwOfs);
 337                 TRACE("       * dwType: %08lx\n", wine_format->rgodf[j].dwType);
 338                 TRACE("         "); _dump_EnumObjects_flags(wine_format->rgodf[j].dwType); TRACE("\n");
 339
 340                 if (wine_format->rgodf[i].dwType & DIDFT_BUTTON)
 341                     dt[index].size = sizeof(BYTE);
 342                 else
 343                     dt[index].size = sizeof(DWORD);
 344                 dt[index].offset_in  = wine_format ->rgodf[i].dwOfs;
 345                 if (asked_format->rgodf[j].dwOfs < next) {
 346                     WARN("bad format: dwOfs=%ld, changing to %ld\n", asked_format->rgodf[j].dwOfs, next);
 347                     dt[index].offset_out = next;
 348                     offset[i] = next;
 349                 } else {
 350                     dt[index].offset_out = asked_format->rgodf[j].dwOfs;
 351                     offset[i] = asked_format->rgodf[j].dwOfs;
 352                 }
 353                 dt[index].value = 0;
 354                 next = next + dt[index].size;
 355
 356                 if (wine_format->rgodf[i].dwOfs != dt[index].offset_out)
 357                     same = 0;
 358
 359                 index++;
 360                 break;
 361             }
 362         }
 363
 364         if (j == asked_format->dwNumObjs)
 365             same = 0;
 366     }
 367
 368     TRACE("Setting to default value :\n");
 369     for (j = 0; j < asked_format->dwNumObjs; j++) {
 370         if (done[j] == 0) {
 371             TRACE("   - Asked (%d) :\n", j);
 372             TRACE("       * GUID: %s ('%s')\n",
 373                   debugstr_guid(asked_format->rgodf[j].pguid),
 374                   _dump_dinput_GUID(asked_format->rgodf[j].pguid));
 375             TRACE("       * Offset: %3ld\n", asked_format->rgodf[j].dwOfs);
 376             TRACE("       * dwType: %08lx\n", asked_format->rgodf[j].dwType);
 377             TRACE("         "); _dump_EnumObjects_flags(asked_format->rgodf[j].dwType); TRACE("\n");
 378
 379             if (asked_format->rgodf[j].dwType & DIDFT_BUTTON)
 380                 dt[index].size = sizeof(BYTE);
 381             else
 382                 dt[index].size = sizeof(DWORD);
 383             dt[index].offset_in  = -1;
 384             dt[index].offset_out = asked_format->rgodf[j].dwOfs;
 385             dt[index].value = 0;
 386             index++;
 387
 388             same = 0;
 389         }
 390     }
 391
 392     ret->internal_format_size = wine_format->dwDataSize;
 393     ret->size = index;
 394     if (same) {
 395         ret->dt = NULL;
 396         HeapFree(GetProcessHeap(), 0, dt);
 397     } else {
 398         ret->dt = dt;
 399     }
 400
 401     HeapFree(GetProcessHeap(), 0, done);
 402
 403     return ret;
 404 }
 405
 406 BOOL DIEnumDevicesCallbackAtoW(LPCDIDEVICEOBJECTINSTANCEA lpddi, LPVOID lpvRef) {
 407     DIDEVICEOBJECTINSTANCEW ddtmp;
 408     device_enumobjects_AtoWcb_data* data;
 409
 410     data = (device_enumobjects_AtoWcb_data*) lpvRef;
 411
 412     memset(&ddtmp, 0, sizeof(DIDEVICEINSTANCEW));
 413
 414     ddtmp.dwSize = sizeof(DIDEVICEINSTANCEW);
 415     ddtmp.guidType     = lpddi->guidType;
 416     ddtmp.dwOfs        = lpddi->dwOfs;
 417     ddtmp.dwType       = lpddi->dwType;
 418     ddtmp.dwFlags      = lpddi->dwFlags;
 419     MultiByteToWideChar(CP_ACP, 0, lpddi->tszName, -1, ddtmp.tszName, MAX_PATH);
 420
 421     if (lpddi->dwSize == sizeof(DIDEVICEINSTANCEA)) {
 422         /**
 423          * if dwSize < sizeof(DIDEVICEINSTANCEA of DInput version >= 5)
 424          *  force feedback and other newer datas aren't available
 425          */
 426         ddtmp.dwFFMaxForce        = lpddi->dwFFMaxForce;
 427         ddtmp.dwFFForceResolution = lpddi->dwFFForceResolution;
 428         ddtmp.wCollectionNumber   = lpddi->wCollectionNumber;
 429         ddtmp.wDesignatorIndex    = lpddi->wDesignatorIndex;
 430         ddtmp.wUsagePage          = lpddi->wUsagePage;
 431         ddtmp.wUsage              = lpddi->wUsage;
 432         ddtmp.dwDimension         = lpddi->dwDimension;
 433         ddtmp.wExponent           = lpddi->wExponent;
 434         ddtmp.wReserved           = lpddi->wReserved;
 435     }
 436     return data->lpCallBack(&ddtmp, data->lpvRef);
 437 }
 438
 439 /******************************************************************************
 440  *      IDirectInputDeviceA
 441  */
 442
 443 HRESULT WINAPI IDirectInputDevice2AImpl_SetDataFormat(
 444         LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
 445 ) {
 446     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 447
 448     TRACE("(this=%p,%p)\n",This,df);
 449
 450     _dump_DIDATAFORMAT(df);
 451
 452     return DI_OK;
 453 }
 454
 455 HRESULT WINAPI IDirectInputDevice2AImpl_SetCooperativeLevel(
 456         LPDIRECTINPUTDEVICE8A iface,HWND hwnd,DWORD dwflags
 457 ) {
 458     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 459     TRACE("(this=%p,0x%08lx,0x%08lx)\n",This,(DWORD)hwnd,dwflags);
 460     if (TRACE_ON(dinput)) {
 461         TRACE(" cooperative level : ");
 462         _dump_cooperativelevel_DI(dwflags);
 463     }
 464     return DI_OK;
 465 }
 466
 467 HRESULT WINAPI IDirectInputDevice2AImpl_SetEventNotification(
 468         LPDIRECTINPUTDEVICE8A iface,HANDLE hnd
 469 ) {
 470     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 471     FIXME("(this=%p,0x%08lx): stub\n",This,(DWORD)hnd);
 472     return DI_OK;
 473 }
 474
 475 ULONG WINAPI IDirectInputDevice2AImpl_Release(LPDIRECTINPUTDEVICE8A iface)
 476 {
 477     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 478     ULONG ref;
 479     ref = InterlockedDecrement(&(This->ref));
 480     if (ref == 0)
 481         HeapFree(GetProcessHeap(),0,This);
 482     return ref;
 483 }
 484
 485 HRESULT WINAPI IDirectInputDevice2AImpl_QueryInterface(
 486         LPDIRECTINPUTDEVICE8A iface,REFIID riid,LPVOID *ppobj
 487 )
 488 {
 489     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 490
 491     TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 492     if (IsEqualGUID(&IID_IUnknown,riid)) {
 493         IDirectInputDevice2_AddRef(iface);
 494         *ppobj = This;
 495         return DI_OK;
 496     }
 497     if (IsEqualGUID(&IID_IDirectInputDeviceA,riid)) {
 498         IDirectInputDevice2_AddRef(iface);
 499         *ppobj = This;
 500         return DI_OK;
 501     }
 502     if (IsEqualGUID(&IID_IDirectInputDevice2A,riid)) {
 503         IDirectInputDevice2_AddRef(iface);
 504         *ppobj = This;
 505         return DI_OK;
 506     }
 507     if (IsEqualGUID(&IID_IDirectInputDevice7A,riid)) {
 508         IDirectInputDevice7_AddRef(iface);
 509         *ppobj = This;
 510         return DI_OK;
 511     }
 512     TRACE("Unsupported interface !\n");
 513     return E_FAIL;
 514 }
 515
 516 HRESULT WINAPI IDirectInputDevice2WImpl_QueryInterface(
 517         LPDIRECTINPUTDEVICE8W iface,REFIID riid,LPVOID *ppobj
 518 )
 519 {
 520     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 521
 522     TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 523     if (IsEqualGUID(&IID_IUnknown,riid)) {
 524         IDirectInputDevice2_AddRef(iface);
 525         *ppobj = This;
 526         return DI_OK;
 527     }
 528     if (IsEqualGUID(&IID_IDirectInputDeviceW,riid)) {
 529         IDirectInputDevice2_AddRef(iface);
 530         *ppobj = This;
 531         return DI_OK;
 532     }
 533     if (IsEqualGUID(&IID_IDirectInputDevice2W,riid)) {
 534         IDirectInputDevice2_AddRef(iface);
 535         *ppobj = This;
 536         return DI_OK;
 537     }
 538     if (IsEqualGUID(&IID_IDirectInputDevice7W,riid)) {
 539         IDirectInputDevice7_AddRef(iface);
 540         *ppobj = This;
 541         return DI_OK;
 542     }
 543     TRACE("Unsupported interface !\n");
 544     return E_FAIL;
 545 }
 546
 547 ULONG WINAPI IDirectInputDevice2AImpl_AddRef(
 548         LPDIRECTINPUTDEVICE8A iface)
 549 {
 550     IDirectInputDevice2AImpl *This = (IDirectInputDevice2AImpl *)iface;
 551     return InterlockedIncrement(&(This->ref));
 552 }
 553
 554 HRESULT WINAPI IDirectInputDevice2AImpl_EnumObjects(
 555         LPDIRECTINPUTDEVICE8A iface,
 556         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
 557         LPVOID lpvRef,
 558         DWORD dwFlags)
 559 {
 560     FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
 561     if (TRACE_ON(dinput)) {
 562         DPRINTF("  - flags = ");
 563         _dump_EnumObjects_flags(dwFlags);
 564         DPRINTF("\n");
 565     }
 566
 567     return DI_OK;
 568 }
 569
 570 HRESULT WINAPI IDirectInputDevice2WImpl_EnumObjects(
 571         LPDIRECTINPUTDEVICE8W iface,
 572         LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
 573         LPVOID lpvRef,
 574         DWORD dwFlags)
 575 {
 576     FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
 577     if (TRACE_ON(dinput)) {
 578         DPRINTF("  - flags = ");
 579         _dump_EnumObjects_flags(dwFlags);
 580         DPRINTF("\n");
 581     }
 582
 583     return DI_OK;
 584 }
 585
 586 HRESULT WINAPI IDirectInputDevice2AImpl_GetProperty(
 587         LPDIRECTINPUTDEVICE8A iface,
 588         REFGUID rguid,
 589         LPDIPROPHEADER pdiph)
 590 {
 591     FIXME("(this=%p,%s,%p): stub!\n",
 592           iface, debugstr_guid(rguid), pdiph);
 593
 594     if (TRACE_ON(dinput))
 595         _dump_DIPROPHEADER(pdiph);
 596
 597     return DI_OK;
 598 }
 599
 600 HRESULT WINAPI IDirectInputDevice2AImpl_GetObjectInfo(
 601         LPDIRECTINPUTDEVICE8A iface,
 602         LPDIDEVICEOBJECTINSTANCEA pdidoi,
 603         DWORD dwObj,
 604         DWORD dwHow)
 605 {
 606     FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
 607           iface, pdidoi, dwObj, dwHow);
 608
 609     return DI_OK;
 610 }
 611
 612 HRESULT WINAPI IDirectInputDevice2WImpl_GetObjectInfo(
 613         LPDIRECTINPUTDEVICE8W iface,
 614         LPDIDEVICEOBJECTINSTANCEW pdidoi,
 615         DWORD dwObj,
 616         DWORD dwHow)
 617 {
 618     FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
 619           iface, pdidoi, dwObj, dwHow);
 620
 621     return DI_OK;
 622 }
 623
 624 HRESULT WINAPI IDirectInputDevice2AImpl_GetDeviceInfo(
 625         LPDIRECTINPUTDEVICE8A iface,
 626         LPDIDEVICEINSTANCEA pdidi)
 627 {
 628     FIXME("(this=%p,%p): stub!\n",
 629           iface, pdidi);
 630
 631     return DI_OK;
 632 }
 633
 634 HRESULT WINAPI IDirectInputDevice2WImpl_GetDeviceInfo(
 635         LPDIRECTINPUTDEVICE8W iface,
 636         LPDIDEVICEINSTANCEW pdidi)
 637 {
 638     FIXME("(this=%p,%p): stub!\n",
 639           iface, pdidi);
 640
 641     return DI_OK;
 642 }
 643
 644 HRESULT WINAPI IDirectInputDevice2AImpl_RunControlPanel(
 645         LPDIRECTINPUTDEVICE8A iface,
 646         HWND hwndOwner,
 647         DWORD dwFlags)
 648 {
 649     FIXME("(this=%p,%p,0x%08lx): stub!\n",
 650           iface, hwndOwner, dwFlags);
 651
 652     return DI_OK;
 653 }
 654
 655 HRESULT WINAPI IDirectInputDevice2AImpl_Initialize(
 656         LPDIRECTINPUTDEVICE8A iface,
 657         HINSTANCE hinst,
 658         DWORD dwVersion,
 659         REFGUID rguid)
 660 {
 661     FIXME("(this=%p,%p,%ld,%s): stub!\n",
 662           iface, hinst, dwVersion, debugstr_guid(rguid));
 663     return DI_OK;
 664 }
 665
 666 /******************************************************************************
 667  *      IDirectInputDevice2A
 668  */
 669
 670 HRESULT WINAPI IDirectInputDevice2AImpl_CreateEffect(
 671         LPDIRECTINPUTDEVICE8A iface,
 672         REFGUID rguid,
 673         LPCDIEFFECT lpeff,
 674         LPDIRECTINPUTEFFECT *ppdef,
 675         LPUNKNOWN pUnkOuter)
 676 {
 677     FIXME("(this=%p,%s,%p,%p,%p): stub!\n",
 678           iface, debugstr_guid(rguid), lpeff, ppdef, pUnkOuter);
 679     return DI_OK;
 680 }
 681
 682 HRESULT WINAPI IDirectInputDevice2AImpl_EnumEffects(
 683         LPDIRECTINPUTDEVICE8A iface,
 684         LPDIENUMEFFECTSCALLBACKA lpCallback,
 685         LPVOID lpvRef,
 686         DWORD dwFlags)
 687 {
 688     FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
 689           iface, lpCallback, lpvRef, dwFlags);
 690
 691     return DI_OK;
 692 }
 693
 694 HRESULT WINAPI IDirectInputDevice2WImpl_EnumEffects(
 695         LPDIRECTINPUTDEVICE8W iface,
 696         LPDIENUMEFFECTSCALLBACKW lpCallback,
 697         LPVOID lpvRef,
 698         DWORD dwFlags)
 699 {
 700     FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
 701           iface, lpCallback, lpvRef, dwFlags);
 702
 703     return DI_OK;
 704 }
 705
 706 HRESULT WINAPI IDirectInputDevice2AImpl_GetEffectInfo(
 707         LPDIRECTINPUTDEVICE8A iface,
 708         LPDIEFFECTINFOA lpdei,
 709         REFGUID rguid)
 710 {
 711     FIXME("(this=%p,%p,%s): stub!\n",
 712           iface, lpdei, debugstr_guid(rguid));
 713     return DI_OK;
 714 }
 715
 716 HRESULT WINAPI IDirectInputDevice2WImpl_GetEffectInfo(
 717         LPDIRECTINPUTDEVICE8W iface,
 718         LPDIEFFECTINFOW lpdei,
 719         REFGUID rguid)
 720 {
 721     FIXME("(this=%p,%p,%s): stub!\n",
 722           iface, lpdei, debugstr_guid(rguid));
 723     return DI_OK;
 724 }
 725
 726 HRESULT WINAPI IDirectInputDevice2AImpl_GetForceFeedbackState(
 727         LPDIRECTINPUTDEVICE8A iface,
 728         LPDWORD pdwOut)
 729 {
 730     FIXME("(this=%p,%p): stub!\n",
 731           iface, pdwOut);
 732     return DI_OK;
 733 }
 734
 735 HRESULT WINAPI IDirectInputDevice2AImpl_SendForceFeedbackCommand(
 736         LPDIRECTINPUTDEVICE8A iface,
 737         DWORD dwFlags)
 738 {
 739     FIXME("(this=%p,0x%08lx): stub!\n",
 740           iface, dwFlags);
 741     return DI_OK;
 742 }
 743
 744 HRESULT WINAPI IDirectInputDevice2AImpl_EnumCreatedEffectObjects(
 745         LPDIRECTINPUTDEVICE8A iface,
 746         LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
 747         LPVOID lpvRef,
 748         DWORD dwFlags)
 749 {
 750     FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
 751           iface, lpCallback, lpvRef, dwFlags);
 752     if (lpCallback)
 753         lpCallback(NULL, lpvRef);
 754     return DI_OK;
 755 }
 756
 757 HRESULT WINAPI IDirectInputDevice2AImpl_Escape(
 758         LPDIRECTINPUTDEVICE8A iface,
 759         LPDIEFFESCAPE lpDIEEsc)
 760 {
 761     FIXME("(this=%p,%p): stub!\n",
 762           iface, lpDIEEsc);
 763     return DI_OK;
 764 }
 765
 766 HRESULT WINAPI IDirectInputDevice2AImpl_Poll(
 767         LPDIRECTINPUTDEVICE8A iface)
 768 {
 769     /* Because wine devices do not need to be polled, just return DI_NOEFFECT */
 770     return DI_NOEFFECT;
 771 }
 772
 773 HRESULT WINAPI IDirectInputDevice2AImpl_SendDeviceData(
 774         LPDIRECTINPUTDEVICE8A iface,
 775         DWORD cbObjectData,
 776         LPCDIDEVICEOBJECTDATA rgdod,
 777         LPDWORD pdwInOut,
 778         DWORD dwFlags)
 779 {
 780     FIXME("(this=%p,0x%08lx,%p,%p,0x%08lx): stub!\n",
 781           iface, cbObjectData, rgdod, pdwInOut, dwFlags);
 782
 783     return DI_OK;
 784 }
 785
 786 HRESULT WINAPI IDirectInputDevice7AImpl_EnumEffectsInFile(LPDIRECTINPUTDEVICE8A iface,
 787                                                           LPCSTR lpszFileName,
 788                                                           LPDIENUMEFFECTSINFILECALLBACK pec,
 789                                                           LPVOID pvRef,
 790                                                           DWORD dwFlags)
 791 {
 792     FIXME("(%p)->(%s,%p,%p,%08lx): stub !\n", iface, lpszFileName, pec, pvRef, dwFlags);
 793
 794     return DI_OK;
 795 }
 796
 797 HRESULT WINAPI IDirectInputDevice7WImpl_EnumEffectsInFile(LPDIRECTINPUTDEVICE8W iface,
 798                                                           LPCWSTR lpszFileName,
 799                                                           LPDIENUMEFFECTSINFILECALLBACK pec,
 800                                                           LPVOID pvRef,
 801                                                           DWORD dwFlags)
 802 {
 803     FIXME("(%p)->(%s,%p,%p,%08lx): stub !\n", iface, debugstr_w(lpszFileName), pec, pvRef, dwFlags);
 804
 805     return DI_OK;
 806 }
 807
 808 HRESULT WINAPI IDirectInputDevice7AImpl_WriteEffectToFile(LPDIRECTINPUTDEVICE8A iface,
 809                                                           LPCSTR lpszFileName,
 810                                                           DWORD dwEntries,
 811                                                           LPDIFILEEFFECT rgDiFileEft,
 812                                                           DWORD dwFlags)
 813 {
 814     FIXME("(%p)->(%s,%08lx,%p,%08lx): stub !\n", iface, lpszFileName, dwEntries, rgDiFileEft, dwFlags);
 815
 816     return DI_OK;
 817 }
 818
 819 HRESULT WINAPI IDirectInputDevice7WImpl_WriteEffectToFile(LPDIRECTINPUTDEVICE8W iface,
 820                                                           LPCWSTR lpszFileName,
 821                                                           DWORD dwEntries,
 822                                                           LPDIFILEEFFECT rgDiFileEft,
 823                                                           DWORD dwFlags)
 824 {
 825     FIXME("(%p)->(%s,%08lx,%p,%08lx): stub !\n", iface, debugstr_w(lpszFileName), dwEntries, rgDiFileEft, dwFlags);
 826
 827     return DI_OK;
 828 }
 829
 830 HRESULT WINAPI IDirectInputDevice8AImpl_BuildActionMap(LPDIRECTINPUTDEVICE8A iface,
 831                                                        LPDIACTIONFORMATA lpdiaf,
 832                                                        LPCSTR lpszUserName,
 833                                                        DWORD dwFlags)
 834 {
 835     FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, lpszUserName, dwFlags);
 836
 837     return DI_OK;
 838 }
 839
 840 HRESULT WINAPI IDirectInputDevice8WImpl_BuildActionMap(LPDIRECTINPUTDEVICE8W iface,
 841                                                        LPDIACTIONFORMATW lpdiaf,
 842                                                        LPCWSTR lpszUserName,
 843                                                        DWORD dwFlags)
 844 {
 845     FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
 846
 847     return DI_OK;
 848 }
 849
 850 HRESULT WINAPI IDirectInputDevice8AImpl_SetActionMap(LPDIRECTINPUTDEVICE8A iface,
 851                                                      LPDIACTIONFORMATA lpdiaf,
 852                                                      LPCSTR lpszUserName,
 853                                                      DWORD dwFlags)
 854 {
 855     FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, lpszUserName, dwFlags);
 856
 857     return DI_OK;
 858 }
 859
 860 HRESULT WINAPI IDirectInputDevice8WImpl_SetActionMap(LPDIRECTINPUTDEVICE8W iface,
 861                                                      LPDIACTIONFORMATW lpdiaf,
 862                                                      LPCWSTR lpszUserName,
 863                                                      DWORD dwFlags)
 864 {
 865     FIXME("(%p)->(%p,%s,%08lx): stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
 866
 867     return DI_OK;
 868 }
 869
 870 HRESULT WINAPI IDirectInputDevice8AImpl_GetImageInfo(LPDIRECTINPUTDEVICE8A iface,
 871                                                      LPDIDEVICEIMAGEINFOHEADERA lpdiDevImageInfoHeader)
 872 {
 873     FIXME("(%p)->(%p): stub !\n", iface, lpdiDevImageInfoHeader);
 874
 875     return DI_OK;
 876 }
 877
 878 HRESULT WINAPI IDirectInputDevice8WImpl_GetImageInfo(LPDIRECTINPUTDEVICE8W iface,
 879                                                      LPDIDEVICEIMAGEINFOHEADERW lpdiDevImageInfoHeader)
 880 {
 881     FIXME("(%p)->(%p): stub !\n", iface, lpdiDevImageInfoHeader);
 882
 883     return DI_OK;
 884 }