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