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

   1 /*              DirectInput Joystick device
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  *
   6  */
   7
   8 #include "config.h"
   9
  10 #ifdef HAVE_LINUX_22_JOYSTICK_API
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <time.h>
  15 #include <unistd.h>
  16 #include <sys/time.h>
  17 #include <sys/fcntl.h>
  18 #include <sys/ioctl.h>
  19 #include <errno.h>
  20 #ifdef HAVE_SYS_ERRNO_H
  21 # include <sys/errno.h>
  22 #endif
  23 #ifdef HAVE_LINUX_JOYSTICK_H
  24 # include <linux/joystick.h>
  25 #endif
  26 #define JOYDEV  "/dev/js0"
  27
  28 #include "debugtools.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "windef.h"
  32 #include "dinput.h"
  33
  34 #include "dinput_private.h"
  35 #include "device_private.h"
  36
  37 DEFAULT_DEBUG_CHANNEL(dinput);
  38
  39 /* Wine joystick driver object instances */
  40 #define WINE_JOYSTICK_AXIS_BASE   0
  41 #define WINE_JOYSTICK_BUTTON_BASE 8
  42
  43 typedef struct JoystickAImpl JoystickAImpl;
  44 static ICOM_VTABLE(IDirectInputDevice2A) JoystickAvt;
  45 static ICOM_VTABLE(IDirectInputDevice7A) Joystick7Avt;
  46 struct JoystickAImpl
  47 {
  48         /* IDirectInputDevice2AImpl */
  49         ICOM_VFIELD(IDirectInputDevice2A);
  50         DWORD                           ref;
  51         GUID                            guid;
  52
  53         /* The 'parent' DInput */
  54         IDirectInputAImpl *dinput;
  55
  56         /* joystick private */
  57         int                             joyfd;
  58         LPDIDATAFORMAT                  df;
  59         HANDLE                          hEvent;
  60         LONG                            lMin,lMax,deadzone;
  61         LPDIDEVICEOBJECTDATA            data_queue;
  62         int                             queue_head, queue_tail, queue_len;
  63         DIJOYSTATE                      js;
  64 };
  65
  66 static GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
  67   0x9e573ed9,
  68   0x7734,
  69   0x11d2,
  70   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
  71 };
  72
  73 static BOOL joydev_enum_device(DWORD dwDevType, DWORD dwFlags, LPCDIDEVICEINSTANCEA lpddi)
  74 {
  75   if ((dwDevType==0) || (GET_DIDEVICE_TYPE(dwDevType)==DIDEVTYPE_JOYSTICK)) {
  76     /* check whether we have a joystick */
  77     if ((access(JOYDEV,O_RDONLY) != -1) || (errno!=ENODEV && errno!=ENOENT)) {
  78       TRACE("Enumerating the Joystick device\n");
  79
  80       /* Return joystick */
  81       lpddi->guidInstance       = GUID_Joystick;
  82       lpddi->guidProduct        = DInput_Wine_Joystick_GUID;
  83       /* we only support traditional joysticks for now */
  84       lpddi->dwDevType  = DIDEVTYPE_JOYSTICK |
  85                          (DIDEVTYPEJOYSTICK_TRADITIONAL<<8);
  86       strcpy(lpddi->tszInstanceName,    "Joystick");
  87       /* ioctl JSIOCGNAME(len) */
  88       strcpy(lpddi->tszProductName,     "Wine Joystick");
  89
  90       return TRUE;
  91     }
  92   }
  93
  94   return FALSE;
  95 }
  96
  97 static JoystickAImpl *alloc_device(REFGUID rguid, ICOM_VTABLE(IDirectInputDevice2A) *jvt, IDirectInputAImpl *dinput)
  98 {
  99   JoystickAImpl* newDevice;
 100
 101   newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickAImpl));
 102   newDevice->ref                = 1;
 103   ICOM_VTBL(newDevice)    = jvt;
 104   newDevice->joyfd      = -1;
 105   newDevice->lMin = -32768;
 106   newDevice->lMax = +32767;
 107   newDevice->dinput = dinput;
 108   memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 109
 110   return newDevice;
 111 }
 112
 113 static HRESULT joydev_create_device(IDirectInputAImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
 114 {
 115   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 116       (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 117     if ((riid == NULL) || (IsEqualGUID(&IID_IDirectInputDevice2A,riid)) || (IsEqualGUID(&IID_IDirectInputDevice2A,riid))) {
 118       *pdev=(IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput);
 119
 120       TRACE("Creating a Joystick device (%p)\n", *pdev);
 121       return DI_OK;
 122     } else if (IsEqualGUID(&IID_IDirectInputDevice7A,riid)) {
 123       *pdev=(IDirectInputDeviceA*) alloc_device(rguid, (ICOM_VTABLE(IDirectInputDevice2A) *) &Joystick7Avt, dinput);
 124
 125       TRACE("Creating a Joystick DInput7A device (%p)\n", *pdev);
 126       return DI_OK;
 127     } else
 128       return DIERR_NOINTERFACE;
 129   }
 130
 131   return DIERR_DEVICENOTREG;
 132 }
 133
 134 static dinput_device joydev = {
 135   10,
 136   joydev_enum_device,
 137   joydev_create_device
 138 };
 139
 140 DECL_GLOBAL_CONSTRUCTOR(joydev_register) { dinput_register_device(&joydev); }
 141
 142 /******************************************************************************
 143  *      Joystick
 144  */
 145 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE2A iface)
 146 {
 147         ICOM_THIS(JoystickAImpl,iface);
 148
 149         This->ref--;
 150         if (This->ref)
 151                 return This->ref;
 152
 153         /* Free the data queue */
 154         if (This->data_queue != NULL)
 155           HeapFree(GetProcessHeap(),0,This->data_queue);
 156
 157         /* Free the DataFormat */
 158         HeapFree(GetProcessHeap(), 0, This->df);
 159
 160         HeapFree(GetProcessHeap(),0,This);
 161         return 0;
 162 }
 163
 164 /******************************************************************************
 165   *   SetDataFormat : the application can choose the format of the data
 166   *   the device driver sends back with GetDeviceState.
 167   */
 168 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
 169         LPDIRECTINPUTDEVICE2A iface,LPCDIDATAFORMAT df
 170 )
 171 {
 172   ICOM_THIS(JoystickAImpl,iface);
 173   int i;
 174
 175   TRACE("(this=%p,%p)\n",This,df);
 176
 177   TRACE("(df.dwSize=%ld)\n",df->dwSize);
 178   TRACE("(df.dwObjsize=%ld)\n",df->dwObjSize);
 179   TRACE("(df.dwFlags=0x%08lx)\n",df->dwFlags);
 180   TRACE("(df.dwDataSize=%ld)\n",df->dwDataSize);
 181   TRACE("(df.dwNumObjs=%ld)\n",df->dwNumObjs);
 182
 183   for (i=0;i<df->dwNumObjs;i++) {
 184     TRACE("df.rgodf[%d].guid %s (%p)\n",i,debugstr_guid(df->rgodf[i].pguid), df->rgodf[i].pguid);
 185     TRACE("df.rgodf[%d].dwOfs %ld\n",i,df->rgodf[i].dwOfs);
 186     TRACE("dwType 0x%02x,dwInstance %d\n",DIDFT_GETTYPE(df->rgodf[i].dwType),DIDFT_GETINSTANCE(df->rgodf[i].dwType));
 187     TRACE("df.rgodf[%d].dwFlags 0x%08lx\n",i,df->rgodf[i].dwFlags);
 188   }
 189
 190   /* Store the new data format */
 191   This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
 192   memcpy(This->df, df, df->dwSize);
 193   This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
 194   memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
 195
 196   return 0;
 197 }
 198
 199 /******************************************************************************
 200   *     Acquire : gets exclusive control of the joystick
 201   */
 202 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE2A iface)
 203 {
 204     ICOM_THIS(JoystickAImpl,iface);
 205
 206     TRACE("(this=%p)\n",This);
 207     if (This->joyfd!=-1)
 208         return 0;
 209     This->joyfd=open(JOYDEV,O_RDONLY);
 210     if (This->joyfd==-1)
 211         return DIERR_NOTFOUND;
 212     return 0;
 213 }
 214
 215 /******************************************************************************
 216   *     Unacquire : frees the joystick
 217   */
 218 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE2A iface)
 219 {
 220     ICOM_THIS(JoystickAImpl,iface);
 221
 222     TRACE("(this=%p)\n",This);
 223     if (This->joyfd!=-1) {
 224         close(This->joyfd);
 225         This->joyfd = -1;
 226     }
 227     return DI_OK;
 228 }
 229
 230 #define map_axis(val) ((val+32768)*(This->lMax-This->lMin)/65536+This->lMin)
 231
 232 static void joy_polldev(JoystickAImpl *This) {
 233     struct timeval tv;
 234     fd_set      readfds;
 235     struct      js_event jse;
 236
 237     if (This->joyfd==-1)
 238         return;
 239     while (1) {
 240         memset(&tv,0,sizeof(tv));
 241         FD_ZERO(&readfds);FD_SET(This->joyfd,&readfds);
 242         if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
 243             return;
 244         /* we have one event, so we can read */
 245         if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
 246             return;
 247         }
 248         TRACE("js_event: type 0x%x, number %d, value %d\n",jse.type,jse.number,jse.value);
 249         if (jse.type & JS_EVENT_BUTTON) {
 250             GEN_EVENT(DIJOFS_BUTTON(jse.number),jse.value?0x80:0x00,jse.time,(This->dinput->evsequence)++);
 251             This->js.rgbButtons[jse.number] = jse.value?0x80:0x00;
 252         }
 253         if (jse.type & JS_EVENT_AXIS) {
 254             switch (jse.number) {
 255             case 0:
 256                 GEN_EVENT(jse.number*4,jse.value,jse.time,(This->dinput->evsequence)++);
 257                 This->js.lX = map_axis(jse.value);
 258                 break;
 259             case 1:
 260                 GEN_EVENT(jse.number*4,jse.value,jse.time,(This->dinput->evsequence)++);
 261                 This->js.lY = map_axis(jse.value);
 262                 break;
 263             case 2:
 264                 GEN_EVENT(jse.number*4,jse.value,jse.time,(This->dinput->evsequence)++);
 265                 This->js.lZ = map_axis(jse.value);
 266                 break;
 267             default:
 268                 FIXME("more then 3 axes (%d) not handled!\n",jse.number);
 269                 break;
 270             }
 271         }
 272     }
 273 }
 274
 275 /******************************************************************************
 276   *     GetDeviceState : returns the "state" of the joystick.
 277   *
 278   */
 279 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
 280         LPDIRECTINPUTDEVICE2A iface,DWORD len,LPVOID ptr
 281 ) {
 282     ICOM_THIS(JoystickAImpl,iface);
 283
 284     joy_polldev(This);
 285     TRACE("(this=%p,0x%08lx,%p)\n",This,len,ptr);
 286     if (len != sizeof(DIJOYSTATE)) {
 287         FIXME("len %ld is not sizeof(DIJOYSTATE), unsupported format.\n",len);
 288     }
 289     memcpy(ptr,&(This->js),len);
 290     This->queue_head = 0;
 291     This->queue_tail = 0;
 292     return 0;
 293 }
 294
 295 /******************************************************************************
 296   *     GetDeviceData : gets buffered input data.
 297   */
 298 static HRESULT WINAPI JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE2A iface,
 299                                               DWORD dodsize,
 300                                               LPDIDEVICEOBJECTDATA dod,
 301                                               LPDWORD entries,
 302                                               DWORD flags
 303 ) {
 304   ICOM_THIS(JoystickAImpl,iface);
 305
 306   FIXME("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx),STUB!\n",This,dodsize,*entries,flags);
 307
 308   joy_polldev(This);
 309   if (flags & DIGDD_PEEK)
 310     FIXME("DIGDD_PEEK\n");
 311
 312   if (dod == NULL) {
 313   } else {
 314   }
 315   return 0;
 316 }
 317
 318 /******************************************************************************
 319   *     SetProperty : change input device properties
 320   */
 321 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE2A iface,
 322                                             REFGUID rguid,
 323                                             LPCDIPROPHEADER ph)
 324 {
 325   ICOM_THIS(JoystickAImpl,iface);
 326
 327   FIXME("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
 328   FIXME("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph->dwSize, ph->dwHeaderSize,ph->dwObj,ph->dwHow);
 329
 330   if (!HIWORD(rguid)) {
 331     switch ((DWORD)rguid) {
 332     case (DWORD) DIPROP_BUFFERSIZE: {
 333       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 334
 335       FIXME("buffersize = %ld\n",pd->dwData);
 336       break;
 337     }
 338     case (DWORD)DIPROP_RANGE: {
 339       LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
 340
 341       FIXME("proprange(%ld,%ld)\n",pr->lMin,pr->lMax);
 342       This->lMin = pr->lMin;
 343       This->lMax = pr->lMax;
 344       break;
 345     }
 346     case (DWORD)DIPROP_DEADZONE: {
 347       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 348
 349       FIXME("deadzone(%ld)\n",pd->dwData);
 350       This->deadzone = pd->dwData;
 351       break;
 352     }
 353     default:
 354       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
 355       break;
 356     }
 357   }
 358   return 0;
 359 }
 360
 361 /******************************************************************************
 362   *     SetEventNotification : specifies event to be sent on state change
 363   */
 364 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
 365         LPDIRECTINPUTDEVICE2A iface, HANDLE hnd
 366 ) {
 367     ICOM_THIS(JoystickAImpl,iface);
 368
 369     TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
 370     This->hEvent = hnd;
 371     return DI_OK;
 372 }
 373
 374 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
 375         LPDIRECTINPUTDEVICE2A iface,
 376         LPDIDEVCAPS lpDIDevCaps)
 377 {
 378     ICOM_THIS(JoystickAImpl,iface);
 379     BYTE        axes,buttons;
 380     int         xfd = This->joyfd;
 381
 382     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
 383     if (xfd==-1)
 384         xfd = open(JOYDEV,O_RDONLY);
 385     lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
 386     lpDIDevCaps->dwDevType      = DIDEVTYPE_JOYSTICK;
 387 #ifdef JSIOCGAXES
 388     if (-1==ioctl(xfd,JSIOCGAXES,&axes))
 389         axes = 2;
 390     lpDIDevCaps->dwAxes = axes;
 391 #endif
 392 #ifdef JSIOCGBUTTONS
 393     if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
 394         buttons = 2;
 395     lpDIDevCaps->dwButtons = buttons;
 396 #endif
 397     if (xfd!=This->joyfd)
 398         close(xfd);
 399     return DI_OK;
 400 }
 401 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE2A iface) {
 402     ICOM_THIS(JoystickAImpl,iface);
 403     TRACE("(),stub!\n");
 404
 405     joy_polldev(This);
 406     return DI_OK;
 407 }
 408
 409 /******************************************************************************
 410   *     EnumObjects : enumerate the different buttons and axis...
 411   */
 412 static HRESULT WINAPI JoystickAImpl_EnumObjects(
 413         LPDIRECTINPUTDEVICE2A iface,
 414         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
 415         LPVOID lpvRef,
 416         DWORD dwFlags)
 417 {
 418   ICOM_THIS(JoystickAImpl,iface);
 419   DIDEVICEOBJECTINSTANCEA ddoi;
 420   int xfd = This->joyfd;
 421
 422   TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
 423   if (TRACE_ON(dinput)) {
 424     DPRINTF("  - flags = ");
 425     _dump_EnumObjects_flags(dwFlags);
 426     DPRINTF("\n");
 427   }
 428
 429   /* Only the fields till dwFFMaxForce are relevant */
 430   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
 431
 432   /* For the joystick, do as is done in the GetCapabilities function */
 433   if ((dwFlags == DIDFT_ALL) ||
 434       (dwFlags & DIDFT_AXIS)) {
 435     BYTE axes, i;
 436
 437 #ifdef JSIOCGAXES
 438     if (-1==ioctl(xfd,JSIOCGAXES,&axes))
 439       axes = 2;
 440 #endif
 441
 442     for (i = 0; i < axes; i++) {
 443       switch (i) {
 444       case 0:
 445         ddoi.guidType = GUID_XAxis;
 446         ddoi.dwOfs = DIJOFS_X;
 447         break;
 448       case 1:
 449         ddoi.guidType = GUID_YAxis;
 450         ddoi.dwOfs = DIJOFS_Y;
 451         break;
 452       case 2:
 453         ddoi.guidType = GUID_ZAxis;
 454         ddoi.dwOfs = DIJOFS_Z;
 455         break;
 456       default:
 457         ddoi.guidType = GUID_Unknown;
 458         ddoi.dwOfs = DIJOFS_Z + (i - 2) * sizeof(LONG);
 459       }
 460       ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << i) << WINE_JOYSTICK_AXIS_BASE) | DIDFT_ABSAXIS;
 461       sprintf(ddoi.tszName, "%d-Axis", i);
 462       _dump_OBJECTINSTANCEA(&ddoi);
 463       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
 464     }
 465   }
 466
 467   if ((dwFlags == DIDFT_ALL) ||
 468       (dwFlags & DIDFT_BUTTON)) {
 469     BYTE buttons, i;
 470
 471 #ifdef JSIOCGBUTTONS
 472     if (-1==ioctl(xfd,JSIOCGAXES,&buttons))
 473       buttons = 2;
 474 #endif
 475
 476     /* The DInput SDK says that GUID_Button is only for mouse buttons but well... */
 477     ddoi.guidType = GUID_Button;
 478
 479     for (i = 0; i < buttons; i++) {
 480       ddoi.dwOfs = DIJOFS_BUTTON(i);
 481       ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << i) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 482       sprintf(ddoi.tszName, "%d-Button", i);
 483       _dump_OBJECTINSTANCEA(&ddoi);
 484       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
 485     }
 486   }
 487
 488   if (xfd!=This->joyfd)
 489     close(xfd);
 490
 491   return DI_OK;
 492 }
 493
 494 /******************************************************************************
 495   *     GetProperty : get input device properties
 496   */
 497 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE2A iface,
 498                                                 REFGUID rguid,
 499                                                 LPDIPROPHEADER pdiph)
 500 {
 501   ICOM_THIS(JoystickAImpl,iface);
 502
 503   TRACE("(this=%p,%s,%p): stub!\n",
 504         iface, debugstr_guid(rguid), pdiph);
 505
 506   if (TRACE_ON(dinput))
 507     _dump_DIPROPHEADER(pdiph);
 508
 509   if (!HIWORD(rguid)) {
 510     switch ((DWORD)rguid) {
 511     case (DWORD) DIPROP_BUFFERSIZE: {
 512       LPDIPROPDWORD     pd = (LPDIPROPDWORD)pdiph;
 513
 514       TRACE(" return buffersize = %d\n",This->queue_len);
 515       pd->dwData = This->queue_len;
 516       break;
 517     }
 518
 519     case (DWORD) DIPROP_RANGE: {
 520       LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
 521
 522       if ((pdiph->dwHow == DIPH_BYID) &&
 523           (pdiph->dwObj & DIDFT_ABSAXIS)) {
 524         /* The app is querying the current range of the axis : return the lMin and lMax values */
 525         pr->lMin = This->lMin;
 526         pr->lMax = This->lMax;
 527       }
 528
 529       break;
 530     }
 531
 532     default:
 533       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
 534       break;
 535     }
 536   }
 537
 538
 539   return DI_OK;
 540 }
 541
 542 static ICOM_VTABLE(IDirectInputDevice2A) JoystickAvt =
 543 {
 544         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 545         IDirectInputDevice2AImpl_QueryInterface,
 546         IDirectInputDevice2AImpl_AddRef,
 547         JoystickAImpl_Release,
 548         JoystickAImpl_GetCapabilities,
 549         JoystickAImpl_EnumObjects,
 550         JoystickAImpl_GetProperty,
 551         JoystickAImpl_SetProperty,
 552         JoystickAImpl_Acquire,
 553         JoystickAImpl_Unacquire,
 554         JoystickAImpl_GetDeviceState,
 555         JoystickAImpl_GetDeviceData,
 556         JoystickAImpl_SetDataFormat,
 557         JoystickAImpl_SetEventNotification,
 558         IDirectInputDevice2AImpl_SetCooperativeLevel,
 559         IDirectInputDevice2AImpl_GetObjectInfo,
 560         IDirectInputDevice2AImpl_GetDeviceInfo,
 561         IDirectInputDevice2AImpl_RunControlPanel,
 562         IDirectInputDevice2AImpl_Initialize,
 563         IDirectInputDevice2AImpl_CreateEffect,
 564         IDirectInputDevice2AImpl_EnumEffects,
 565         IDirectInputDevice2AImpl_GetEffectInfo,
 566         IDirectInputDevice2AImpl_GetForceFeedbackState,
 567         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
 568         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
 569         IDirectInputDevice2AImpl_Escape,
 570         JoystickAImpl_Poll,
 571         IDirectInputDevice2AImpl_SendDeviceData,
 572 };
 573
 574 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
 575 # define XCAST(fun)     (typeof(Joystick7Avt.fun))
 576 #else
 577 # define XCAST(fun)     (void*)
 578 #endif
 579
 580 static ICOM_VTABLE(IDirectInputDevice7A) Joystick7Avt =
 581 {
 582         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 583         XCAST(QueryInterface)IDirectInputDevice2AImpl_QueryInterface,
 584         XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
 585         XCAST(Release)JoystickAImpl_Release,
 586         XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
 587         XCAST(EnumObjects)JoystickAImpl_EnumObjects,
 588         XCAST(GetProperty)JoystickAImpl_GetProperty,
 589         XCAST(SetProperty)JoystickAImpl_SetProperty,
 590         XCAST(Acquire)JoystickAImpl_Acquire,
 591         XCAST(Unacquire)JoystickAImpl_Unacquire,
 592         XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
 593         XCAST(GetDeviceData)JoystickAImpl_GetDeviceData,
 594         XCAST(SetDataFormat)JoystickAImpl_SetDataFormat,
 595         XCAST(SetEventNotification)JoystickAImpl_SetEventNotification,
 596         XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
 597         XCAST(GetObjectInfo)IDirectInputDevice2AImpl_GetObjectInfo,
 598         XCAST(GetDeviceInfo)IDirectInputDevice2AImpl_GetDeviceInfo,
 599         XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
 600         XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
 601         XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
 602         XCAST(EnumEffects)IDirectInputDevice2AImpl_EnumEffects,
 603         XCAST(GetEffectInfo)IDirectInputDevice2AImpl_GetEffectInfo,
 604         XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
 605         XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
 606         XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
 607         XCAST(Escape)IDirectInputDevice2AImpl_Escape,
 608         XCAST(Poll)JoystickAImpl_Poll,
 609         XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
 610         IDirectInputDevice7AImpl_EnumEffectsInFile,
 611         IDirectInputDevice7AImpl_WriteEffectToFile
 612 };
 613
 614 #undef XCAST
 615
 616 #endif  /* HAVE_LINUX_22_JOYSTICK_API */