git.oblomov.eu Git - wine/blob - dlls/dinput/dinput_main.c

   1 /*              DirectInput
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  *
   6  */
   7 /* Status:
   8  *
   9  * - Tomb Raider 2 Demo:
  10  *   Playable using keyboard only.
  11  * - WingCommander Prophecy Demo:
  12  *   Doesn't get Input Focus.
  13  *
  14  * - Fallout : works great in X and DGA mode
  15  *
  16  * FIXME: The keyboard handling needs to (and will) be merged into keyboard.c
  17  *        (The current implementation is currently only a proof of concept and
  18  *         an utter mess.)
  19  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26 #include <assert.h>
  27 #ifdef HAVE_SYS_SIGNAL_H
  28 # include <sys/signal.h>
  29 #endif
  30 #include <sys/time.h>
  31 #include <sys/fcntl.h>
  32 #include <sys/ioctl.h>
  33 #include <errno.h>
  34 #ifdef HAVE_SYS_ERRNO_H
  35 # include <sys/errno.h>
  36 #endif
  37 #ifdef HAVE_LINUX_JOYSTICK_H
  38 # include <linux/joystick.h>
  39 # define JOYDEV "/dev/js0"
  40 #endif
  41
  42 #include "debugtools.h"
  43 #include "input.h"
  44 #include "user.h"
  45 #include "mouse.h"
  46 #include "winbase.h"
  47 #include "winerror.h"
  48 #include "windef.h"
  49 #include "wingdi.h"
  50 #include "winuser.h"
  51
  52 #include "initguid.h"
  53 #include "dinput.h"
  54
  55 DEFAULT_DEBUG_CHANNEL(dinput);
  56
  57 /* Wine mouse driver object instances */
  58 #define WINE_MOUSE_X_AXIS_INSTANCE 0x0001
  59 #define WINE_MOUSE_Y_AXIS_INSTANCE 0x0002
  60 #define WINE_MOUSE_L_BUTTON_INSTANCE 0x0004
  61 #define WINE_MOUSE_R_BUTTON_INSTANCE 0x0008
  62 #define WINE_MOUSE_M_BUTTON_INSTANCE 0x0010
  63
  64 /* Wine joystick driver object instances */
  65 #define WINE_JOYSTICK_AXIS_BASE   0
  66 #define WINE_JOYSTICK_BUTTON_BASE 8
  67
  68 extern BYTE InputKeyStateTable[256];
  69 extern int min_keycode, max_keycode;
  70 extern WORD keyc2vkey[256];
  71
  72 /* Routines to do DataFormat / WineFormat conversions */
  73 typedef struct {
  74   int size;
  75   int offset_in;
  76   int offset_out;
  77   int value;
  78 } DataTransform;
  79
  80 typedef struct {
  81   int size;
  82   int internal_format_size;
  83   DataTransform *dt;
  84 } DataFormat;
  85
  86 /* ------------------------------- */
  87 /* Wine mouse internal data format */
  88 /* ------------------------------- */
  89
  90 /* Constants used to access the offset array */
  91 #define WINE_MOUSE_X_POSITION 0
  92 #define WINE_MOUSE_Y_POSITION 1
  93 #define WINE_MOUSE_L_POSITION 2
  94 #define WINE_MOUSE_R_POSITION 3
  95 #define WINE_MOUSE_M_POSITION 4
  96
  97 typedef struct {
  98   LONG lX;
  99   LONG lY;
 100   BYTE rgbButtons[4];
 101 } Wine_InternalMouseData;
 102
 103 #define WINE_INTERNALMOUSE_NUM_OBJS 5
 104
 105 static DIOBJECTDATAFORMAT Wine_InternalMouseObjectFormat[WINE_INTERNALMOUSE_NUM_OBJS] = {
 106   { &GUID_XAxis,   FIELD_OFFSET(Wine_InternalMouseData, lX),
 107       DIDFT_MAKEINSTANCE(WINE_MOUSE_X_AXIS_INSTANCE) | DIDFT_RELAXIS, 0 },
 108   { &GUID_YAxis,   FIELD_OFFSET(Wine_InternalMouseData, lY),
 109       DIDFT_MAKEINSTANCE(WINE_MOUSE_Y_AXIS_INSTANCE) | DIDFT_RELAXIS, 0 },
 110   { &GUID_Button, (FIELD_OFFSET(Wine_InternalMouseData, rgbButtons)) + 0,
 111       DIDFT_MAKEINSTANCE(WINE_MOUSE_L_BUTTON_INSTANCE) | DIDFT_PSHBUTTON, 0 },
 112   { &GUID_Button, (FIELD_OFFSET(Wine_InternalMouseData, rgbButtons)) + 1,
 113       DIDFT_MAKEINSTANCE(WINE_MOUSE_R_BUTTON_INSTANCE) | DIDFT_PSHBUTTON, 0 },
 114   { &GUID_Button, (FIELD_OFFSET(Wine_InternalMouseData, rgbButtons)) + 2,
 115       DIDFT_MAKEINSTANCE(WINE_MOUSE_M_BUTTON_INSTANCE) | DIDFT_PSHBUTTON, 0 }
 116 };
 117
 118 static DIDATAFORMAT Wine_InternalMouseFormat = {
 119   0, /* dwSize - unused */
 120   0, /* dwObjsize - unused */
 121   0, /* dwFlags - unused */
 122   sizeof(Wine_InternalMouseData),
 123   WINE_INTERNALMOUSE_NUM_OBJS, /* dwNumObjs */
 124   Wine_InternalMouseObjectFormat
 125 };
 126
 127 static ICOM_VTABLE(IDirectInputA) ddiavt;
 128 static ICOM_VTABLE(IDirectInputDevice2A) SysKeyboardAvt;
 129 static ICOM_VTABLE(IDirectInputDevice2A) SysMouseAvt;
 130
 131 typedef struct IDirectInputAImpl IDirectInputAImpl;
 132 typedef struct IDirectInputDevice2AImpl IDirectInputDevice2AImpl;
 133 typedef struct SysKeyboardAImpl SysKeyboardAImpl;
 134 typedef struct SysMouseAImpl SysMouseAImpl;
 135
 136 struct IDirectInputDevice2AImpl
 137 {
 138         ICOM_VFIELD(IDirectInputDevice2A);
 139         DWORD                           ref;
 140         GUID                            guid;
 141 };
 142
 143 struct SysKeyboardAImpl
 144 {
 145         /* IDirectInputDevice2AImpl */
 146         ICOM_VFIELD(IDirectInputDevice2A);
 147         DWORD                           ref;
 148         GUID                            guid;
 149         /* SysKeyboardAImpl */
 150         BYTE                            keystate[256];
 151         KEYBOARD_CONFIG                 initial_config;
 152         int                             acquired;
 153 };
 154
 155 #ifdef HAVE_LINUX_22_JOYSTICK_API
 156 typedef struct JoystickAImpl JoystickAImpl;
 157 static ICOM_VTABLE(IDirectInputDevice2A) JoystickAvt;
 158 struct JoystickAImpl
 159 {
 160         /* IDirectInputDevice2AImpl */
 161         ICOM_VFIELD(IDirectInputDevice2A);
 162         DWORD                           ref;
 163         GUID                            guid;
 164
 165         /* joystick private */
 166         int                             joyfd;
 167         LPDIDATAFORMAT                  df;
 168         HANDLE                          hEvent;
 169         LONG                            lMin,lMax,deadzone;
 170         LPDIDEVICEOBJECTDATA            data_queue;
 171         int                             queue_pos, queue_len;
 172         DIJOYSTATE                      js;
 173 };
 174 #endif
 175
 176 typedef enum {
 177   WARP_NEEDED,  /* Warping is needed */
 178   WARP_STARTED, /* Warping has been done, waiting for the warp event */
 179   WARP_DONE     /* Warping has been done */
 180 } WARP_STATUS;
 181
 182 struct SysMouseAImpl
 183 {
 184         /* IDirectInputDevice2AImpl */
 185         ICOM_VFIELD(IDirectInputDevice2A);
 186         DWORD                           ref;
 187         GUID                            guid;
 188
 189         /* The current data format and the conversion between internal
 190            and external data formats */
 191         LPDIDATAFORMAT                  df;
 192         DataFormat                     *wine_df;
 193         int                             offset_array[5];
 194
 195         /* SysMouseAImpl */
 196         BYTE                            absolute;
 197         /* Previous position for relative moves */
 198         LONG                            prevX, prevY;
 199         LPMOUSE_EVENT_PROC              prev_handler;
 200         HWND                            win;
 201         DWORD                           win_centerX, win_centerY;
 202         LPDIDEVICEOBJECTDATA            data_queue;
 203         int                             queue_pos, queue_len;
 204         WARP_STATUS                     need_warp;
 205         int                             acquired;
 206         HANDLE                          hEvent;
 207         CRITICAL_SECTION                crit;
 208
 209         /* This is for mouse reporting. */
 210         Wine_InternalMouseData          m_state;
 211 };
 212
 213 static int evsequence=0;
 214
 215
 216 /* UIDs for Wine "drivers".
 217    When enumerating each device supporting DInput, they have two UIDs :
 218     - the 'windows' UID
 219     - a vendor UID */
 220 #ifdef HAVE_LINUX_22_JOYSTICK_API
 221 static GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
 222   0x9e573ed9,
 223   0x7734,
 224   0x11d2,
 225   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
 226 };
 227 #endif
 228 static GUID DInput_Wine_Mouse_GUID = { /* 9e573ed8-7734-11d2-8d4a-23903fb6bdf7 */
 229   0x9e573ed8,
 230   0x7734,
 231   0x11d2,
 232   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
 233 };
 234 static GUID DInput_Wine_Keyboard_GUID = { /* 0ab8648a-7735-11d2-8c73-71df54a96441 */
 235   0x0ab8648a,
 236   0x7735,
 237   0x11d2,
 238   {0x8c, 0x73, 0x71, 0xdf, 0x54, 0xa9, 0x64, 0x41}
 239 };
 240
 241 /* FIXME: This is ugly and not thread safe :/ */
 242 static IDirectInputDevice2A* current_lock = NULL;
 243
 244 /******************************************************************************
 245  *      Various debugging tools
 246  */
 247 static void _dump_cooperativelevel(DWORD dwFlags) {
 248   int   i;
 249   const struct {
 250     DWORD       mask;
 251     char        *name;
 252   } flags[] = {
 253 #define FE(x) { x, #x},
 254     FE(DISCL_BACKGROUND)
 255     FE(DISCL_EXCLUSIVE)
 256     FE(DISCL_FOREGROUND)
 257     FE(DISCL_NONEXCLUSIVE)
 258 #undef FE
 259   };
 260   for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 261     if (flags[i].mask & dwFlags)
 262       DPRINTF("%s ",flags[i].name);
 263   DPRINTF("\n");
 264 }
 265
 266 static void _dump_EnumObjects_flags(DWORD dwFlags) {
 267   int   i;
 268   const struct {
 269     DWORD       mask;
 270     char        *name;
 271   } flags[] = {
 272 #define FE(x) { x, #x},
 273     FE(DIDFT_ABSAXIS)
 274     FE(DIDFT_ALL)
 275     FE(DIDFT_AXIS)
 276     FE(DIDFT_BUTTON)
 277     FE(DIDFT_COLLECTION)
 278     FE(DIDFT_FFACTUATOR)
 279     FE(DIDFT_FFEFFECTTRIGGER)
 280     FE(DIDFT_NOCOLLECTION)
 281     FE(DIDFT_NODATA)
 282     FE(DIDFT_OUTPUT)
 283     FE(DIDFT_POV)
 284     FE(DIDFT_PSHBUTTON)
 285     FE(DIDFT_RELAXIS)
 286     FE(DIDFT_TGLBUTTON)
 287 #undef FE
 288   };
 289   if (dwFlags == DIDFT_ALL) {
 290     DPRINTF("DIDFT_ALL");
 291     return;
 292   }
 293   for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 294     if (flags[i].mask & dwFlags)
 295       DPRINTF("%s ",flags[i].name);
 296   if (dwFlags & DIDFT_INSTANCEMASK)
 297     DPRINTF("Instance(%04lx) ", dwFlags >> 8);
 298 }
 299
 300 static void _dump_DIPROPHEADER(DIPROPHEADER *diph) {
 301   DPRINTF("  - dwObj = 0x%08lx\n", diph->dwObj);
 302   DPRINTF("  - dwHow = %s\n",
 303           ((diph->dwHow == DIPH_DEVICE) ? "DIPH_DEVICE" :
 304            ((diph->dwHow == DIPH_BYOFFSET) ? "DIPH_BYOFFSET" :
 305             ((diph->dwHow == DIPH_BYID)) ? "DIPH_BYID" : "unknown")));
 306 }
 307
 308 static void _dump_OBJECTINSTANCEA(DIDEVICEOBJECTINSTANCEA *ddoi) {
 309   if (TRACE_ON(dinput)) {
 310     DPRINTF("    - enumerating : 0x%08lx - %2ld - 0x%08lx - %s\n",
 311             ddoi->guidType.Data1, ddoi->dwOfs, ddoi->dwType, ddoi->tszName);
 312   }
 313 }
 314
 315 struct IDirectInputAImpl
 316 {
 317         ICOM_VFIELD(IDirectInputA);
 318         DWORD                   ref;
 319 };
 320
 321 /* Conversion between internal data buffer and external data buffer */
 322 static void fill_DataFormat(void *out, void *in, DataFormat *df) {
 323   int i;
 324   char *in_c = (char *) in;
 325   char *out_c = (char *) out;
 326
 327   if (df->dt == NULL) {
 328     /* This means that the app uses Wine's internal data format */
 329     memcpy(out, in, df->internal_format_size);
 330   } else {
 331     for (i = 0; i < df->size; i++) {
 332       if (df->dt[i].offset_in >= 0) {
 333         switch (df->dt[i].size) {
 334         case 1:
 335           TRACE("Copying (c) to %d from %d (value %d)\n",
 336                 df->dt[i].offset_out, df->dt[i].offset_in, *((char *) (in_c + df->dt[i].offset_in)));
 337           *((char *) (out_c + df->dt[i].offset_out)) = *((char *) (in_c + df->dt[i].offset_in));
 338           break;
 339
 340         case 2:
 341           TRACE("Copying (s) to %d from %d (value %d)\n",
 342                 df->dt[i].offset_out, df->dt[i].offset_in, *((short *) (in_c + df->dt[i].offset_in)));
 343           *((short *) (out_c + df->dt[i].offset_out)) = *((short *) (in_c + df->dt[i].offset_in));
 344           break;
 345
 346         case 4:
 347           TRACE("Copying (i) to %d from %d (value %d)\n",
 348                 df->dt[i].offset_out, df->dt[i].offset_in, *((int *) (in_c + df->dt[i].offset_in)));
 349           *((int *) (out_c + df->dt[i].offset_out)) = *((int *) (in_c + df->dt[i].offset_in));
 350           break;
 351
 352         default:
 353           memcpy((out_c + df->dt[i].offset_out), (in_c + df->dt[i].offset_in), df->dt[i].size);
 354         }
 355       } else {
 356         switch (df->dt[i].size) {
 357         case 1:
 358           TRACE("Copying (c) to %d default value %d\n",
 359                 df->dt[i].offset_out, df->dt[i].value);
 360           *((char *) (out_c + df->dt[i].offset_out)) = (char) df->dt[i].value;
 361           break;
 362
 363         case 2:
 364           TRACE("Copying (s) to %d default value %d\n",
 365                 df->dt[i].offset_out, df->dt[i].value);
 366           *((short *) (out_c + df->dt[i].offset_out)) = (short) df->dt[i].value;
 367           break;
 368
 369         case 4:
 370           TRACE("Copying (i) to %d default value %d\n",
 371                 df->dt[i].offset_out, df->dt[i].value);
 372           *((int *) (out_c + df->dt[i].offset_out)) = (int) df->dt[i].value;
 373           break;
 374
 375         default:
 376           memset((out_c + df->dt[i].offset_out), df->dt[i].size, 0);
 377         }
 378       }
 379     }
 380   }
 381 }
 382
 383 static DataFormat *create_DataFormat(DIDATAFORMAT *wine_format, LPCDIDATAFORMAT asked_format, int *offset) {
 384   DataFormat *ret;
 385   DataTransform *dt;
 386   int i, j;
 387   int same = 1;
 388   int *done;
 389   int index = 0;
 390
 391   ret = (DataFormat *) HeapAlloc(GetProcessHeap(), 0, sizeof(DataFormat));
 392
 393   done = (int *) HeapAlloc(GetProcessHeap(), 0, sizeof(int) * asked_format->dwNumObjs);
 394   memset(done, 0, sizeof(int) * asked_format->dwNumObjs);
 395
 396   dt = (DataTransform *) HeapAlloc(GetProcessHeap(), 0, asked_format->dwNumObjs * sizeof(DataTransform));
 397
 398   TRACE("Creating DataTransorm : \n");
 399
 400   for (i = 0; i < wine_format->dwNumObjs; i++) {
 401     offset[i] = -1;
 402
 403     for (j = 0; j < asked_format->dwNumObjs; j++) {
 404       if (done[j] == 1)
 405         continue;
 406
 407       if (((asked_format->rgodf[j].pguid == NULL) || (IsEqualGUID(wine_format->rgodf[i].pguid, asked_format->rgodf[j].pguid)))
 408           &&
 409           (wine_format->rgodf[i].dwType & asked_format->rgodf[j].dwType)) {
 410
 411         done[j] = 1;
 412
 413         TRACE("Matching : \n");
 414         TRACE("   - Asked (%d) : %s - Ofs = %3ld - (Type = 0x%02x | Instance = %04x)\n",
 415               j, debugstr_guid(asked_format->rgodf[j].pguid),
 416               asked_format->rgodf[j].dwOfs,
 417               DIDFT_GETTYPE(asked_format->rgodf[j].dwType), DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType));
 418
 419         TRACE("   - Wine  (%d) : %s - Ofs = %3ld - (Type = 0x%02x | Instance = %04x)\n",
 420               j, debugstr_guid(wine_format->rgodf[i].pguid),
 421               wine_format->rgodf[i].dwOfs,
 422               DIDFT_GETTYPE(wine_format->rgodf[i].dwType), DIDFT_GETINSTANCE(wine_format->rgodf[i].dwType));
 423
 424         if (wine_format->rgodf[i].dwType & DIDFT_BUTTON)
 425           dt[index].size = sizeof(BYTE);
 426         else
 427           dt[index].size = sizeof(DWORD);
 428         dt[index].offset_in  = wine_format ->rgodf[i].dwOfs;
 429         dt[index].offset_out = asked_format->rgodf[j].dwOfs;
 430         dt[index].value = 0;
 431         index++;
 432
 433         if (wine_format->rgodf[i].dwOfs != asked_format->rgodf[j].dwOfs)
 434           same = 0;
 435
 436         offset[i] = asked_format->rgodf[j].dwOfs;
 437         break;
 438       }
 439     }
 440
 441     if (j == asked_format->dwNumObjs)
 442       same = 0;
 443   }
 444
 445   TRACE("Setting to default value :\n");
 446   for (j = 0; j < asked_format->dwNumObjs; j++) {
 447     if (done[j] == 0) {
 448       TRACE(" - Asked (%d) : %s - Ofs = %3ld - (Type = 0x%02x | Instance = %04x)\n",
 449             j, debugstr_guid(asked_format->rgodf[j].pguid),
 450             asked_format->rgodf[j].dwOfs,
 451             DIDFT_GETTYPE(asked_format->rgodf[j].dwType), DIDFT_GETINSTANCE(asked_format->rgodf[j].dwType));
 452
 453
 454       if (asked_format->rgodf[j].dwType & DIDFT_BUTTON)
 455         dt[index].size = sizeof(BYTE);
 456       else
 457         dt[index].size = sizeof(DWORD);
 458       dt[index].offset_in  = -1;
 459       dt[index].offset_out = asked_format->rgodf[j].dwOfs;
 460       dt[index].value = 0;
 461       index++;
 462
 463       same = 0;
 464     }
 465   }
 466
 467   ret->internal_format_size = wine_format->dwDataSize;
 468   ret->size = index;
 469   if (same) {
 470     ret->dt = NULL;
 471     HeapFree(GetProcessHeap(), 0, dt);
 472   } else {
 473     ret->dt = dt;
 474   }
 475
 476   HeapFree(GetProcessHeap(), 0, done);
 477
 478   return ret;
 479 }
 480
 481 /******************************************************************************
 482  *      DirectInputCreateA
 483  */
 484 HRESULT WINAPI DirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA *ppDI, LPUNKNOWN punkOuter)
 485 {
 486         IDirectInputAImpl* This;
 487         TRACE("(0x%08lx,%04lx,%p,%p)\n",
 488                 (DWORD)hinst,dwVersion,ppDI,punkOuter
 489         );
 490         This = (IDirectInputAImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectInputAImpl));
 491         This->ref = 1;
 492         ICOM_VTBL(This) = &ddiavt;
 493         *ppDI=(IDirectInputA*)This;
 494         return 0;
 495 }
 496 /******************************************************************************
 497  *      IDirectInputA_EnumDevices
 498  */
 499 static HRESULT WINAPI IDirectInputAImpl_EnumDevices(
 500         LPDIRECTINPUTA iface, DWORD dwDevType, LPDIENUMDEVICESCALLBACKA lpCallback,
 501         LPVOID pvRef, DWORD dwFlags
 502 )
 503 {
 504         ICOM_THIS(IDirectInputAImpl,iface);
 505         DIDEVICEINSTANCEA devInstance;
 506         int ret;
 507
 508         TRACE("(this=%p,0x%04lx,%p,%p,%04lx)\n", This, dwDevType, lpCallback, pvRef, dwFlags);
 509
 510         devInstance.dwSize = sizeof(DIDEVICEINSTANCEA);
 511         if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_KEYBOARD)) {
 512                 /* Return keyboard */
 513                 devInstance.guidInstance = GUID_SysKeyboard;/* DInput's GUID */
 514                 devInstance.guidProduct = DInput_Wine_Keyboard_GUID; /* Vendor's GUID */
 515                 devInstance.dwDevType = DIDEVTYPE_KEYBOARD | (DIDEVTYPEKEYBOARD_UNKNOWN << 8);
 516                 strcpy(devInstance.tszInstanceName, "Keyboard");
 517                 strcpy(devInstance.tszProductName, "Wine Keyboard");
 518
 519                 ret = lpCallback(&devInstance, pvRef);
 520                 TRACE("Keyboard registered\n");
 521                 if (ret == DIENUM_STOP)
 522                         return 0;
 523         }
 524
 525         if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_MOUSE)) {
 526                 /* Return mouse */
 527                 devInstance.guidInstance = GUID_SysMouse;/* DInput's GUID */
 528                 devInstance.guidProduct = DInput_Wine_Mouse_GUID; /* Vendor's GUID */
 529                 devInstance.dwDevType = DIDEVTYPE_MOUSE | (DIDEVTYPEMOUSE_UNKNOWN << 8);
 530                 strcpy(devInstance.tszInstanceName, "Mouse");
 531                 strcpy(devInstance.tszProductName, "Wine Mouse");
 532
 533                 ret = lpCallback(&devInstance, pvRef);
 534                 TRACE("Mouse registered\n");
 535                 if (ret == DIENUM_STOP)
 536                         return 0;
 537         }
 538         if ((dwDevType == 0) || (dwDevType == DIDEVTYPE_JOYSTICK)) {
 539                 /* check whether we have a joystick */
 540 #ifdef HAVE_LINUX_22_JOYSTICK_API
 541                 if (    (access(JOYDEV,O_RDONLY)!=-1)           ||
 542                         (errno!=ENODEV && errno!=ENOENT)
 543                 ) {
 544                     /* Return joystick */
 545                     devInstance.guidInstance    = GUID_Joystick;
 546                     devInstance.guidProduct     = DInput_Wine_Joystick_GUID;
 547                     /* we only support traditional joysticks for now */
 548                     devInstance.dwDevType       = DIDEVTYPE_JOYSTICK | DIDEVTYPEJOYSTICK_TRADITIONAL;
 549                     strcpy(devInstance.tszInstanceName, "Joystick");
 550                     /* ioctl JSIOCGNAME(len) */
 551                     strcpy(devInstance.tszProductName,  "Wine Joystick");
 552
 553                     ret = lpCallback(&devInstance,pvRef);
 554                     TRACE("Joystick registered\n");
 555                     if (ret == DIENUM_STOP)
 556                             return 0;
 557                 }
 558 #endif
 559         }
 560         return 0;
 561 }
 562
 563 static ULONG WINAPI IDirectInputAImpl_AddRef(LPDIRECTINPUTA iface)
 564 {
 565         ICOM_THIS(IDirectInputAImpl,iface);
 566         return ++(This->ref);
 567 }
 568
 569 static ULONG WINAPI IDirectInputAImpl_Release(LPDIRECTINPUTA iface)
 570 {
 571         ICOM_THIS(IDirectInputAImpl,iface);
 572         if (!(--This->ref)) {
 573                 HeapFree(GetProcessHeap(),0,This);
 574                 return 0;
 575         }
 576         return This->ref;
 577 }
 578
 579 static HRESULT WINAPI IDirectInputAImpl_CreateDevice(
 580         LPDIRECTINPUTA iface,REFGUID rguid,LPDIRECTINPUTDEVICEA* pdev,
 581         LPUNKNOWN punk
 582 ) {
 583         ICOM_THIS(IDirectInputAImpl,iface);
 584
 585         TRACE("(this=%p,%s,%p,%p)\n",This,debugstr_guid(rguid),pdev,punk);
 586         if ((IsEqualGUID(&GUID_SysKeyboard,rguid)) ||          /* Generic Keyboard */
 587             (IsEqualGUID(&DInput_Wine_Keyboard_GUID,rguid))) { /* Wine Keyboard */
 588                 SysKeyboardAImpl* newDevice;
 589                 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysKeyboardAImpl));
 590                 newDevice->ref = 1;
 591                 ICOM_VTBL(newDevice) = &SysKeyboardAvt;
 592                 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 593                 memset(newDevice->keystate,0,256);
 594                 *pdev=(IDirectInputDeviceA*)newDevice;
 595
 596                 TRACE("Creating a Keyboard device (%p)\n", newDevice);
 597                 return DI_OK;
 598         }
 599         if ((IsEqualGUID(&GUID_SysMouse,rguid)) ||             /* Generic Mouse */
 600             (IsEqualGUID(&DInput_Wine_Mouse_GUID,rguid))) { /* Wine Mouse */
 601                 SysMouseAImpl* newDevice;
 602                 int offset_array[5] = {
 603                   FIELD_OFFSET(Wine_InternalMouseData, lX),
 604                   FIELD_OFFSET(Wine_InternalMouseData, lY),
 605                   FIELD_OFFSET(Wine_InternalMouseData, rgbButtons) + 0,
 606                   FIELD_OFFSET(Wine_InternalMouseData, rgbButtons) + 1,
 607                   FIELD_OFFSET(Wine_InternalMouseData, rgbButtons) + 2
 608                 };
 609
 610                 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(SysMouseAImpl));
 611                 newDevice->ref = 1;
 612                 ICOM_VTBL(newDevice) = &SysMouseAvt;
 613                 InitializeCriticalSection(&(newDevice->crit));
 614                 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 615                 *pdev=(IDirectInputDeviceA*)newDevice;
 616
 617                 /* Per default, Wine uses its internal data format */
 618                 newDevice->df = &Wine_InternalMouseFormat;
 619                 memcpy(newDevice->offset_array, offset_array, 5 * sizeof(int));
 620                 newDevice->wine_df = (DataFormat *) HeapAlloc(GetProcessHeap(), 0, sizeof(DataFormat));
 621                 newDevice->wine_df->size = 0;
 622                 newDevice->wine_df->internal_format_size = Wine_InternalMouseFormat.dwDataSize;
 623                 newDevice->wine_df->dt = NULL;
 624
 625                 TRACE("Creating a Mouse device (%p)\n", newDevice);
 626                 return DI_OK;
 627         }
 628 #ifdef HAVE_LINUX_22_JOYSTICK_API
 629         if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 630             (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 631                 JoystickAImpl* newDevice;
 632                 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickAImpl));
 633                 newDevice->ref          = 1;
 634                 ICOM_VTBL(newDevice)    = &JoystickAvt;
 635                 newDevice->joyfd        = -1;
 636                 newDevice->lMin = -32768;
 637                 newDevice->lMax = +32767;
 638                 memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 639                 *pdev=(IDirectInputDeviceA*)newDevice;
 640
 641                 TRACE("Creating a Joystick device (%p)\n", newDevice);
 642                 return DI_OK;
 643         }
 644 #endif
 645         return E_FAIL;
 646 }
 647
 648 static HRESULT WINAPI IDirectInputAImpl_QueryInterface(
 649         LPDIRECTINPUTA iface,REFIID riid,LPVOID *ppobj
 650 ) {
 651         ICOM_THIS(IDirectInputAImpl,iface);
 652
 653         TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 654         if (IsEqualGUID(&IID_IUnknown,riid)) {
 655                 IDirectInputA_AddRef(iface);
 656                 *ppobj = This;
 657                 return 0;
 658         }
 659         if (IsEqualGUID(&IID_IDirectInputA,riid)) {
 660                 IDirectInputA_AddRef(iface);
 661                 *ppobj = This;
 662                 return 0;
 663         }
 664         TRACE("Unsupported interface !\n");
 665         return E_FAIL;
 666 }
 667
 668 static HRESULT WINAPI IDirectInputAImpl_Initialize(
 669         LPDIRECTINPUTA iface,HINSTANCE hinst,DWORD x
 670 ) {
 671         return DIERR_ALREADYINITIALIZED;
 672 }
 673
 674 static HRESULT WINAPI IDirectInputAImpl_GetDeviceStatus(LPDIRECTINPUTA iface,
 675                                                         REFGUID rguid) {
 676   ICOM_THIS(IDirectInputAImpl,iface);
 677
 678   FIXME("(%p)->(%s): stub\n",This,debugstr_guid(rguid));
 679
 680   return DI_OK;
 681 }
 682
 683 static HRESULT WINAPI IDirectInputAImpl_RunControlPanel(LPDIRECTINPUTA iface,
 684                                                         HWND hwndOwner,
 685                                                         DWORD dwFlags) {
 686   ICOM_THIS(IDirectInputAImpl,iface);
 687   FIXME("(%p)->(%08lx,%08lx): stub\n",This, (DWORD) hwndOwner, dwFlags);
 688
 689   return DI_OK;
 690 }
 691
 692 static ICOM_VTABLE(IDirectInputA) ddiavt =
 693 {
 694         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 695         IDirectInputAImpl_QueryInterface,
 696         IDirectInputAImpl_AddRef,
 697         IDirectInputAImpl_Release,
 698         IDirectInputAImpl_CreateDevice,
 699         IDirectInputAImpl_EnumDevices,
 700         IDirectInputAImpl_GetDeviceStatus,
 701         IDirectInputAImpl_RunControlPanel,
 702         IDirectInputAImpl_Initialize
 703 };
 704
 705 /******************************************************************************
 706  *      IDirectInputDeviceA
 707  */
 708
 709 static HRESULT WINAPI IDirectInputDevice2AImpl_SetDataFormat(
 710         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
 711 ) {
 712         /*
 713         int i;
 714         TRACE(dinput,"(this=%p,%p)\n",This,df);
 715
 716         TRACE(dinput,"df.dwSize=%ld\n",df->dwSize);
 717         TRACE(dinput,"(df.dwObjsize=%ld)\n",df->dwObjSize);
 718         TRACE(dinput,"(df.dwFlags=0x%08lx)\n",df->dwFlags);
 719         TRACE(dinput,"(df.dwDataSize=%ld)\n",df->dwDataSize);
 720         TRACE(dinput,"(df.dwNumObjs=%ld)\n",df->dwNumObjs);
 721
 722         for (i=0;i<df->dwNumObjs;i++) {
 723                 TRACE(dinput,"df.rgodf[%d].guid %s\n",i,debugstr_guid(df->rgodf[i].pguid));
 724                 TRACE(dinput,"df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
 725                 TRACE(dinput,"dwType 0x%02lx,dwInstance %ld\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
 726                 TRACE(dinput,"df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
 727         }
 728         */
 729         return 0;
 730 }
 731
 732 static HRESULT WINAPI IDirectInputDevice2AImpl_SetCooperativeLevel(
 733         LPDIRECTINPUTDEVICE2A iface,HWND hwnd,DWORD dwflags
 734 ) {
 735         ICOM_THIS(IDirectInputDevice2AImpl,iface);
 736         TRACE("(this=%p,0x%08lx,0x%08lx)\n",This,(DWORD)hwnd,dwflags);
 737         if (TRACE_ON(dinput))
 738           _dump_cooperativelevel(dwflags);
 739         return 0;
 740 }
 741
 742 static HRESULT WINAPI IDirectInputDevice2AImpl_SetEventNotification(
 743         LPDIRECTINPUTDEVICE2A iface,HANDLE hnd
 744 ) {
 745         ICOM_THIS(IDirectInputDevice2AImpl,iface);
 746         FIXME("(this=%p,0x%08lx): stub\n",This,(DWORD)hnd);
 747         return 0;
 748 }
 749
 750 static ULONG WINAPI IDirectInputDevice2AImpl_Release(LPDIRECTINPUTDEVICE2A iface)
 751 {
 752         ICOM_THIS(IDirectInputDevice2AImpl,iface);
 753         This->ref--;
 754         if (This->ref)
 755                 return This->ref;
 756         HeapFree(GetProcessHeap(),0,This);
 757         return 0;
 758 }
 759
 760 static HRESULT WINAPI SysKeyboardAImpl_SetProperty(
 761         LPDIRECTINPUTDEVICE2A iface,REFGUID rguid,LPCDIPROPHEADER ph
 762 )
 763 {
 764         ICOM_THIS(SysKeyboardAImpl,iface);
 765
 766         TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
 767         TRACE("(size=%ld,headersize=%ld,obj=%ld,how=%ld\n",
 768             ph->dwSize,ph->dwHeaderSize,ph->dwObj,ph->dwHow);
 769         if (!HIWORD(rguid)) {
 770                 switch ((DWORD)rguid) {
 771                 case (DWORD) DIPROP_BUFFERSIZE: {
 772                         LPCDIPROPDWORD  pd = (LPCDIPROPDWORD)ph;
 773
 774                         TRACE("(buffersize=%ld)\n",pd->dwData);
 775                         break;
 776                 }
 777                 default:
 778                         WARN("Unknown type %ld\n",(DWORD)rguid);
 779                         break;
 780                 }
 781         }
 782         return 0;
 783 }
 784
 785 static HRESULT WINAPI SysKeyboardAImpl_GetDeviceState(
 786         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
 787 )
 788 {
 789         return USER_Driver.pGetDIState(len, ptr)?DI_OK:E_FAIL;
 790 }
 791
 792 static HRESULT WINAPI SysKeyboardAImpl_GetDeviceData(
 793         LPDIRECTINPUTDEVICE2A iface,DWORD dodsize,LPDIDEVICEOBJECTDATA dod,
 794         LPDWORD entries,DWORD flags
 795 )
 796 {
 797         ICOM_THIS(SysKeyboardAImpl,iface);
 798         HRESULT ret;
 799         int     i;
 800
 801         TRACE("(this=%p,%ld,%p,%p(%ld)),0x%08lx)\n",
 802               This,dodsize,dod,entries,entries?*entries:0,flags);
 803
 804         ret=USER_Driver.pGetDIData(
 805                 This->keystate, dodsize, dod, entries, flags)?DI_OK:E_FAIL;
 806         for (i=0;i<*entries;i++) {
 807                 dod[i].dwTimeStamp = GetTickCount();
 808                 dod[i].dwSequence = evsequence++;
 809         }
 810         return ret;
 811 }
 812
 813 static HRESULT WINAPI SysKeyboardAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
 814 {
 815         ICOM_THIS(SysKeyboardAImpl,iface);
 816
 817         TRACE("(this=%p)\n",This);
 818
 819         if (This->acquired == 0) {
 820           KEYBOARD_CONFIG no_auto;
 821
 822           /* Save the original config */
 823           USER_Driver.pGetKeyboardConfig(&(This->initial_config));
 824
 825           /* Now, remove auto-repeat */
 826           no_auto.auto_repeat = FALSE;
 827           USER_Driver.pSetKeyboardConfig(&no_auto, WINE_KEYBOARD_CONFIG_AUTO_REPEAT);
 828
 829           This->acquired = 1;
 830         }
 831
 832         return DI_OK;
 833 }
 834
 835 static HRESULT WINAPI SysKeyboardAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
 836 {
 837         ICOM_THIS(SysKeyboardAImpl,iface);
 838         TRACE("(this=%p)\n",This);
 839
 840         if (This->acquired == 1) {
 841           /* Restore the original configuration */
 842           USER_Driver.pSetKeyboardConfig(&(This->initial_config), 0xFFFFFFFF);
 843           This->acquired = 0;
 844         } else {
 845           ERR("Unacquiring a not-acquired device !!!\n");
 846         }
 847
 848         return DI_OK;
 849 }
 850
 851 /******************************************************************************
 852   *     GetCapabilities : get the device capablitites
 853   */
 854 static HRESULT WINAPI SysKeyboardAImpl_GetCapabilities(
 855         LPDIRECTINPUTDEVICE2A iface,
 856         LPDIDEVCAPS lpDIDevCaps)
 857 {
 858   ICOM_THIS(SysMouseAImpl,iface);
 859
 860   TRACE("(this=%p,%p)\n",This,lpDIDevCaps);
 861
 862   if (lpDIDevCaps->dwSize == sizeof(DIDEVCAPS)) {
 863     lpDIDevCaps->dwFlags = DIDC_ATTACHED;
 864     lpDIDevCaps->dwDevType = DIDEVTYPE_KEYBOARD;
 865     lpDIDevCaps->dwAxes = 0;
 866     lpDIDevCaps->dwButtons = 0;
 867     lpDIDevCaps->dwPOVs = 0;
 868     lpDIDevCaps->dwFFSamplePeriod = 0;
 869     lpDIDevCaps->dwFFMinTimeResolution = 0;
 870     lpDIDevCaps->dwFirmwareRevision = 100;
 871     lpDIDevCaps->dwHardwareRevision = 100;
 872     lpDIDevCaps->dwFFDriverVersion = 0;
 873   } else {
 874     /* DirectX 3.0 */
 875     FIXME("DirectX 3.0 not supported....\n");
 876   }
 877
 878   return DI_OK;
 879 }
 880
 881 static HRESULT WINAPI IDirectInputDevice2AImpl_QueryInterface(
 882         LPDIRECTINPUTDEVICE2A iface,REFIID riid,LPVOID *ppobj
 883 )
 884 {
 885         ICOM_THIS(IDirectInputDevice2AImpl,iface);
 886
 887         TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 888         if (IsEqualGUID(&IID_IUnknown,riid)) {
 889                 IDirectInputDevice2_AddRef(iface);
 890                 *ppobj = This;
 891                 return 0;
 892         }
 893         if (IsEqualGUID(&IID_IDirectInputDeviceA,riid)) {
 894                 IDirectInputDevice2_AddRef(iface);
 895                 *ppobj = This;
 896                 return 0;
 897         }
 898         if (IsEqualGUID(&IID_IDirectInputDevice2A,riid)) {
 899                 IDirectInputDevice2_AddRef(iface);
 900                 *ppobj = This;
 901                 return 0;
 902         }
 903         TRACE("Unsupported interface !\n");
 904         return E_FAIL;
 905 }
 906
 907 static ULONG WINAPI IDirectInputDevice2AImpl_AddRef(
 908         LPDIRECTINPUTDEVICE2A iface)
 909 {
 910         ICOM_THIS(IDirectInputDevice2AImpl,iface);
 911         return ++This->ref;
 912 }
 913
 914 static HRESULT WINAPI IDirectInputDevice2AImpl_EnumObjects(
 915         LPDIRECTINPUTDEVICE2A iface,
 916         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
 917         LPVOID lpvRef,
 918         DWORD dwFlags)
 919 {
 920         FIXME("(this=%p,%p,%p,%08lx): stub!\n", iface, lpCallback, lpvRef, dwFlags);
 921         if (TRACE_ON(dinput)) {
 922           DPRINTF("  - flags = ");
 923           _dump_EnumObjects_flags(dwFlags);
 924           DPRINTF("\n");
 925         }
 926
 927         return DI_OK;
 928 }
 929
 930 static HRESULT WINAPI IDirectInputDevice2AImpl_GetProperty(
 931         LPDIRECTINPUTDEVICE2A iface,
 932         REFGUID rguid,
 933         LPDIPROPHEADER pdiph)
 934 {
 935         FIXME("(this=%p,%s,%p): stub!\n",
 936               iface, debugstr_guid(rguid), pdiph);
 937
 938         if (TRACE_ON(dinput))
 939           _dump_DIPROPHEADER(pdiph);
 940
 941         return DI_OK;
 942 }
 943
 944 static HRESULT WINAPI IDirectInputDevice2AImpl_GetObjectInfo(
 945         LPDIRECTINPUTDEVICE2A iface,
 946         LPDIDEVICEOBJECTINSTANCEA pdidoi,
 947         DWORD dwObj,
 948         DWORD dwHow)
 949 {
 950         FIXME("(this=%p,%p,%ld,0x%08lx): stub!\n",
 951               iface, pdidoi, dwObj, dwHow);
 952
 953         return DI_OK;
 954 }
 955
 956 static HRESULT WINAPI IDirectInputDevice2AImpl_GetDeviceInfo(
 957         LPDIRECTINPUTDEVICE2A iface,
 958         LPDIDEVICEINSTANCEA pdidi)
 959 {
 960         FIXME("(this=%p,%p): stub!\n",
 961               iface, pdidi);
 962
 963         return DI_OK;
 964 }
 965
 966 static HRESULT WINAPI IDirectInputDevice2AImpl_RunControlPanel(
 967         LPDIRECTINPUTDEVICE2A iface,
 968         HWND hwndOwner,
 969         DWORD dwFlags)
 970 {
 971   FIXME("(this=%p,0x%08x,0x%08lx): stub!\n",
 972         iface, hwndOwner, dwFlags);
 973
 974         return DI_OK;
 975 }
 976
 977 static HRESULT WINAPI IDirectInputDevice2AImpl_Initialize(
 978         LPDIRECTINPUTDEVICE2A iface,
 979         HINSTANCE hinst,
 980         DWORD dwVersion,
 981         REFGUID rguid)
 982 {
 983         FIXME("(this=%p,%d,%ld,%s): stub!\n",
 984               iface, hinst, dwVersion, debugstr_guid(rguid));
 985         return DI_OK;
 986 }
 987
 988 /******************************************************************************
 989  *      IDirectInputDevice2A
 990  */
 991
 992 static HRESULT WINAPI IDirectInputDevice2AImpl_CreateEffect(
 993         LPDIRECTINPUTDEVICE2A iface,
 994         REFGUID rguid,
 995         LPCDIEFFECT lpeff,
 996         LPDIRECTINPUTEFFECT *ppdef,
 997         LPUNKNOWN pUnkOuter)
 998 {
 999         FIXME("(this=%p,%s,%p,%p,%p): stub!\n",
1000               iface, debugstr_guid(rguid), lpeff, ppdef, pUnkOuter);
1001         return DI_OK;
1002 }
1003
1004 static HRESULT WINAPI IDirectInputDevice2AImpl_EnumEffects(
1005         LPDIRECTINPUTDEVICE2A iface,
1006         LPDIENUMEFFECTSCALLBACKA lpCallback,
1007         LPVOID lpvRef,
1008         DWORD dwFlags)
1009 {
1010         FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
1011               iface, lpCallback, lpvRef, dwFlags);
1012
1013         if (lpCallback)
1014                 lpCallback(NULL, lpvRef);
1015         return DI_OK;
1016 }
1017
1018 static HRESULT WINAPI IDirectInputDevice2AImpl_GetEffectInfo(
1019         LPDIRECTINPUTDEVICE2A iface,
1020         LPDIEFFECTINFOA lpdei,
1021         REFGUID rguid)
1022 {
1023         FIXME("(this=%p,%p,%s): stub!\n",
1024               iface, lpdei, debugstr_guid(rguid));
1025         return DI_OK;
1026 }
1027
1028 static HRESULT WINAPI IDirectInputDevice2AImpl_GetForceFeedbackState(
1029         LPDIRECTINPUTDEVICE2A iface,
1030         LPDWORD pdwOut)
1031 {
1032         FIXME("(this=%p,%p): stub!\n",
1033               iface, pdwOut);
1034         return DI_OK;
1035 }
1036
1037 static HRESULT WINAPI IDirectInputDevice2AImpl_SendForceFeedbackCommand(
1038         LPDIRECTINPUTDEVICE2A iface,
1039         DWORD dwFlags)
1040 {
1041         FIXME("(this=%p,0x%08lx): stub!\n",
1042               iface, dwFlags);
1043         return DI_OK;
1044 }
1045
1046 static HRESULT WINAPI IDirectInputDevice2AImpl_EnumCreatedEffectObjects(
1047         LPDIRECTINPUTDEVICE2A iface,
1048         LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
1049         LPVOID lpvRef,
1050         DWORD dwFlags)
1051 {
1052         FIXME("(this=%p,%p,%p,0x%08lx): stub!\n",
1053               iface, lpCallback, lpvRef, dwFlags);
1054         if (lpCallback)
1055                 lpCallback(NULL, lpvRef);
1056         return DI_OK;
1057 }
1058
1059 static HRESULT WINAPI IDirectInputDevice2AImpl_Escape(
1060         LPDIRECTINPUTDEVICE2A iface,
1061         LPDIEFFESCAPE lpDIEEsc)
1062 {
1063         FIXME("(this=%p,%p): stub!\n",
1064               iface, lpDIEEsc);
1065         return DI_OK;
1066 }
1067
1068 static HRESULT WINAPI IDirectInputDevice2AImpl_Poll(
1069         LPDIRECTINPUTDEVICE2A iface)
1070 {
1071         FIXME("(this=%p): stub!\n",
1072               iface);
1073         return DI_OK;
1074 }
1075
1076 static HRESULT WINAPI IDirectInputDevice2AImpl_SendDeviceData(
1077         LPDIRECTINPUTDEVICE2A iface,
1078         DWORD cbObjectData,
1079         LPDIDEVICEOBJECTDATA rgdod,
1080         LPDWORD pdwInOut,
1081         DWORD dwFlags)
1082 {
1083         FIXME("(this=%p,0x%08lx,%p,%p,0x%08lx): stub!\n",
1084               iface, cbObjectData, rgdod, pdwInOut, dwFlags);
1085
1086         return DI_OK;
1087 }
1088
1089 /******************************************************************************
1090  *      SysMouseA (DInput Mouse support)
1091  */
1092
1093 /******************************************************************************
1094   *     Release : release the mouse buffer.
1095   */
1096 static ULONG WINAPI SysMouseAImpl_Release(LPDIRECTINPUTDEVICE2A iface)
1097 {
1098         ICOM_THIS(SysMouseAImpl,iface);
1099
1100         This->ref--;
1101         if (This->ref)
1102                 return This->ref;
1103
1104         /* Free the data queue */
1105         if (This->data_queue != NULL)
1106           HeapFree(GetProcessHeap(),0,This->data_queue);
1107
1108         /* Install the previous event handler (in case of releasing an aquired
1109            mouse device) */
1110         if (This->prev_handler != NULL)
1111           MOUSE_Enable(This->prev_handler);
1112         DeleteCriticalSection(&(This->crit));
1113
1114         /* Free the DataFormat */
1115         if (This->df != &(Wine_InternalMouseFormat)) {
1116           HeapFree(GetProcessHeap(), 0, This->df->rgodf);
1117           HeapFree(GetProcessHeap(), 0, This->df);
1118         }
1119
1120         HeapFree(GetProcessHeap(),0,This);
1121         return 0;
1122 }
1123
1124
1125 /******************************************************************************
1126   *     SetCooperativeLevel : store the window in which we will do our
1127   *   grabbing.
1128   */
1129 static HRESULT WINAPI SysMouseAImpl_SetCooperativeLevel(
1130         LPDIRECTINPUTDEVICE2A iface,HWND hwnd,DWORD dwflags
1131 )
1132 {
1133   ICOM_THIS(SysMouseAImpl,iface);
1134
1135   TRACE("(this=%p,0x%08lx,0x%08lx)\n",This,(DWORD)hwnd,dwflags);
1136
1137   if (TRACE_ON(dinput))
1138     _dump_cooperativelevel(dwflags);
1139
1140   /* Store the window which asks for the mouse */
1141   This->win = hwnd;
1142
1143   return 0;
1144 }
1145
1146
1147 /******************************************************************************
1148   *     SetDataFormat : the application can choose the format of the data
1149   *   the device driver sends back with GetDeviceState.
1150   *
1151   *   For the moment, only the "standard" configuration (c_dfDIMouse) is supported
1152   *   in absolute and relative mode.
1153   */
1154 static HRESULT WINAPI SysMouseAImpl_SetDataFormat(
1155         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
1156 )
1157 {
1158   ICOM_THIS(SysMouseAImpl,iface);
1159   int i;
1160
1161   TRACE("(this=%p,%p)\n",This,df);
1162
1163   TRACE("(df.dwSize=%ld)\n",df->dwSize);
1164   TRACE("(df.dwObjsize=%ld)\n",df->dwObjSize);
1165   TRACE("(df.dwFlags=0x%08lx)\n",df->dwFlags);
1166   TRACE("(df.dwDataSize=%ld)\n",df->dwDataSize);
1167   TRACE("(df.dwNumObjs=%ld)\n",df->dwNumObjs);
1168
1169   for (i=0;i<df->dwNumObjs;i++) {
1170
1171     TRACE("df.rgodf[%d].guid %s (%p)\n",i, debugstr_guid(df->rgodf[i].pguid), df->rgodf[i].pguid);
1172     TRACE("df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
1173     TRACE("dwType 0x%02x,dwInstance %d\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
1174     TRACE("df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
1175   }
1176
1177   /* Check if the mouse is in absolute or relative mode */
1178   if (df->dwFlags == DIDF_ABSAXIS)
1179     This->absolute = 1;
1180   else if (df->dwFlags == DIDF_RELAXIS)
1181     This->absolute = 0;
1182   else
1183     ERR("Neither absolute nor relative flag set.");
1184
1185   /* Store the new data format */
1186   This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
1187   memcpy(This->df, df, df->dwSize);
1188   This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
1189   memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
1190
1191   /* Prepare all the data-conversion filters */
1192   This->wine_df = create_DataFormat(&(Wine_InternalMouseFormat), df, This->offset_array);
1193
1194   return 0;
1195 }
1196
1197 #define GEN_EVENT(offset,data,xtime,seq)                                        \
1198 {                                                                               \
1199   /* If queue_len > 0, queuing is requested -> TRACE the event queued */        \
1200   if (This->queue_len > 0) {                                                    \
1201     TRACE(" queueing %d at offset %d (queue pos %d / size %d)\n",               \
1202           (int) (data), (int) (offset),                                         \
1203           (int) (This->queue_pos), (int) (This->queue_len));                    \
1204                                                                                 \
1205     if ((offset >= 0) && (This->queue_pos < This->queue_len)) {                 \
1206       This->data_queue[This->queue_pos].dwOfs = offset;                         \
1207       This->data_queue[This->queue_pos].dwData = data;                          \
1208       This->data_queue[This->queue_pos].dwTimeStamp = xtime;                    \
1209       This->data_queue[This->queue_pos].dwSequence = seq;                       \
1210       This->queue_pos++;                                                        \
1211     }                                                                           \
1212   }                                                                             \
1213 }
1214
1215
1216 /* Our private mouse event handler */
1217 static void WINAPI dinput_mouse_event( DWORD dwFlags, DWORD dx, DWORD dy,
1218                                       DWORD cButtons, DWORD dwExtraInfo )
1219 {
1220   long posX = -1, posY = -1;
1221   DWORD keyState, xtime, extra;
1222   SysMouseAImpl* This = (SysMouseAImpl*) current_lock;
1223
1224   EnterCriticalSection(&(This->crit));
1225   /* Mouse moved -> send event if asked */
1226   if (This->hEvent)
1227     SetEvent(This->hEvent);
1228
1229   if (   !IsBadReadPtr( (LPVOID)dwExtraInfo, sizeof(WINE_MOUSEEVENT) )
1230       && ((WINE_MOUSEEVENT *)dwExtraInfo)->magic == WINE_MOUSEEVENT_MAGIC ) {
1231     WINE_MOUSEEVENT *wme = (WINE_MOUSEEVENT *)dwExtraInfo;
1232     keyState = wme->keyState;
1233     xtime = wme->time;
1234     extra = (DWORD)wme->hWnd;
1235
1236     if (dwFlags & MOUSEEVENTF_MOVE) {
1237       if (dwFlags & MOUSEEVENTF_ABSOLUTE) {
1238         posX = (dx * GetSystemMetrics(SM_CXSCREEN)) >> 16;
1239         posY = (dy * GetSystemMetrics(SM_CYSCREEN)) >> 16;
1240
1241         if (This->absolute) {
1242           if (posX != This->prevX)
1243             GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], posX, xtime, 0);
1244           if (posY != This->prevY)
1245             GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], posY, xtime, 0);
1246         } else {
1247           /* Now, warp handling */
1248           if ((This->need_warp == WARP_STARTED) &&
1249               (posX == This->win_centerX) && (posX == This->win_centerX)) {
1250             /* Warp has been done... */
1251             This->need_warp = WARP_DONE;
1252             LeaveCriticalSection(&(This->crit));
1253             return;
1254           }
1255
1256           /* Relative mouse input with absolute mouse event : the real fun starts here... */
1257           if ((This->need_warp == WARP_NEEDED) ||
1258               (This->need_warp == WARP_STARTED)) {
1259             if (posX != This->prevX)
1260               GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], posX - This->prevX, xtime, evsequence++);
1261             if (posY != This->prevY)
1262               GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], posY - This->prevY, xtime, evsequence++);
1263           } else {
1264             /* This is the first time the event handler has been called after a
1265                GetData of GetState. */
1266             if (posX != This->win_centerX) {
1267               GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], posX - This->win_centerX, xtime, evsequence++);
1268               This->need_warp = WARP_NEEDED;
1269             }
1270
1271             if (posY != This->win_centerY) {
1272               GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], posY - This->win_centerY, xtime, evsequence++);
1273               This->need_warp = WARP_NEEDED;
1274             }
1275           }
1276         }
1277
1278         This->prevX = posX;
1279         This->prevY = posY;
1280
1281         if (This->absolute) {
1282           This->m_state.lX = posX;
1283           This->m_state.lY = posY;
1284         } else {
1285           This->m_state.lX = posX - This->win_centerX;
1286           This->m_state.lY = posY - This->win_centerY;
1287         }
1288       } else {
1289         /* Mouse reporting is in relative mode */
1290         posX = (long) dx;
1291         posY = (long) dy;
1292
1293         if (This->absolute) {
1294           long aposX, aposY;
1295
1296           aposX = This->m_state.lX + posX;
1297           if (aposX < 0)
1298             aposX = 0;
1299           if (aposX >= GetSystemMetrics(SM_CXSCREEN))
1300             aposX = GetSystemMetrics(SM_CXSCREEN);
1301
1302           aposY = This->m_state.lY + posY;
1303           if (aposY < 0)
1304             aposY = 0;
1305           if (aposY >= GetSystemMetrics(SM_CYSCREEN))
1306             aposY = GetSystemMetrics(SM_CYSCREEN);
1307
1308           if (posX != 0)
1309             GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], aposX, xtime, evsequence++);
1310           if (posY != 0)
1311             GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], aposY, xtime, evsequence++);
1312
1313           This->m_state.lX = aposX;
1314           This->m_state.lY = aposY;
1315         } else {
1316           if (posX != 0)
1317             GEN_EVENT(This->offset_array[WINE_MOUSE_X_POSITION], posX, xtime, evsequence++);
1318           if (posY != 0)
1319             GEN_EVENT(This->offset_array[WINE_MOUSE_Y_POSITION], posY, xtime, evsequence++);
1320
1321           This->m_state.lX = posX;
1322           This->m_state.lY = posY;
1323         }
1324       }
1325     }
1326   } else {
1327     ERR("Mouse event not supported...\n");
1328     LeaveCriticalSection(&(This->crit));
1329     return ;
1330   }
1331
1332   if (TRACE_ON(dinput)) {
1333     if (dwFlags & MOUSEEVENTF_MOVE)
1334       TRACE(" %ld %ld (%s)", posX, posY,
1335             (dwFlags & MOUSEEVENTF_ABSOLUTE ? "abs" : "rel"));
1336
1337     if ( dwFlags & MOUSEEVENTF_LEFTDOWN ) DPRINTF(" LD ");
1338     if ( dwFlags & MOUSEEVENTF_LEFTUP )   DPRINTF(" LU ");
1339
1340     if ( dwFlags & MOUSEEVENTF_RIGHTDOWN ) DPRINTF(" RD ");
1341     if ( dwFlags & MOUSEEVENTF_RIGHTUP )   DPRINTF(" RU ");
1342
1343     if ( dwFlags & MOUSEEVENTF_MIDDLEDOWN ) DPRINTF(" MD ");
1344     if ( dwFlags & MOUSEEVENTF_MIDDLEUP )   DPRINTF(" MU ");
1345
1346     if (!(This->absolute)) DPRINTF(" W=%d ", This->need_warp);
1347
1348     DPRINTF("\n");
1349   }
1350
1351
1352   if ( dwFlags & MOUSEEVENTF_LEFTDOWN ) {
1353     GEN_EVENT(This->offset_array[WINE_MOUSE_L_POSITION], 0xFF, xtime, evsequence++);
1354     This->m_state.rgbButtons[0] = 0xFF;
1355   }
1356   if ( dwFlags & MOUSEEVENTF_LEFTUP ) {
1357     GEN_EVENT(This->offset_array[WINE_MOUSE_L_POSITION], 0x00, xtime, evsequence++);
1358     This->m_state.rgbButtons[0] = 0x00;
1359   }
1360   if ( dwFlags & MOUSEEVENTF_RIGHTDOWN ) {
1361     GEN_EVENT(This->offset_array[WINE_MOUSE_R_POSITION], 0xFF, xtime, evsequence++);
1362     This->m_state.rgbButtons[1] = 0xFF;
1363   }
1364   if ( dwFlags & MOUSEEVENTF_RIGHTUP ) {
1365     GEN_EVENT(This->offset_array[WINE_MOUSE_R_POSITION], 0x00, xtime, evsequence++);
1366     This->m_state.rgbButtons[1] = 0x00;
1367   }
1368   if ( dwFlags & MOUSEEVENTF_MIDDLEDOWN ) {
1369     GEN_EVENT(This->offset_array[WINE_MOUSE_M_POSITION], 0xFF, xtime, evsequence++);
1370     This->m_state.rgbButtons[2] = 0xFF;
1371   }
1372   if ( dwFlags & MOUSEEVENTF_MIDDLEUP ) {
1373     GEN_EVENT(This->offset_array[WINE_MOUSE_M_POSITION], 0x00, xtime, evsequence++);
1374     This->m_state.rgbButtons[2] = 0x00;
1375   }
1376
1377   TRACE("(X: %ld - Y: %ld   L: %02x M: %02x R: %02x)\n",
1378         This->m_state.lX, This->m_state.lY,
1379         This->m_state.rgbButtons[0], This->m_state.rgbButtons[2], This->m_state.rgbButtons[1]);
1380
1381   LeaveCriticalSection(&(This->crit));
1382 }
1383
1384
1385 /******************************************************************************
1386   *     Acquire : gets exclusive control of the mouse
1387   */
1388 static HRESULT WINAPI SysMouseAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
1389 {
1390   ICOM_THIS(SysMouseAImpl,iface);
1391   RECT  rect;
1392
1393   TRACE("(this=%p)\n",This);
1394
1395   if (This->acquired == 0) {
1396     POINT       point;
1397
1398     /* This stores the current mouse handler. */
1399     This->prev_handler = mouse_event;
1400
1401     /* Store (in a global variable) the current lock */
1402     current_lock = (IDirectInputDevice2A*)This;
1403
1404     /* Init the mouse state */
1405     if (This->absolute) {
1406       This->m_state.lX = PosX;
1407       This->m_state.lY = PosY;
1408
1409       This->prevX = PosX;
1410       This->prevY = PosY;
1411     } else {
1412       This->m_state.lX = 0;
1413       This->m_state.lY = 0;
1414     }
1415     This->m_state.rgbButtons[0] = (MouseButtonsStates[0] ? 0xFF : 0x00);
1416     This->m_state.rgbButtons[1] = (MouseButtonsStates[1] ? 0xFF : 0x00);
1417     This->m_state.rgbButtons[2] = (MouseButtonsStates[2] ? 0xFF : 0x00);
1418
1419     /* Install our own mouse event handler */
1420     MOUSE_Enable(dinput_mouse_event);
1421
1422     /* Get the window dimension and find the center */
1423     GetWindowRect(This->win, &rect);
1424     This->win_centerX = (rect.right  - rect.left) / 2;
1425     This->win_centerY = (rect.bottom - rect.top ) / 2;
1426
1427     /* Warp the mouse to the center of the window */
1428     if (This->absolute == 0) {
1429       TRACE("Warping mouse to %ld - %ld\n", This->win_centerX, This->win_centerY);
1430       point.x = This->win_centerX;
1431       point.y = This->win_centerY;
1432       MapWindowPoints(This->win, HWND_DESKTOP, &point, 1);
1433       USER_Driver.pMoveCursor( point.x, point.y );
1434       This->need_warp = WARP_STARTED;
1435     }
1436
1437     This->acquired = 1;
1438   }
1439   return 0;
1440 }
1441
1442 /******************************************************************************
1443   *     Unacquire : frees the mouse
1444   */
1445 static HRESULT WINAPI SysMouseAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
1446 {
1447   ICOM_THIS(SysMouseAImpl,iface);
1448
1449   TRACE("(this=%p)\n",This);
1450
1451   /* Reinstall previous mouse event handler */
1452   MOUSE_Enable(This->prev_handler);
1453   This->prev_handler = NULL;
1454
1455   /* No more locks */
1456   current_lock = NULL;
1457
1458   /* Unacquire device */
1459   This->acquired = 0;
1460
1461   return 0;
1462 }
1463
1464 /******************************************************************************
1465   *     GetDeviceState : returns the "state" of the mouse.
1466   *
1467   *   For the moment, only the "standard" return structure (DIMOUSESTATE) is
1468   *   supported.
1469   */
1470 static HRESULT WINAPI SysMouseAImpl_GetDeviceState(
1471         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
1472 ) {
1473   ICOM_THIS(SysMouseAImpl,iface);
1474
1475   EnterCriticalSection(&(This->crit));
1476   TRACE("(this=%p,0x%08lx,%p): \n",This,len,ptr);
1477
1478   /* Copy the current mouse state */
1479   fill_DataFormat(ptr, &(This->m_state), This->wine_df);
1480
1481   /* Initialize the buffer when in relative mode */
1482   if (This->absolute == 0) {
1483     This->m_state.lX = 0;
1484     This->m_state.lY = 0;
1485   }
1486
1487   /* Check if we need to do a mouse warping */
1488   if (This->need_warp == WARP_NEEDED) {
1489     POINT point;
1490
1491     TRACE("Warping mouse to %ld - %ld\n", This->win_centerX, This->win_centerY);
1492     point.x = This->win_centerX;
1493     point.y = This->win_centerY;
1494     MapWindowPoints(This->win, HWND_DESKTOP, &point, 1);
1495     USER_Driver.pMoveCursor( point.x, point.y );
1496
1497     This->need_warp = WARP_STARTED;
1498   }
1499
1500   LeaveCriticalSection(&(This->crit));
1501
1502   TRACE("(X: %ld - Y: %ld   L: %02x M: %02x R: %02x)\n",
1503         This->m_state.lX, This->m_state.lY,
1504         This->m_state.rgbButtons[0], This->m_state.rgbButtons[2], This->m_state.rgbButtons[1]);
1505
1506   return 0;
1507 }
1508
1509 /******************************************************************************
1510   *     GetDeviceState : gets buffered input data.
1511   */
1512 static HRESULT WINAPI SysMouseAImpl_GetDeviceData(LPDIRECTINPUTDEVICE2A iface,
1513                                               DWORD dodsize,
1514                                               LPDIDEVICEOBJECTDATA dod,
1515                                               LPDWORD entries,
1516                                               DWORD flags
1517 ) {
1518   ICOM_THIS(SysMouseAImpl,iface);
1519
1520   EnterCriticalSection(&(This->crit));
1521   TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This,dodsize,*entries,flags);
1522
1523   if (flags & DIGDD_PEEK)
1524     FIXME("DIGDD_PEEK\n");
1525
1526   if (dod == NULL) {
1527     *entries = This->queue_pos;
1528     This->queue_pos = 0;
1529   } else {
1530     /* Check for buffer overflow */
1531     if (This->queue_pos > *entries) {
1532       WARN("Buffer overflow not handled properly yet...\n");
1533       This->queue_pos = *entries;
1534     }
1535     if (dodsize != sizeof(DIDEVICEOBJECTDATA)) {
1536       ERR("Wrong structure size !\n");
1537       LeaveCriticalSection(&(This->crit));
1538       return DIERR_INVALIDPARAM;
1539     }
1540
1541     if (This->queue_pos)
1542         TRACE("Application retrieving %d event(s).\n", This->queue_pos);
1543
1544     /* Copy the buffered data into the application queue */
1545     memcpy(dod, This->data_queue, This->queue_pos * dodsize);
1546     *entries = This->queue_pos;
1547
1548     /* Reset the event queue */
1549     This->queue_pos = 0;
1550   }
1551   LeaveCriticalSection(&(This->crit));
1552
1553   /* Check if we need to do a mouse warping */
1554   if (This->need_warp == WARP_NEEDED) {
1555     POINT point;
1556
1557     TRACE("Warping mouse to %ld - %ld\n", This->win_centerX, This->win_centerY);
1558     point.x = This->win_centerX;
1559     point.y = This->win_centerY;
1560     MapWindowPoints(This->win, HWND_DESKTOP, &point, 1);
1561
1562     USER_Driver.pMoveCursor( point.x, point.y );
1563
1564     This->need_warp = WARP_STARTED;
1565   }
1566   return 0;
1567 }
1568
1569 /******************************************************************************
1570   *     SetProperty : change input device properties
1571   */
1572 static HRESULT WINAPI SysMouseAImpl_SetProperty(LPDIRECTINPUTDEVICE2A iface,
1573                                             REFGUID rguid,
1574                                             LPCDIPROPHEADER ph)
1575 {
1576   ICOM_THIS(SysMouseAImpl,iface);
1577
1578   TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
1579
1580   if (!HIWORD(rguid)) {
1581     switch ((DWORD)rguid) {
1582     case (DWORD) DIPROP_BUFFERSIZE: {
1583       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
1584
1585       TRACE("buffersize = %ld\n",pd->dwData);
1586
1587       This->data_queue = (LPDIDEVICEOBJECTDATA)HeapAlloc(GetProcessHeap(),0,
1588                                                           pd->dwData * sizeof(DIDEVICEOBJECTDATA));
1589       This->queue_pos  = 0;
1590       This->queue_len  = pd->dwData;
1591       break;
1592     }
1593     default:
1594       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1595       break;
1596     }
1597   }
1598
1599   return 0;
1600 }
1601
1602 /******************************************************************************
1603   *     GetProperty : get input device properties
1604   */
1605 static HRESULT WINAPI SysMouseAImpl_GetProperty(LPDIRECTINPUTDEVICE2A iface,
1606                                                 REFGUID rguid,
1607                                                 LPDIPROPHEADER pdiph)
1608 {
1609   ICOM_THIS(SysMouseAImpl,iface);
1610
1611   TRACE("(this=%p,%s,%p): stub!\n",
1612         iface, debugstr_guid(rguid), pdiph);
1613
1614   if (TRACE_ON(dinput))
1615     _dump_DIPROPHEADER(pdiph);
1616
1617   if (!HIWORD(rguid)) {
1618     switch ((DWORD)rguid) {
1619     case (DWORD) DIPROP_BUFFERSIZE: {
1620       LPDIPROPDWORD     pd = (LPDIPROPDWORD)pdiph;
1621
1622       TRACE(" return buffersize = %d\n",This->queue_len);
1623       pd->dwData = This->queue_len;
1624       break;
1625     }
1626
1627     case (DWORD) DIPROP_RANGE: {
1628       LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
1629
1630       if ((pdiph->dwHow == DIPH_BYID) &&
1631           ((pdiph->dwObj == (DIDFT_MAKEINSTANCE(WINE_MOUSE_X_AXIS_INSTANCE) | DIDFT_RELAXIS)) ||
1632            (pdiph->dwObj == (DIDFT_MAKEINSTANCE(WINE_MOUSE_Y_AXIS_INSTANCE) | DIDFT_RELAXIS)))) {
1633         /* Querying the range of either the X or the Y axis.  As I do
1634            not know the range, do as if the range where
1635            unrestricted...*/
1636         pr->lMin = DIPROPRANGE_NOMIN;
1637         pr->lMax = DIPROPRANGE_NOMAX;
1638       }
1639
1640       break;
1641     }
1642
1643     default:
1644       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1645       break;
1646     }
1647   }
1648
1649
1650   return DI_OK;
1651 }
1652
1653
1654
1655 /******************************************************************************
1656   *     SetEventNotification : specifies event to be sent on state change
1657   */
1658 static HRESULT WINAPI SysMouseAImpl_SetEventNotification(LPDIRECTINPUTDEVICE2A iface,
1659                                                          HANDLE hnd) {
1660   ICOM_THIS(SysMouseAImpl,iface);
1661
1662   TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
1663
1664   This->hEvent = hnd;
1665
1666   return DI_OK;
1667 }
1668
1669 /******************************************************************************
1670   *     GetCapabilities : get the device capablitites
1671   */
1672 static HRESULT WINAPI SysMouseAImpl_GetCapabilities(
1673         LPDIRECTINPUTDEVICE2A iface,
1674         LPDIDEVCAPS lpDIDevCaps)
1675 {
1676   ICOM_THIS(SysMouseAImpl,iface);
1677
1678   TRACE("(this=%p,%p)\n",This,lpDIDevCaps);
1679
1680   if (lpDIDevCaps->dwSize == sizeof(DIDEVCAPS)) {
1681     lpDIDevCaps->dwFlags = DIDC_ATTACHED;
1682     lpDIDevCaps->dwDevType = DIDEVTYPE_MOUSE;
1683     lpDIDevCaps->dwAxes = 2;
1684     lpDIDevCaps->dwButtons = 3;
1685     lpDIDevCaps->dwPOVs = 0;
1686     lpDIDevCaps->dwFFSamplePeriod = 0;
1687     lpDIDevCaps->dwFFMinTimeResolution = 0;
1688     lpDIDevCaps->dwFirmwareRevision = 100;
1689     lpDIDevCaps->dwHardwareRevision = 100;
1690     lpDIDevCaps->dwFFDriverVersion = 0;
1691   } else {
1692     /* DirectX 3.0 */
1693     FIXME("DirectX 3.0 not supported....\n");
1694   }
1695
1696   return DI_OK;
1697 }
1698
1699
1700 /******************************************************************************
1701   *     EnumObjects : enumerate the different buttons and axis...
1702   */
1703 static HRESULT WINAPI SysMouseAImpl_EnumObjects(
1704         LPDIRECTINPUTDEVICE2A iface,
1705         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
1706         LPVOID lpvRef,
1707         DWORD dwFlags)
1708 {
1709   ICOM_THIS(SysMouseAImpl,iface);
1710   DIDEVICEOBJECTINSTANCEA ddoi;
1711
1712   TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
1713   if (TRACE_ON(dinput)) {
1714     DPRINTF("  - flags = ");
1715     _dump_EnumObjects_flags(dwFlags);
1716     DPRINTF("\n");
1717   }
1718
1719   /* Only the fields till dwFFMaxForce are relevant */
1720   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
1721
1722   /* In a mouse, we have : two relative axis and three buttons */
1723   if ((dwFlags == DIDFT_ALL) ||
1724       (dwFlags & DIDFT_AXIS)) {
1725     /* X axis */
1726     ddoi.guidType = GUID_XAxis;
1727     ddoi.dwOfs = This->offset_array[WINE_MOUSE_X_POSITION];
1728     ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_X_AXIS_INSTANCE) | DIDFT_RELAXIS;
1729     strcpy(ddoi.tszName, "X-Axis");
1730     _dump_OBJECTINSTANCEA(&ddoi);
1731     if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1732
1733     /* Y axis */
1734     ddoi.guidType = GUID_YAxis;
1735     ddoi.dwOfs = This->offset_array[WINE_MOUSE_Y_POSITION];
1736     ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_Y_AXIS_INSTANCE) | DIDFT_RELAXIS;
1737     strcpy(ddoi.tszName, "Y-Axis");
1738     _dump_OBJECTINSTANCEA(&ddoi);
1739     if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1740   }
1741
1742   if ((dwFlags == DIDFT_ALL) ||
1743       (dwFlags & DIDFT_BUTTON)) {
1744     ddoi.guidType = GUID_Button;
1745
1746     /* Left button */
1747     ddoi.dwOfs = This->offset_array[WINE_MOUSE_L_POSITION];
1748     ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_L_BUTTON_INSTANCE) | DIDFT_PSHBUTTON;
1749     strcpy(ddoi.tszName, "Left-Button");
1750     _dump_OBJECTINSTANCEA(&ddoi);
1751     if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1752
1753     /* Right button */
1754     ddoi.dwOfs = This->offset_array[WINE_MOUSE_R_POSITION];
1755     ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_R_BUTTON_INSTANCE) | DIDFT_PSHBUTTON;
1756     strcpy(ddoi.tszName, "Right-Button");
1757     _dump_OBJECTINSTANCEA(&ddoi);
1758     if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1759
1760     /* Middle button */
1761     ddoi.dwOfs = This->offset_array[WINE_MOUSE_M_POSITION];
1762     ddoi.dwType = DIDFT_MAKEINSTANCE(WINE_MOUSE_M_BUTTON_INSTANCE) | DIDFT_PSHBUTTON;
1763     strcpy(ddoi.tszName, "Middle-Button");
1764     _dump_OBJECTINSTANCEA(&ddoi);
1765     if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1766   }
1767
1768   return DI_OK;
1769 }
1770
1771
1772
1773 #ifdef HAVE_LINUX_22_JOYSTICK_API
1774 /******************************************************************************
1775  *      Joystick
1776  */
1777 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE2A iface)
1778 {
1779         ICOM_THIS(JoystickAImpl,iface);
1780
1781         This->ref--;
1782         if (This->ref)
1783                 return This->ref;
1784
1785         /* Free the data queue */
1786         if (This->data_queue != NULL)
1787           HeapFree(GetProcessHeap(),0,This->data_queue);
1788
1789         /* Free the DataFormat */
1790         HeapFree(GetProcessHeap(), 0, This->df);
1791
1792         HeapFree(GetProcessHeap(),0,This);
1793         return 0;
1794 }
1795
1796 /******************************************************************************
1797   *   SetDataFormat : the application can choose the format of the data
1798   *   the device driver sends back with GetDeviceState.
1799   */
1800 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
1801         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
1802 )
1803 {
1804   ICOM_THIS(JoystickAImpl,iface);
1805   int i;
1806
1807   TRACE("(this=%p,%p)\n",This,df);
1808
1809   TRACE("(df.dwSize=%ld)\n",df->dwSize);
1810   TRACE("(df.dwObjsize=%ld)\n",df->dwObjSize);
1811   TRACE("(df.dwFlags=0x%08lx)\n",df->dwFlags);
1812   TRACE("(df.dwDataSize=%ld)\n",df->dwDataSize);
1813   TRACE("(df.dwNumObjs=%ld)\n",df->dwNumObjs);
1814
1815   for (i=0;i<df->dwNumObjs;i++) {
1816     TRACE("df.rgodf[%d].guid %s (%p)\n",i,debugstr_guid(df->rgodf[i].pguid), df->rgodf[i].pguid);
1817     TRACE("df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
1818     TRACE("dwType 0x%02x,dwInstance %d\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
1819     TRACE("df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
1820   }
1821
1822   /* Store the new data format */
1823   This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
1824   memcpy(This->df, df, df->dwSize);
1825   This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
1826   memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
1827
1828   return 0;
1829 }
1830
1831 /******************************************************************************
1832   *     Acquire : gets exclusive control of the joystick
1833   */
1834 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
1835 {
1836     ICOM_THIS(JoystickAImpl,iface);
1837
1838     TRACE("(this=%p)\n",This);
1839     if (This->joyfd!=-1)
1840         return 0;
1841     This->joyfd=open(JOYDEV,O_RDONLY);
1842     if (This->joyfd==-1)
1843         return DIERR_NOTFOUND;
1844     return 0;
1845 }
1846
1847 /******************************************************************************
1848   *     Unacquire : frees the joystick
1849   */
1850 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
1851 {
1852     ICOM_THIS(JoystickAImpl,iface);
1853
1854     TRACE("(this=%p)\n",This);
1855     if (This->joyfd!=-1) {
1856         close(This->joyfd);
1857         This->joyfd = -1;
1858     }
1859     return 0;
1860 }
1861
1862 #define map_axis(val) ((val+32768)*(This->lMax-This->lMin)/65536+This->lMin)
1863
1864 static void joy_polldev(JoystickAImpl *This) {
1865     struct timeval tv;
1866     fd_set      readfds;
1867     struct      js_event jse;
1868
1869     if (This->joyfd==-1)
1870         return;
1871     while (1) {
1872         memset(&tv,0,sizeof(tv));
1873         FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
1874         if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
1875             return;
1876         /* we have one event, so we can read */
1877         if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
1878             return;
1879         }
1880         TRACE("js_event: type 0x%x, number %d, value %d\n",jse.type,jse.number,jse.value);
1881         if (jse.type & JS_EVENT_BUTTON) {
1882             GEN_EVENT(DIJOFS_BUTTON(jse.number),jse.value?0x80:0x00,jse.time,evsequence++);
1883             This->js.rgbButtons[jse.number] = jse.value?0x80:0x00;
1884         }
1885         if (jse.type & JS_EVENT_AXIS) {
1886             switch (jse.number) {
1887             case 0:
1888                 GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
1889                 This->js.lX = map_axis(jse.value);
1890                 break;
1891             case 1:
1892                 GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
1893                 This->js.lY = map_axis(jse.value);
1894                 break;
1895             case 2:
1896                 GEN_EVENT(jse.number*4,jse.value,jse.time,evsequence++);
1897                 This->js.lZ = map_axis(jse.value);
1898                 break;
1899             default:
1900                 FIXME("more then 3 axes (%d) not handled!\n",jse.number);
1901                 break;
1902             }
1903         }
1904     }
1905 }
1906
1907 /******************************************************************************
1908   *     GetDeviceState : returns the "state" of the joystick.
1909   *
1910   */
1911 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
1912         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
1913 ) {
1914     ICOM_THIS(JoystickAImpl,iface);
1915
1916     joy_polldev(This);
1917     TRACE("(this=%p,0x%08lx,%p)\n",This,len,ptr);
1918     if (len != sizeof(DIJOYSTATE)) {
1919         FIXME("len %ld is not sizeof(DIJOYSTATE), unsupported format.\n",len);
1920     }
1921     memcpy(ptr,&(This->js),len);
1922     This->queue_pos = 0;
1923     return 0;
1924 }
1925
1926 /******************************************************************************
1927   *     GetDeviceState : gets buffered input data.
1928   */
1929 static HRESULT WINAPI JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE2A iface,
1930                                               DWORD dodsize,
1931                                               LPDIDEVICEOBJECTDATA dod,
1932                                               LPDWORD entries,
1933                                               DWORD flags
1934 ) {
1935   ICOM_THIS(JoystickAImpl,iface);
1936
1937   FIXME("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx),STUB!\n",This,dodsize,*entries,flags);
1938
1939   joy_polldev(This);
1940   if (flags & DIGDD_PEEK)
1941     FIXME("DIGDD_PEEK\n");
1942
1943   if (dod == NULL) {
1944   } else {
1945   }
1946   return 0;
1947 }
1948
1949 /******************************************************************************
1950   *     SetProperty : change input device properties
1951   */
1952 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE2A iface,
1953                                             REFGUID rguid,
1954                                             LPCDIPROPHEADER ph)
1955 {
1956   ICOM_THIS(JoystickAImpl,iface);
1957
1958   FIXME("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
1959   FIXME("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph->dwSize, ph->dwHeaderSize,ph->dwObj,ph->dwHow);
1960
1961   if (!HIWORD(rguid)) {
1962     switch ((DWORD)rguid) {
1963     case (DWORD) DIPROP_BUFFERSIZE: {
1964       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
1965
1966       FIXME("buffersize = %ld\n",pd->dwData);
1967       break;
1968     }
1969     case (DWORD)DIPROP_RANGE: {
1970       LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
1971
1972       FIXME("proprange(%ld,%ld)\n",pr->lMin,pr->lMax);
1973       This->lMin = pr->lMin;
1974       This->lMax = pr->lMax;
1975       break;
1976     }
1977     case (DWORD)DIPROP_DEADZONE: {
1978       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
1979
1980       FIXME("deadzone(%ld)\n",pd->dwData);
1981       This->deadzone = pd->dwData;
1982       break;
1983     }
1984     default:
1985       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1986       break;
1987     }
1988   }
1989   return 0;
1990 }
1991
1992 /******************************************************************************
1993   *     SetEventNotification : specifies event to be sent on state change
1994   */
1995 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
1996         LPDIRECTINPUTDEVICE2A iface, HANDLE hnd
1997 ) {
1998     ICOM_THIS(JoystickAImpl,iface);
1999
2000     TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
2001     This->hEvent = hnd;
2002     return DI_OK;
2003 }
2004
2005 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
2006         LPDIRECTINPUTDEVICE2A iface,
2007         LPDIDEVCAPS lpDIDevCaps)
2008 {
2009     ICOM_THIS(JoystickAImpl,iface);
2010     BYTE        axes,buttons;
2011     int         xfd = This->joyfd;
2012
2013     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
2014     if (xfd==-1)
2015         xfd = open(JOYDEV,O_RDONLY);
2016     lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
2017     lpDIDevCaps->dwDevType      = DIDEVTYPE_JOYSTICK;
2018 #ifdef JSIOCGAXES
2019     if (-1==ioctl(xfd,JSIOCGAXES,&axes))
2020         axes = 2;
2021     lpDIDevCaps->dwAxes = axes;
2022 #endif
2023 #ifdef JSIOCGBUTTONS
2024     if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
2025         buttons = 2;
2026     lpDIDevCaps->dwButtons = buttons;
2027 #endif
2028     if (xfd!=This->joyfd)
2029         close(xfd);
2030     return DI_OK;
2031 }
2032 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE2A iface) {
2033     ICOM_THIS(JoystickAImpl,iface);
2034     TRACE("(),stub!\n");
2035
2036     joy_polldev(This);
2037     return DI_OK;
2038 }
2039
2040 /******************************************************************************
2041   *     EnumObjects : enumerate the different buttons and axis...
2042   */
2043 static HRESULT WINAPI JoystickAImpl_EnumObjects(
2044         LPDIRECTINPUTDEVICE2A iface,
2045         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
2046         LPVOID lpvRef,
2047         DWORD dwFlags)
2048 {
2049   ICOM_THIS(JoystickAImpl,iface);
2050   DIDEVICEOBJECTINSTANCEA ddoi;
2051   int xfd = This->joyfd;
2052
2053   TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
2054   if (TRACE_ON(dinput)) {
2055     DPRINTF("  - flags = ");
2056     _dump_EnumObjects_flags(dwFlags);
2057     DPRINTF("\n");
2058   }
2059
2060   /* Only the fields till dwFFMaxForce are relevant */
2061   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
2062
2063   /* For the joystick, do as is done in the GetCapabilities function */
2064   if ((dwFlags == DIDFT_ALL) ||
2065       (dwFlags & DIDFT_AXIS)) {
2066     BYTE axes, i;
2067
2068 #ifdef JSIOCGAXES
2069     if (-1==ioctl(xfd,JSIOCGAXES,&axes))
2070       axes = 2;
2071 #endif
2072
2073     for (i = 0; i < axes; i++) {
2074       switch (i) {
2075       case 0:
2076         ddoi.guidType = GUID_XAxis;
2077         ddoi.dwOfs = DIJOFS_X;
2078         break;
2079       case 1:
2080         ddoi.guidType = GUID_YAxis;
2081         ddoi.dwOfs = DIJOFS_Y;
2082         break;
2083       case 2:
2084         ddoi.guidType = GUID_ZAxis;
2085         ddoi.dwOfs = DIJOFS_Z;
2086         break;
2087       default:
2088         ddoi.guidType = GUID_Unknown;
2089         ddoi.dwOfs = DIJOFS_Z + (i - 2) * sizeof(LONG);
2090       }
2091       ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << i) << WINE_JOYSTICK_AXIS_BASE) | DIDFT_ABSAXIS;
2092       sprintf(ddoi.tszName, "%d-Axis", i);
2093       _dump_OBJECTINSTANCEA(&ddoi);
2094       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
2095     }
2096   }
2097
2098   if ((dwFlags == DIDFT_ALL) ||
2099       (dwFlags & DIDFT_BUTTON)) {
2100     BYTE buttons, i;
2101
2102 #ifdef JSIOCGBUTTONS
2103     if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
2104       buttons = 2;
2105 #endif
2106
2107     /* The DInput SDK says that GUID_Button is only for mouse buttons but well... */
2108     ddoi.guidType = GUID_Button;
2109
2110     for (i = 0; i < buttons; i++) {
2111       ddoi.dwOfs = DIJOFS_BUTTON(i);
2112       ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << i) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
2113       sprintf(ddoi.tszName, "%d-Button", i);
2114       _dump_OBJECTINSTANCEA(&ddoi);
2115       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
2116     }
2117   }
2118
2119   if (xfd!=This->joyfd)
2120     close(xfd);
2121
2122   return DI_OK;
2123 }
2124
2125 /******************************************************************************
2126   *     GetProperty : get input device properties
2127   */
2128 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE2A iface,
2129                                                 REFGUID rguid,
2130                                                 LPDIPROPHEADER pdiph)
2131 {
2132   ICOM_THIS(JoystickAImpl,iface);
2133
2134   TRACE("(this=%p,%s,%p): stub!\n",
2135         iface, debugstr_guid(rguid), pdiph);
2136
2137   if (TRACE_ON(dinput))
2138     _dump_DIPROPHEADER(pdiph);
2139
2140   if (!HIWORD(rguid)) {
2141     switch ((DWORD)rguid) {
2142     case (DWORD) DIPROP_BUFFERSIZE: {
2143       LPDIPROPDWORD     pd = (LPDIPROPDWORD)pdiph;
2144
2145       TRACE(" return buffersize = %d\n",This->queue_len);
2146       pd->dwData = This->queue_len;
2147       break;
2148     }
2149
2150     case (DWORD) DIPROP_RANGE: {
2151       LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
2152
2153       if ((pdiph->dwHow == DIPH_BYID) &&
2154           (pdiph->dwObj & DIDFT_ABSAXIS)) {
2155         /* The app is querying the current range of the axis : return the lMin and lMax values */
2156         pr->lMin = This->lMin;
2157         pr->lMax = This->lMax;
2158       }
2159
2160       break;
2161     }
2162
2163     default:
2164       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
2165       break;
2166     }
2167   }
2168
2169
2170   return DI_OK;
2171 }
2172
2173 #endif
2174
2175 /****************************************************************************/
2176 /****************************************************************************/
2177
2178 static ICOM_VTABLE(IDirectInputDevice2A) SysKeyboardAvt =
2179 {
2180         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2181         IDirectInputDevice2AImpl_QueryInterface,
2182         IDirectInputDevice2AImpl_AddRef,
2183         IDirectInputDevice2AImpl_Release,
2184         SysKeyboardAImpl_GetCapabilities,
2185         IDirectInputDevice2AImpl_EnumObjects,
2186         IDirectInputDevice2AImpl_GetProperty,
2187         SysKeyboardAImpl_SetProperty,
2188         SysKeyboardAImpl_Acquire,
2189         SysKeyboardAImpl_Unacquire,
2190         SysKeyboardAImpl_GetDeviceState,
2191         SysKeyboardAImpl_GetDeviceData,
2192         IDirectInputDevice2AImpl_SetDataFormat,
2193         IDirectInputDevice2AImpl_SetEventNotification,
2194         IDirectInputDevice2AImpl_SetCooperativeLevel,
2195         IDirectInputDevice2AImpl_GetObjectInfo,
2196         IDirectInputDevice2AImpl_GetDeviceInfo,
2197         IDirectInputDevice2AImpl_RunControlPanel,
2198         IDirectInputDevice2AImpl_Initialize,
2199         IDirectInputDevice2AImpl_CreateEffect,
2200         IDirectInputDevice2AImpl_EnumEffects,
2201         IDirectInputDevice2AImpl_GetEffectInfo,
2202         IDirectInputDevice2AImpl_GetForceFeedbackState,
2203         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
2204         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
2205         IDirectInputDevice2AImpl_Escape,
2206         IDirectInputDevice2AImpl_Poll,
2207         IDirectInputDevice2AImpl_SendDeviceData,
2208 };
2209
2210 static ICOM_VTABLE(IDirectInputDevice2A) SysMouseAvt =
2211 {
2212         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2213         IDirectInputDevice2AImpl_QueryInterface,
2214         IDirectInputDevice2AImpl_AddRef,
2215         SysMouseAImpl_Release,
2216         SysMouseAImpl_GetCapabilities,
2217         SysMouseAImpl_EnumObjects,
2218         SysMouseAImpl_GetProperty,
2219         SysMouseAImpl_SetProperty,
2220         SysMouseAImpl_Acquire,
2221         SysMouseAImpl_Unacquire,
2222         SysMouseAImpl_GetDeviceState,
2223         SysMouseAImpl_GetDeviceData,
2224         SysMouseAImpl_SetDataFormat,
2225         SysMouseAImpl_SetEventNotification,
2226         SysMouseAImpl_SetCooperativeLevel,
2227         IDirectInputDevice2AImpl_GetObjectInfo,
2228         IDirectInputDevice2AImpl_GetDeviceInfo,
2229         IDirectInputDevice2AImpl_RunControlPanel,
2230         IDirectInputDevice2AImpl_Initialize,
2231         IDirectInputDevice2AImpl_CreateEffect,
2232         IDirectInputDevice2AImpl_EnumEffects,
2233         IDirectInputDevice2AImpl_GetEffectInfo,
2234         IDirectInputDevice2AImpl_GetForceFeedbackState,
2235         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
2236         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
2237         IDirectInputDevice2AImpl_Escape,
2238         IDirectInputDevice2AImpl_Poll,
2239         IDirectInputDevice2AImpl_SendDeviceData,
2240 };
2241
2242 #ifdef HAVE_LINUX_22_JOYSTICK_API
2243 static ICOM_VTABLE(IDirectInputDevice2A) JoystickAvt =
2244 {
2245         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2246         IDirectInputDevice2AImpl_QueryInterface,
2247         IDirectInputDevice2AImpl_AddRef,
2248         JoystickAImpl_Release,
2249         JoystickAImpl_GetCapabilities,
2250         JoystickAImpl_EnumObjects,
2251         JoystickAImpl_GetProperty,
2252         JoystickAImpl_SetProperty,
2253         JoystickAImpl_Acquire,
2254         JoystickAImpl_Unacquire,
2255         JoystickAImpl_GetDeviceState,
2256         JoystickAImpl_GetDeviceData,
2257         JoystickAImpl_SetDataFormat,
2258         JoystickAImpl_SetEventNotification,
2259         IDirectInputDevice2AImpl_SetCooperativeLevel,
2260         IDirectInputDevice2AImpl_GetObjectInfo,
2261         IDirectInputDevice2AImpl_GetDeviceInfo,
2262         IDirectInputDevice2AImpl_RunControlPanel,
2263         IDirectInputDevice2AImpl_Initialize,
2264         IDirectInputDevice2AImpl_CreateEffect,
2265         IDirectInputDevice2AImpl_EnumEffects,
2266         IDirectInputDevice2AImpl_GetEffectInfo,
2267         IDirectInputDevice2AImpl_GetForceFeedbackState,
2268         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
2269         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
2270         IDirectInputDevice2AImpl_Escape,
2271         JoystickAImpl_Poll,
2272         IDirectInputDevice2AImpl_SendDeviceData,
2273 };
2274 #endif
2275
2276 /***********************************************************************
2277  *              DllCanUnloadNow (DINPUT.@)
2278  */
2279 HRESULT WINAPI DINPUT_DllCanUnloadNow(void)
2280 {
2281     FIXME("(void): stub\n");
2282
2283     return S_FALSE;
2284 }
2285
2286 /***********************************************************************
2287  *              DllGetClassObject (DINPUT.@)
2288  */
2289 HRESULT WINAPI DINPUT_DllGetClassObject(REFCLSID rclsid, REFIID riid,
2290                                         LPVOID *ppv)
2291 {
2292     FIXME("(%p, %p, %p): stub\n", debugstr_guid(rclsid),
2293           debugstr_guid(riid), ppv);
2294
2295     return CLASS_E_CLASSNOTAVAILABLE;
2296 }
2297
2298 /***********************************************************************
2299  *              DllRegisterServer (DINPUT.@)
2300  */
2301 HRESULT WINAPI DINPUT_DllRegisterServer(void)
2302 {
2303     FIXME("(void): stub\n");
2304
2305     return S_OK;
2306 }
2307
2308 /***********************************************************************
2309  *              DllUnregisterServer (DINPUT.@)
2310  */
2311 HRESULT WINAPI DINPUT_DllUnregisterServer(void)
2312 {
2313     FIXME("(void): stub\n");
2314
2315     return S_OK;
2316 }