dlls/dinput/joystick_linux.c

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