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