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

   1 /*              DirectInput Joystick device
   2  *
   3  * Copyright 1998,2000 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #ifdef HAVE_LINUX_INPUT_H
  26
  27 #include <assert.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <time.h>
  32 #ifdef HAVE_UNISTD_H
  33 # include <unistd.h>
  34 #endif
  35 #ifdef HAVE_SYS_TIME_H
  36 # include <sys/time.h>
  37 #endif
  38 #include <sys/fcntl.h>
  39 #ifdef HAVE_SYS_IOCTL_H
  40 # include <sys/ioctl.h>
  41 #endif
  42 #include <errno.h>
  43 #ifdef HAVE_SYS_ERRNO_H
  44 # include <sys/errno.h>
  45 #endif
  46
  47 #ifdef HAVE_CORRECT_LINUXINPUT_H
  48
  49 #ifdef HAVE_LINUX_INPUT_H
  50 # include <linux/input.h>
  51 #endif
  52
  53
  54 #define EVDEVPREFIX     "/dev/input/event"
  55
  56 #include "wine/debug.h"
  57 #include "wine/unicode.h"
  58 #include "windef.h"
  59 #include "winbase.h"
  60 #include "winerror.h"
  61 #include "dinput.h"
  62
  63 #include "dinput_private.h"
  64 #include "device_private.h"
  65
  66 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  67
  68 /* Wine joystick driver object instances */
  69 #define WINE_JOYSTICK_AXIS_BASE   0
  70 #define WINE_JOYSTICK_BUTTON_BASE 8
  71
  72 typedef struct JoystickImpl JoystickImpl;
  73 static IDirectInputDevice8AVtbl JoystickAvt;
  74 static IDirectInputDevice8WVtbl JoystickWvt;
  75 struct JoystickImpl
  76 {
  77         LPVOID                          lpVtbl;
  78         DWORD                           ref;
  79         GUID                            guid;
  80
  81
  82         /* The 'parent' DInput */
  83         IDirectInputImpl               *dinput;
  84
  85         /* joystick private */
  86         /* what range and deadzone the game wants */
  87         LONG                            wantmin[ABS_MAX];
  88         LONG                            wantmax[ABS_MAX];
  89         LONG                            deadz[ABS_MAX];
  90
  91         /* autodetecting ranges per axe by following movement */
  92         LONG                            havemax[ABS_MAX];
  93         LONG                            havemin[ABS_MAX];
  94
  95         int                             joyfd;
  96
  97         LPDIDATAFORMAT                  df;
  98         HANDLE                          hEvent;
  99         LPDIDEVICEOBJECTDATA            data_queue;
 100         int                             queue_head, queue_tail, queue_len;
 101         BOOL                            overflow;
 102         DIJOYSTATE2                     js;
 103
 104         /* data returned by the EVIOCGABS() ioctl */
 105         int                             axes[ABS_MAX+1][5];
 106
 107 #define AXE_ABS         0
 108 #define AXE_ABSMIN      1
 109 #define AXE_ABSMAX      2
 110 #define AXE_ABSFUZZ     3
 111 #define AXE_ABSFLAT     4
 112
 113
 114         /* data returned by EVIOCGBIT for EV_ABS and EV_KEY */
 115         BYTE                            absbits[(ABS_MAX+7)/8];
 116         BYTE                            keybits[(KEY_MAX+7)/8];
 117 };
 118
 119 /* This GUID is slightly different from the linux joystick one. Take note. */
 120 static GUID DInput_Wine_Joystick_GUID = { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
 121   0x9e573eda,
 122   0x7734,
 123   0x11d2,
 124   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
 125 };
 126
 127 static void fake_current_js_state(JoystickImpl *ji);
 128
 129 #define test_bit(arr,bit) (((BYTE*)arr)[bit>>3]&(1<<(bit&7)))
 130
 131 static int joydev_have(void)
 132 {
 133   int i, fd;
 134   int havejoy = 0;
 135
 136   for (i=0;i<64;i++) {
 137       char      buf[200];
 138       BYTE      absbits[(ABS_MAX+7)/8],keybits[(KEY_MAX+7)/8];
 139
 140       sprintf(buf,EVDEVPREFIX"%d",i);
 141       if (-1!=(fd=open(buf,O_RDONLY))) {
 142           if (-1==ioctl(fd,EVIOCGBIT(EV_ABS,sizeof(absbits)),absbits)) {
 143               perror("EVIOCGBIT EV_ABS");
 144               close(fd);
 145               continue;
 146           }
 147           if (-1==ioctl(fd,EVIOCGBIT(EV_KEY,sizeof(keybits)),keybits)) {
 148               perror("EVIOCGBIT EV_KEY");
 149               close(fd);
 150               continue;
 151           }
 152           /* A true joystick has at least axis X and Y, and at least 1
 153            * button. copied from linux/drivers/input/joydev.c */
 154           if (test_bit(absbits,ABS_X) && test_bit(absbits,ABS_Y) &&
 155               (   test_bit(keybits,BTN_TRIGGER) ||
 156                   test_bit(keybits,BTN_A)       ||
 157                   test_bit(keybits,BTN_1)
 158               )
 159           ) {
 160               FIXME("found a joystick at %s!\n",buf);
 161               havejoy = 1;
 162           }
 163           close(fd);
 164       }
 165       if (havejoy || (errno==ENODEV))
 166           break;
 167   }
 168   return havejoy;
 169 }
 170
 171 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, int version, int id)
 172 {
 173   int havejoy = 0;
 174
 175   if (id != 0)
 176       return FALSE;
 177
 178   if (!((dwDevType == 0) ||
 179         ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 8)) ||
 180         (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 8))))
 181     return FALSE;
 182
 183   if (dwFlags & DIEDFL_FORCEFEEDBACK)
 184     return FALSE;
 185
 186   havejoy = joydev_have();
 187
 188   if (!havejoy)
 189       return FALSE;
 190
 191   TRACE("Enumerating the linuxinput Joystick device\n");
 192
 193   /* Return joystick */
 194   lpddi->guidInstance   = GUID_Joystick;
 195   lpddi->guidProduct    = DInput_Wine_Joystick_GUID;
 196
 197   lpddi->guidFFDriver = GUID_NULL;
 198   if (version >= 8)
 199     lpddi->dwDevType    = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 200   else
 201     lpddi->dwDevType    = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 202
 203   strcpy(lpddi->tszInstanceName, "Joystick");
 204   /* ioctl JSIOCGNAME(len) */
 205   strcpy(lpddi->tszProductName, "Wine Joystick");
 206   return TRUE;
 207 }
 208
 209 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, int version, int id)
 210 {
 211   int havejoy = 0;
 212
 213   if (id != 0)
 214       return FALSE;
 215
 216   if (!((dwDevType == 0) ||
 217         ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 8)) ||
 218         (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 8))))
 219     return FALSE;
 220
 221   if (dwFlags & DIEDFL_FORCEFEEDBACK)
 222     return FALSE;
 223
 224   havejoy = joydev_have();
 225
 226   if (!havejoy)
 227       return FALSE;
 228
 229   TRACE("Enumerating the linuxinput Joystick device\n");
 230
 231   /* Return joystick */
 232   lpddi->guidInstance   = GUID_Joystick;
 233   lpddi->guidProduct    = DInput_Wine_Joystick_GUID;
 234
 235   lpddi->guidFFDriver = GUID_NULL;
 236   if (version >= 8)
 237     lpddi->dwDevType    = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 238   else
 239     lpddi->dwDevType    = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 240
 241   MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, lpddi->tszInstanceName, MAX_PATH);
 242   /* ioctl JSIOCGNAME(len) */
 243   MultiByteToWideChar(CP_ACP, 0, "Wine Joystick", -1, lpddi->tszProductName, MAX_PATH);
 244   return TRUE;
 245 }
 246
 247 static JoystickImpl *alloc_device(REFGUID rguid, LPVOID jvt, IDirectInputImpl *dinput)
 248 {
 249   JoystickImpl* newDevice;
 250   int i;
 251
 252   newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
 253   newDevice->lpVtbl = jvt;
 254   newDevice->ref = 1;
 255   newDevice->joyfd = -1;
 256   newDevice->dinput = dinput;
 257   memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 258   for (i=0;i<ABS_MAX;i++) {
 259     newDevice->wantmin[i] = -32768;
 260     newDevice->wantmax[i] =  32767;
 261     /* TODO:
 262      * direct input defines a default for the deadzone somewhere; but as long
 263      * as in map_axis the code for the dead zone is commented out its no
 264      * problem
 265      */
 266     newDevice->deadz[i]   =  0;
 267   }
 268   fake_current_js_state(newDevice);
 269   return newDevice;
 270 }
 271
 272 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
 273 {
 274   int havejoy = 0;
 275
 276   havejoy = joydev_have();
 277
 278   if (!havejoy)
 279       return DIERR_DEVICENOTREG;
 280
 281   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 282       (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 283     if ((riid == NULL) ||
 284         IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
 285         IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
 286         IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
 287         IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
 288       *pdev = (IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput);
 289       TRACE("Creating a Joystick device (%p)\n", *pdev);
 290       return DI_OK;
 291     } else
 292       return DIERR_NOINTERFACE;
 293   }
 294
 295   return DIERR_DEVICENOTREG;
 296 }
 297
 298
 299 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
 300 {
 301   int havejoy = 0;
 302
 303   havejoy = joydev_have();
 304
 305   if (!havejoy)
 306       return DIERR_DEVICENOTREG;
 307
 308   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 309       (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 310     if ((riid == NULL) ||
 311         IsEqualGUID(&IID_IDirectInputDeviceW,riid) ||
 312         IsEqualGUID(&IID_IDirectInputDevice2W,riid) ||
 313         IsEqualGUID(&IID_IDirectInputDevice7W,riid) ||
 314         IsEqualGUID(&IID_IDirectInputDevice8W,riid)) {
 315       *pdev = (IDirectInputDeviceW*) alloc_device(rguid, &JoystickWvt, dinput);
 316       TRACE("Creating a Joystick device (%p)\n", *pdev);
 317       return DI_OK;
 318     } else
 319       return DIERR_NOINTERFACE;
 320   }
 321
 322   return DIERR_DEVICENOTREG;
 323 }
 324
 325 static dinput_device joydev = {
 326   20,
 327   "Wine Linux-input joystick driver",
 328   joydev_enum_deviceA,
 329   joydev_enum_deviceW,
 330   joydev_create_deviceA,
 331   joydev_create_deviceW
 332 };
 333
 334 DECL_GLOBAL_CONSTRUCTOR(joydev_register) { dinput_register_device(&joydev); }
 335
 336 /******************************************************************************
 337  *      Joystick
 338  */
 339 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
 340 {
 341         JoystickImpl *This = (JoystickImpl *)iface;
 342         ULONG ref;
 343
 344         ref = InterlockedDecrement(&(This->ref));
 345         if (ref)
 346                 return ref;
 347
 348         /* Free the data queue */
 349         if (This->data_queue != NULL)
 350           HeapFree(GetProcessHeap(),0,This->data_queue);
 351
 352         /* Free the DataFormat */
 353         HeapFree(GetProcessHeap(), 0, This->df);
 354
 355         HeapFree(GetProcessHeap(),0,This);
 356         return 0;
 357 }
 358
 359 /******************************************************************************
 360   *   SetDataFormat : the application can choose the format of the data
 361   *   the device driver sends back with GetDeviceState.
 362   */
 363 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
 364         LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
 365 )
 366 {
 367   JoystickImpl *This = (JoystickImpl *)iface;
 368
 369   TRACE("(this=%p,%p)\n",This,df);
 370
 371   _dump_DIDATAFORMAT(df);
 372
 373   /* Store the new data format */
 374   This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
 375   memcpy(This->df, df, df->dwSize);
 376   This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
 377   memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
 378
 379   return 0;
 380 }
 381
 382 /******************************************************************************
 383   *     Acquire : gets exclusive control of the joystick
 384   */
 385 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
 386 {
 387     int         i;
 388     JoystickImpl *This = (JoystickImpl *)iface;
 389     char        buf[200];
 390
 391     TRACE("(this=%p)\n",This);
 392     if (This->joyfd!=-1)
 393         return 0;
 394     for (i=0;i<64;i++) {
 395       sprintf(buf,EVDEVPREFIX"%d",i);
 396       if (-1==(This->joyfd=open(buf,O_RDONLY))) {
 397         if (errno==ENODEV)
 398           return DIERR_NOTFOUND;
 399         perror(buf);
 400         continue;
 401       }
 402       if ((-1!=ioctl(This->joyfd,EVIOCGBIT(EV_ABS,sizeof(This->absbits)),This->absbits)) &&
 403           (-1!=ioctl(This->joyfd,EVIOCGBIT(EV_KEY,sizeof(This->keybits)),This->keybits)) &&
 404           (test_bit(This->absbits,ABS_X) && test_bit(This->absbits,ABS_Y) &&
 405            (test_bit(This->keybits,BTN_TRIGGER)||
 406             test_bit(This->keybits,BTN_A)        ||
 407             test_bit(This->keybits,BTN_1)
 408           )
 409          )
 410       )
 411         break;
 412       close(This->joyfd);
 413       This->joyfd = -1;
 414     }
 415     if (This->joyfd==-1)
 416         return DIERR_NOTFOUND;
 417
 418     for (i=0;i<ABS_MAX;i++) {
 419         if (test_bit(This->absbits,i)) {
 420           if (-1==ioctl(This->joyfd,EVIOCGABS(i),&(This->axes[i])))
 421             continue;
 422           FIXME("axe %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
 423               i,
 424               This->axes[i][AXE_ABS],
 425               This->axes[i][AXE_ABSMIN],
 426               This->axes[i][AXE_ABSMAX],
 427               This->axes[i][AXE_ABSFUZZ],
 428               This->axes[i][AXE_ABSFLAT]
 429           );
 430           This->havemin[i] = This->axes[i][AXE_ABSMIN];
 431           This->havemax[i] = This->axes[i][AXE_ABSMAX];
 432         }
 433     }
 434     MESSAGE("\n");
 435
 436         fake_current_js_state(This);
 437
 438     return 0;
 439 }
 440
 441 /******************************************************************************
 442   *     Unacquire : frees the joystick
 443   */
 444 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
 445 {
 446     JoystickImpl *This = (JoystickImpl *)iface;
 447
 448     TRACE("(this=%p)\n",This);
 449     if (This->joyfd!=-1) {
 450         close(This->joyfd);
 451         This->joyfd = -1;
 452         return DI_OK;
 453     }
 454     else
 455         return DI_NOEFFECT;
 456 }
 457
 458 /*
 459  * This maps the read value (from the input event) to a value in the
 460  * 'wanted' range. It also autodetects the possible range of the axe and
 461  * adapts values accordingly.
 462  */
 463 static int
 464 map_axis(JoystickImpl* This, int axis, int val) {
 465     int xmin = This->axes[axis][AXE_ABSMIN];
 466     int xmax = This->axes[axis][AXE_ABSMAX];
 467     int hmax = This->havemax[axis];
 468     int hmin = This->havemin[axis];
 469     int wmin = This->wantmin[axis];
 470     int wmax = This->wantmax[axis];
 471     int ret;
 472
 473     if (val > hmax) This->havemax[axis] = hmax = val;
 474     if (val < hmin) This->havemin[axis] = hmin = val;
 475
 476     if (xmin == xmax) return val;
 477
 478     /* map the value from the hmin-hmax range into the wmin-wmax range */
 479     ret = (val * (wmax-wmin)) / (hmax-hmin) + wmin;
 480
 481 #if 0
 482     /* deadzone doesn't work comfortably enough right now. needs more testing*/
 483     if ((ret > -deadz/2 ) && (ret < deadz/2)) {
 484         FIXME("%d in deadzone, return mid.\n",val);
 485         return (wmax-wmin)/2+wmin;
 486     }
 487 #endif
 488     return ret;
 489 }
 490
 491 /*
 492  * set the current state of the js device as it would be with the middle
 493  * values on the axes
 494  */
 495 static void fake_current_js_state(JoystickImpl *ji)
 496 {
 497         ji->js.lX  = map_axis(ji, ABS_X,  ji->axes[ABS_X ][AXE_ABS]);
 498         ji->js.lY  = map_axis(ji, ABS_Y,  ji->axes[ABS_Y ][AXE_ABS]);
 499         ji->js.lZ  = map_axis(ji, ABS_Z,  ji->axes[ABS_Z ][AXE_ABS]);
 500         ji->js.lRx = map_axis(ji, ABS_RX, ji->axes[ABS_RX][AXE_ABS]);
 501         ji->js.lRy = map_axis(ji, ABS_RY, ji->axes[ABS_RY][AXE_ABS]);
 502         ji->js.lRz = map_axis(ji, ABS_RZ, ji->axes[ABS_RZ][AXE_ABS]);
 503 }
 504
 505 static void joy_polldev(JoystickImpl *This) {
 506     struct timeval tv;
 507     fd_set      readfds;
 508     struct      input_event ie;
 509
 510     if (This->joyfd==-1)
 511         return;
 512
 513     while (1) {
 514         memset(&tv,0,sizeof(tv));
 515         FD_ZERO(&readfds);
 516         FD_SET(This->joyfd,&readfds);
 517
 518         if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
 519             return;
 520
 521         /* we have one event, so we can read */
 522         if (sizeof(ie)!=read(This->joyfd,&ie,sizeof(ie)))
 523             return;
 524
 525         TRACE("input_event: type %d, code %d, value %d\n",ie.type,ie.code,ie.value);
 526         switch (ie.type) {
 527         case EV_KEY:    /* button */
 528             switch (ie.code) {
 529             case BTN_TRIGGER:   /* normal flight stick */
 530             case BTN_A:         /* gamepad */
 531             case BTN_1:         /* generic */
 532                 This->js.rgbButtons[0] = ie.value?0x80:0x00;
 533                 GEN_EVENT(DIJOFS_BUTTON(0),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 534                 break;
 535             case BTN_THUMB:
 536             case BTN_B:
 537             case BTN_2:
 538                 This->js.rgbButtons[1] = ie.value?0x80:0x00;
 539                 GEN_EVENT(DIJOFS_BUTTON(1),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 540                 break;
 541             case BTN_THUMB2:
 542             case BTN_C:
 543             case BTN_3:
 544                 This->js.rgbButtons[2] = ie.value?0x80:0x00;
 545                 GEN_EVENT(DIJOFS_BUTTON(2),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 546                 break;
 547             case BTN_TOP:
 548             case BTN_X:
 549             case BTN_4:
 550                 This->js.rgbButtons[3] = ie.value?0x80:0x00;
 551                 GEN_EVENT(DIJOFS_BUTTON(3),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 552                 break;
 553             case BTN_TOP2:
 554             case BTN_Y:
 555             case BTN_5:
 556                 This->js.rgbButtons[4] = ie.value?0x80:0x00;
 557                 GEN_EVENT(DIJOFS_BUTTON(4),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 558                 break;
 559             case BTN_PINKIE:
 560             case BTN_Z:
 561             case BTN_6:
 562                 This->js.rgbButtons[5] = ie.value?0x80:0x00;
 563                 GEN_EVENT(DIJOFS_BUTTON(5),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 564                 break;
 565             case BTN_BASE:
 566             case BTN_TL:
 567             case BTN_7:
 568                 This->js.rgbButtons[6] = ie.value?0x80:0x00;
 569                 GEN_EVENT(DIJOFS_BUTTON(6),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 570                 break;
 571             case BTN_BASE2:
 572             case BTN_TR:
 573             case BTN_8:
 574                 This->js.rgbButtons[7] = ie.value?0x80:0x00;
 575                 GEN_EVENT(DIJOFS_BUTTON(7),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 576                 break;
 577             case BTN_BASE3:
 578             case BTN_TL2:
 579             case BTN_9:
 580                 This->js.rgbButtons[8] = ie.value?0x80:0x00;
 581                 GEN_EVENT(DIJOFS_BUTTON(8),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 582                 break;
 583             case BTN_BASE4:
 584             case BTN_TR2:
 585                 This->js.rgbButtons[9] = ie.value?0x80:0x00;
 586                 GEN_EVENT(DIJOFS_BUTTON(9),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 587                 break;
 588             case BTN_BASE5:
 589             case BTN_SELECT:
 590                 This->js.rgbButtons[10] = ie.value?0x80:0x00;
 591                 GEN_EVENT(DIJOFS_BUTTON(10),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 592                 break;
 593             default:
 594                 FIXME("unhandled joystick button %x, value %d\n",ie.code,ie.value);
 595                 break;
 596             }
 597             break;
 598         case EV_ABS:
 599             switch (ie.code) {
 600             case ABS_X:
 601                 This->js.lX = map_axis(This,ABS_X,ie.value);
 602                 GEN_EVENT(DIJOFS_X,This->js.lX,ie.time.tv_usec,(This->dinput->evsequence)++);
 603                 break;
 604             case ABS_Y:
 605                 This->js.lY = map_axis(This,ABS_Y,ie.value);
 606                 GEN_EVENT(DIJOFS_Y,This->js.lY,ie.time.tv_usec,(This->dinput->evsequence)++);
 607                 break;
 608             case ABS_Z:
 609                 This->js.lZ = map_axis(This,ABS_Z,ie.value);
 610                 GEN_EVENT(DIJOFS_Z,This->js.lZ,ie.time.tv_usec,(This->dinput->evsequence)++);
 611                 break;
 612             case ABS_RX:
 613                 This->js.lRx = map_axis(This,ABS_RX,ie.value);
 614                 GEN_EVENT(DIJOFS_RX,This->js.lRx,ie.time.tv_usec,(This->dinput->evsequence)++);
 615                 break;
 616             case ABS_RY:
 617                 This->js.lRy = map_axis(This,ABS_RY,ie.value);
 618                 GEN_EVENT(DIJOFS_RY,This->js.lRy,ie.time.tv_usec,(This->dinput->evsequence)++);
 619                 break;
 620             case ABS_RZ:
 621                 This->js.lRz = map_axis(This,ABS_RZ,ie.value);
 622                 GEN_EVENT(DIJOFS_RZ,This->js.lRz,ie.time.tv_usec,(This->dinput->evsequence)++);
 623                 break;
 624             default:
 625                 FIXME("unhandled joystick axe event (code %d, value %d)\n",ie.code,ie.value);
 626                 break;
 627             }
 628             break;
 629         default:
 630             FIXME("joystick cannot handle type %d event (code %d)\n",ie.type,ie.code);
 631             break;
 632         }
 633     }
 634 }
 635
 636 /******************************************************************************
 637   *     GetDeviceState : returns the "state" of the joystick.
 638   *
 639   */
 640 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
 641         LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
 642 ) {
 643     JoystickImpl *This = (JoystickImpl *)iface;
 644
 645     joy_polldev(This);
 646
 647     TRACE("(this=%p,0x%08lx,%p)\n",This,len,ptr);
 648     if ((len != sizeof(DIJOYSTATE)) && (len != sizeof(DIJOYSTATE2))) {
 649         FIXME("len %ld is not sizeof(DIJOYSTATE) or DIJOYSTATE2, unsupported format.\n",len);
 650         return E_FAIL;
 651     }
 652     memcpy(ptr,&(This->js),len);
 653     This->queue_head = 0;
 654     This->queue_tail = 0;
 655     return 0;
 656 }
 657
 658 /******************************************************************************
 659   *     GetDeviceData : gets buffered input data.
 660   */
 661 static HRESULT WINAPI JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE8A iface,
 662                                               DWORD dodsize,
 663                                               LPDIDEVICEOBJECTDATA dod,
 664                                               LPDWORD entries,
 665                                               DWORD flags
 666 ) {
 667   JoystickImpl *This = (JoystickImpl *)iface;
 668
 669   FIXME("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx),STUB!\n",This,dodsize,*entries,flags);
 670
 671   joy_polldev(This);
 672   if (flags & DIGDD_PEEK)
 673     FIXME("DIGDD_PEEK\n");
 674
 675   if (dod == NULL) {
 676   } else {
 677   }
 678   return 0;
 679 }
 680
 681 /******************************************************************************
 682   *     SetProperty : change input device properties
 683   */
 684 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
 685                                             REFGUID rguid,
 686                                             LPCDIPROPHEADER ph)
 687 {
 688   JoystickImpl *This = (JoystickImpl *)iface;
 689
 690   FIXME("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
 691   FIXME("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph->dwSize, ph->dwHeaderSize,ph->dwObj,ph->dwHow);
 692
 693   if (!HIWORD(rguid)) {
 694     switch ((DWORD)rguid) {
 695     case (DWORD) DIPROP_BUFFERSIZE: {
 696       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 697
 698       FIXME("buffersize = %ld\n",pd->dwData);
 699       break;
 700     }
 701     case (DWORD)DIPROP_RANGE: {
 702       LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
 703
 704       FIXME("proprange(%ld,%ld)\n",pr->lMin,pr->lMax);
 705       switch (ph->dwObj) {
 706       case 0:   /* X */
 707       case 4:   /* Y */
 708       case 8:   /* Z */
 709       case 12:  /* Rx */
 710       case 16:  /* Ry */
 711       case 20:  /* Rz */
 712           This->wantmin[ph->dwObj/4] = pr->lMin;
 713           This->wantmax[ph->dwObj/4] = pr->lMax;
 714           break;
 715       default:
 716           FIXME("setting proprange %ld - %ld for dwObj %ld\n",pr->lMin,pr->lMax,ph->dwObj);
 717       }
 718       break;
 719     }
 720     case (DWORD)DIPROP_DEADZONE: {
 721       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 722
 723       FIXME("setting deadzone(%ld)\n",pd->dwData);
 724       This->deadz[ph->dwObj/4] = pd->dwData;
 725       break;
 726     }
 727     default:
 728       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
 729       break;
 730     }
 731   }
 732   fake_current_js_state(This);
 733   return 0;
 734 }
 735
 736 /******************************************************************************
 737   *     SetEventNotification : specifies event to be sent on state change
 738   */
 739 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
 740         LPDIRECTINPUTDEVICE8A iface, HANDLE hnd
 741 ) {
 742     JoystickImpl *This = (JoystickImpl *)iface;
 743
 744     TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
 745     This->hEvent = hnd;
 746     return DI_OK;
 747 }
 748
 749 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
 750         LPDIRECTINPUTDEVICE8A iface,
 751         LPDIDEVCAPS lpDIDevCaps)
 752 {
 753     JoystickImpl *This = (JoystickImpl *)iface;
 754     int         xfd = This->joyfd;
 755     int         i,axes,buttons;
 756     int         wasacquired = 1;
 757
 758     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
 759     if (xfd==-1) {
 760         /* yes, games assume we return something, even if unacquired */
 761         JoystickAImpl_Acquire(iface);
 762         xfd = This->joyfd;
 763         wasacquired = 0;
 764     }
 765     lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
 766     if (This->dinput->version >= 8)
 767         lpDIDevCaps->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 768     else
 769         lpDIDevCaps->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 770
 771     axes=0;
 772     for (i=0;i<ABS_MAX;i++) if (test_bit(This->absbits,i)) axes++;
 773     buttons=0;
 774     for (i=0;i<KEY_MAX;i++) if (test_bit(This->keybits,i)) buttons++;
 775
 776     lpDIDevCaps->dwAxes = axes;
 777     lpDIDevCaps->dwButtons = buttons;
 778
 779     if (!wasacquired)
 780         JoystickAImpl_Unacquire(iface);
 781
 782     return DI_OK;
 783 }
 784
 785 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface) {
 786     JoystickImpl *This = (JoystickImpl *)iface;
 787     TRACE("(),stub!\n");
 788
 789     joy_polldev(This);
 790     return DI_OK;
 791 }
 792
 793 /******************************************************************************
 794   *     EnumObjects : enumerate the different buttons and axis...
 795   */
 796 static HRESULT WINAPI JoystickAImpl_EnumObjects(
 797         LPDIRECTINPUTDEVICE8A iface,
 798         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
 799         LPVOID lpvRef,
 800         DWORD dwFlags)
 801 {
 802   JoystickImpl *This = (JoystickImpl *)iface;
 803   DIDEVICEOBJECTINSTANCEA ddoi;
 804   int xfd = This->joyfd;
 805
 806
 807   TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
 808   if (TRACE_ON(dinput)) {
 809     TRACE("  - flags = ");
 810     _dump_EnumObjects_flags(dwFlags);
 811     TRACE("\n");
 812   }
 813
 814   if (xfd == -1) return DIERR_NOTACQUIRED;
 815
 816   /* Only the fields till dwFFMaxForce are relevant */
 817   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
 818
 819   /* For the joystick, do as is done in the GetCapabilities function */
 820   /* FIXME: needs more items */
 821   if ((dwFlags == DIDFT_ALL) ||
 822       (dwFlags & DIDFT_AXIS)) {
 823     BYTE i;
 824
 825     for (i = 0; i < ABS_MAX; i++) {
 826       if (!test_bit(This->absbits,i)) continue;
 827
 828       switch (i) {
 829       case ABS_X:
 830         ddoi.guidType = GUID_XAxis;
 831         ddoi.dwOfs = DIJOFS_X;
 832         break;
 833       case ABS_Y:
 834         ddoi.guidType = GUID_YAxis;
 835         ddoi.dwOfs = DIJOFS_Y;
 836         break;
 837       case ABS_Z:
 838         ddoi.guidType = GUID_ZAxis;
 839         ddoi.dwOfs = DIJOFS_Z;
 840         break;
 841       case ABS_RX:
 842         ddoi.guidType = GUID_RxAxis;
 843         ddoi.dwOfs = DIJOFS_RX;
 844         break;
 845       case ABS_RY:
 846         ddoi.guidType = GUID_RyAxis;
 847         ddoi.dwOfs = DIJOFS_RY;
 848         break;
 849       case ABS_RZ:
 850         ddoi.guidType = GUID_RzAxis;
 851         ddoi.dwOfs = DIJOFS_RZ;
 852         break;
 853       case ABS_THROTTLE:
 854         ddoi.guidType = GUID_Slider;
 855         ddoi.dwOfs = DIJOFS_SLIDER(0);
 856         break;
 857       default:
 858         FIXME("unhandled abs axis %d, ignoring!\n",i);
 859       }
 860       ddoi.dwType = DIDFT_MAKEINSTANCE((1<<i) << WINE_JOYSTICK_AXIS_BASE) | DIDFT_ABSAXIS;
 861       sprintf(ddoi.tszName, "%d-Axis", i);
 862       _dump_OBJECTINSTANCEA(&ddoi);
 863       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
 864           return DI_OK;
 865     }
 866   }
 867
 868   if ((dwFlags == DIDFT_ALL) ||
 869       (dwFlags & DIDFT_BUTTON)) {
 870     int i;
 871
 872     /*The DInput SDK says that GUID_Button is only for mouse buttons but well*/
 873
 874     ddoi.guidType = GUID_Button;
 875
 876     for (i = 0; i < KEY_MAX; i++) {
 877       if (!test_bit(This->keybits,i)) continue;
 878
 879       switch (i) {
 880       case BTN_TRIGGER:
 881       case BTN_A:
 882       case BTN_1:
 883           ddoi.dwOfs = DIJOFS_BUTTON(0);
 884           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 0) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 885           break;
 886         case BTN_THUMB:
 887         case BTN_B:
 888         case BTN_2:
 889           ddoi.dwOfs = DIJOFS_BUTTON(1);
 890           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 1) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 891           break;
 892         case BTN_THUMB2:
 893         case BTN_C:
 894         case BTN_3:
 895           ddoi.dwOfs = DIJOFS_BUTTON(2);
 896           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 2) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 897           break;
 898         case BTN_TOP:
 899         case BTN_X:
 900         case BTN_4:
 901           ddoi.dwOfs = DIJOFS_BUTTON(3);
 902           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 3) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 903           break;
 904         case BTN_TOP2:
 905         case BTN_Y:
 906         case BTN_5:
 907           ddoi.dwOfs = DIJOFS_BUTTON(4);
 908           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 4) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 909           break;
 910         case BTN_PINKIE:
 911         case BTN_Z:
 912         case BTN_6:
 913           ddoi.dwOfs = DIJOFS_BUTTON(5);
 914           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 5) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 915           break;
 916         case BTN_BASE:
 917         case BTN_TL:
 918         case BTN_7:
 919           ddoi.dwOfs = DIJOFS_BUTTON(6);
 920           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 6) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 921           break;
 922         case BTN_BASE2:
 923         case BTN_TR:
 924         case BTN_8:
 925           ddoi.dwOfs = DIJOFS_BUTTON(7);
 926           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 7) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 927           break;
 928         case BTN_BASE3:
 929         case BTN_TL2:
 930         case BTN_9:
 931           ddoi.dwOfs = DIJOFS_BUTTON(8);
 932           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 8) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 933           break;
 934         case BTN_BASE4:
 935         case BTN_TR2:
 936           ddoi.dwOfs = DIJOFS_BUTTON(9);
 937           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 9) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 938           break;
 939         case BTN_BASE5:
 940         case BTN_SELECT:
 941           ddoi.dwOfs = DIJOFS_BUTTON(10);
 942           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 10) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 943           break;
 944       }
 945       sprintf(ddoi.tszName, "%d-Button", i);
 946       _dump_OBJECTINSTANCEA(&ddoi);
 947       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
 948           return DI_OK;
 949     }
 950   }
 951
 952   if (xfd!=This->joyfd)
 953     close(xfd);
 954
 955   return DI_OK;
 956 }
 957
 958 static HRESULT WINAPI JoystickWImpl_EnumObjects(LPDIRECTINPUTDEVICE8W iface,
 959                                                 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
 960                                                 LPVOID lpvRef,
 961                                                 DWORD dwFlags)
 962 {
 963   JoystickImpl *This = (JoystickImpl *)iface;
 964
 965   device_enumobjects_AtoWcb_data data;
 966
 967   data.lpCallBack = lpCallback;
 968   data.lpvRef = lpvRef;
 969
 970   return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A) This, (LPDIENUMDEVICEOBJECTSCALLBACKA) DIEnumDevicesCallbackAtoW, (LPVOID) &data, dwFlags);
 971 }
 972
 973 /******************************************************************************
 974   *     GetProperty : get input device properties
 975   */
 976 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
 977                                                 REFGUID rguid,
 978                                                 LPDIPROPHEADER pdiph)
 979 {
 980   JoystickImpl *This = (JoystickImpl *)iface;
 981
 982   TRACE("(this=%p,%s,%p): stub!\n",
 983         iface, debugstr_guid(rguid), pdiph);
 984
 985   if (TRACE_ON(dinput))
 986     _dump_DIPROPHEADER(pdiph);
 987
 988   if (!HIWORD(rguid)) {
 989     switch ((DWORD)rguid) {
 990     case (DWORD) DIPROP_BUFFERSIZE: {
 991       LPDIPROPDWORD     pd = (LPDIPROPDWORD)pdiph;
 992
 993       TRACE(" return buffersize = %d\n",This->queue_len);
 994       pd->dwData = This->queue_len;
 995       break;
 996     }
 997
 998     case (DWORD) DIPROP_RANGE: {
 999       /* LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph; */
1000       if ((pdiph->dwHow == DIPH_BYID) &&
1001           (pdiph->dwObj & DIDFT_ABSAXIS)) {
1002         /* The app is querying the current range of the axis : return the lMin and lMax values */
1003         FIXME("unimplemented axis range query.\n");
1004       }
1005
1006       break;
1007     }
1008
1009     default:
1010       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1011       break;
1012     }
1013   }
1014
1015
1016   return DI_OK;
1017 }
1018
1019 static IDirectInputDevice8AVtbl JoystickAvt =
1020 {
1021         IDirectInputDevice2AImpl_QueryInterface,
1022         IDirectInputDevice2AImpl_AddRef,
1023         JoystickAImpl_Release,
1024         JoystickAImpl_GetCapabilities,
1025         JoystickAImpl_EnumObjects,
1026         JoystickAImpl_GetProperty,
1027         JoystickAImpl_SetProperty,
1028         JoystickAImpl_Acquire,
1029         JoystickAImpl_Unacquire,
1030         JoystickAImpl_GetDeviceState,
1031         JoystickAImpl_GetDeviceData,
1032         JoystickAImpl_SetDataFormat,
1033         JoystickAImpl_SetEventNotification,
1034         IDirectInputDevice2AImpl_SetCooperativeLevel,
1035         IDirectInputDevice2AImpl_GetObjectInfo,
1036         IDirectInputDevice2AImpl_GetDeviceInfo,
1037         IDirectInputDevice2AImpl_RunControlPanel,
1038         IDirectInputDevice2AImpl_Initialize,
1039         IDirectInputDevice2AImpl_CreateEffect,
1040         IDirectInputDevice2AImpl_EnumEffects,
1041         IDirectInputDevice2AImpl_GetEffectInfo,
1042         IDirectInputDevice2AImpl_GetForceFeedbackState,
1043         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1044         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1045         IDirectInputDevice2AImpl_Escape,
1046         JoystickAImpl_Poll,
1047         IDirectInputDevice2AImpl_SendDeviceData,
1048         IDirectInputDevice7AImpl_EnumEffectsInFile,
1049         IDirectInputDevice7AImpl_WriteEffectToFile,
1050         IDirectInputDevice8AImpl_BuildActionMap,
1051         IDirectInputDevice8AImpl_SetActionMap,
1052         IDirectInputDevice8AImpl_GetImageInfo
1053 };
1054
1055 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1056 # define XCAST(fun)     (typeof(JoystickWvt.fun))
1057 #else
1058 # define XCAST(fun)     (void*)
1059 #endif
1060
1061 static IDirectInputDevice8WVtbl JoystickWvt =
1062 {
1063         IDirectInputDevice2WImpl_QueryInterface,
1064         XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1065         XCAST(Release)JoystickAImpl_Release,
1066         XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1067         JoystickWImpl_EnumObjects,
1068         XCAST(GetProperty)JoystickAImpl_GetProperty,
1069         XCAST(SetProperty)JoystickAImpl_SetProperty,
1070         XCAST(Acquire)JoystickAImpl_Acquire,
1071         XCAST(Unacquire)JoystickAImpl_Unacquire,
1072         XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1073         XCAST(GetDeviceData)JoystickAImpl_GetDeviceData,
1074         XCAST(SetDataFormat)JoystickAImpl_SetDataFormat,
1075         XCAST(SetEventNotification)JoystickAImpl_SetEventNotification,
1076         XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1077         IDirectInputDevice2WImpl_GetObjectInfo,
1078         IDirectInputDevice2WImpl_GetDeviceInfo,
1079         XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1080         XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1081         XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
1082         IDirectInputDevice2WImpl_EnumEffects,
1083         IDirectInputDevice2WImpl_GetEffectInfo,
1084         XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
1085         XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1086         XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1087         XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1088         XCAST(Poll)JoystickAImpl_Poll,
1089         XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1090         IDirectInputDevice7WImpl_EnumEffectsInFile,
1091         IDirectInputDevice7WImpl_WriteEffectToFile,
1092         IDirectInputDevice8WImpl_BuildActionMap,
1093         IDirectInputDevice8WImpl_SetActionMap,
1094         IDirectInputDevice8WImpl_GetImageInfo
1095 };
1096 #undef XCAST
1097
1098 #endif  /* HAVE_LINUX_INPUT_H */
1099
1100 #endif