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  * Copyright 2005 Daniel Remenak
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <assert.h>
  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_INPUT_H
  46 # include <linux/input.h>
  47 # if defined(EVIOCGBIT) && defined(EV_ABS) && defined(BTN_PINKIE)
  48 #  define HAVE_CORRECT_LINUXINPUT_H
  49 # endif
  50 #endif
  51
  52 #include "wine/debug.h"
  53 #include "wine/unicode.h"
  54 #include "windef.h"
  55 #include "winbase.h"
  56 #include "winerror.h"
  57 #include "dinput.h"
  58
  59 #include "dinput_private.h"
  60 #include "device_private.h"
  61
  62 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  63
  64 #ifdef HAVE_CORRECT_LINUXINPUT_H
  65
  66 #define EVDEVPREFIX     "/dev/input/event"
  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 EffectListItem EffectListItem;
  73 struct EffectListItem
  74 {
  75         LPDIRECTINPUTEFFECT ref;
  76         struct EffectListItem* next;
  77 };
  78
  79 /* implemented in effect_linuxinput.c */
  80 HRESULT linuxinput_create_effect(int fd, REFGUID rguid, LPDIRECTINPUTEFFECT* peff);
  81 HRESULT linuxinput_get_info_A(int fd, REFGUID rguid, LPDIEFFECTINFOA info);
  82 HRESULT linuxinput_get_info_W(int fd, REFGUID rguid, LPDIEFFECTINFOW info);
  83
  84 typedef struct JoystickImpl JoystickImpl;
  85 static const IDirectInputDevice8AVtbl JoystickAvt;
  86 static const IDirectInputDevice8WVtbl JoystickWvt;
  87 struct JoystickImpl
  88 {
  89         const void                     *lpVtbl;
  90         LONG                            ref;
  91         GUID                            guid;
  92
  93
  94         /* The 'parent' DInput */
  95         IDirectInputImpl               *dinput;
  96
  97         /* joystick private */
  98         /* what range and deadzone the game wants */
  99         LONG                            wantmin[ABS_MAX];
 100         LONG                            wantmax[ABS_MAX];
 101         LONG                            deadz[ABS_MAX];
 102
 103         /* autodetecting ranges per axe by following movement */
 104         LONG                            havemax[ABS_MAX];
 105         LONG                            havemin[ABS_MAX];
 106
 107         int                             joyfd;
 108
 109         LPDIDATAFORMAT                  df;
 110         HANDLE                          hEvent;
 111         LPDIDEVICEOBJECTDATA            data_queue;
 112         int                             queue_head, queue_tail, queue_len;
 113         BOOL                            overflow;
 114         DIJOYSTATE2                     js;
 115
 116         /* Force feedback variables */
 117         BOOL                            has_ff;
 118         int                             num_effects;
 119         EffectListItem*                 top_effect;
 120         int                             ff_state;
 121
 122         /* data returned by the EVIOCGABS() ioctl */
 123         int                             axes[ABS_MAX+1][5];
 124
 125 #define AXE_ABS         0
 126 #define AXE_ABSMIN      1
 127 #define AXE_ABSMAX      2
 128 #define AXE_ABSFUZZ     3
 129 #define AXE_ABSFLAT     4
 130
 131
 132         /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
 133         BYTE                            evbits[(EV_MAX+7)/8];
 134         BYTE                            absbits[(ABS_MAX+7)/8];
 135         BYTE                            keybits[(KEY_MAX+7)/8];
 136         BYTE                            ffbits[(FF_MAX+7)/8];
 137 };
 138
 139 /* This GUID is slightly different from the linux joystick one. Take note. */
 140 static GUID DInput_Wine_Joystick_GUID = { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
 141   0x9e573eda,
 142   0x7734,
 143   0x11d2,
 144   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
 145 };
 146
 147 static void fake_current_js_state(JoystickImpl *ji);
 148
 149 #define test_bit(arr,bit) (((BYTE*)arr)[bit>>3]&(1<<(bit&7)))
 150
 151 static int joydev_have(BOOL require_ff)
 152 {
 153   int i, fd, flags, num_effects;
 154   int havejoy = 0;
 155
 156   for (i=0;i<64;i++) {
 157       char      buf[200];
 158       BYTE      absbits[(ABS_MAX+7)/8],keybits[(KEY_MAX+7)/8];
 159       BYTE      evbits[(EV_MAX+7)/8],ffbits[(FF_MAX+7)/8];
 160
 161       sprintf(buf,EVDEVPREFIX"%d",i);
 162
 163       if (require_ff)
 164           flags = O_RDWR;
 165       else
 166           flags = O_RDONLY;
 167
 168       if (-1!=(fd=open(buf,flags))) {
 169           if (-1==ioctl(fd,EVIOCGBIT(EV_ABS,sizeof(absbits)),absbits)) {
 170               perror("EVIOCGBIT EV_ABS");
 171               close(fd);
 172               continue;
 173           }
 174           if (-1==ioctl(fd,EVIOCGBIT(EV_KEY,sizeof(keybits)),keybits)) {
 175               perror("EVIOCGBIT EV_KEY");
 176               close(fd);
 177               continue;
 178           }
 179
 180           /* test for force feedback if it's required */
 181           if (require_ff) {
 182               if ((-1==ioctl(fd,EVIOCGBIT(0,sizeof(evbits)),evbits))) {
 183                   perror("EVIOCGBIT 0");
 184                   close(fd);
 185                   continue;
 186               }
 187               if (   (!test_bit(evbits,EV_FF))
 188                   || (-1==ioctl(fd,EVIOCGBIT(EV_FF,sizeof(ffbits)),ffbits))
 189                   || (-1==ioctl(fd,EVIOCGEFFECTS,&num_effects))
 190                   || (num_effects <= 0)) {
 191                   close(fd);
 192                   continue;
 193               }
 194           }
 195
 196           /* A true joystick has at least axis X and Y, and at least 1
 197            * button. copied from linux/drivers/input/joydev.c */
 198           if (test_bit(absbits,ABS_X) && test_bit(absbits,ABS_Y) &&
 199               (   test_bit(keybits,BTN_TRIGGER) ||
 200                   test_bit(keybits,BTN_A)       ||
 201                   test_bit(keybits,BTN_1)
 202               )
 203           ) {
 204               FIXME("found a joystick at %s!\n",buf);
 205               havejoy = 1;
 206           }
 207           close(fd);
 208       }
 209       if (havejoy || (errno==ENODEV))
 210           break;
 211   }
 212   return havejoy;
 213 }
 214
 215 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
 216 {
 217   int havejoy = 0;
 218
 219   if (id != 0)
 220       return FALSE;
 221
 222   if (!((dwDevType == 0) ||
 223         ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 0x0800)) ||
 224         (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
 225     return FALSE;
 226
 227 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
 228   if (dwFlags & DIEDFL_FORCEFEEDBACK)
 229     return FALSE;
 230 #endif
 231
 232   havejoy = joydev_have(dwFlags & DIEDFL_FORCEFEEDBACK);
 233
 234   if (!havejoy)
 235       return FALSE;
 236
 237   TRACE("Enumerating the linuxinput Joystick device\n");
 238
 239   /* Return joystick */
 240   lpddi->guidInstance   = GUID_Joystick;
 241   lpddi->guidProduct    = DInput_Wine_Joystick_GUID;
 242
 243   lpddi->guidFFDriver = GUID_NULL;
 244   if (version >= 0x0800)
 245     lpddi->dwDevType    = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 246   else
 247     lpddi->dwDevType    = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 248
 249   strcpy(lpddi->tszInstanceName, "Joystick");
 250   /* ioctl JSIOCGNAME(len) */
 251   strcpy(lpddi->tszProductName, "Wine Joystick");
 252   return TRUE;
 253 }
 254
 255 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
 256 {
 257   int havejoy = 0;
 258
 259   if (id != 0)
 260       return FALSE;
 261
 262   if (!((dwDevType == 0) ||
 263         ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 0x0800)) ||
 264         (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
 265     return FALSE;
 266
 267 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
 268   if (dwFlags & DIEDFL_FORCEFEEDBACK)
 269     return FALSE;
 270 #endif
 271
 272   havejoy = joydev_have(dwFlags & DIEDFL_FORCEFEEDBACK);
 273
 274   if (!havejoy)
 275       return FALSE;
 276
 277   TRACE("Enumerating the linuxinput Joystick device\n");
 278
 279   /* Return joystick */
 280   lpddi->guidInstance   = GUID_Joystick;
 281   lpddi->guidProduct    = DInput_Wine_Joystick_GUID;
 282
 283   lpddi->guidFFDriver = GUID_NULL;
 284   if (version >= 0x0800)
 285     lpddi->dwDevType    = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 286   else
 287     lpddi->dwDevType    = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 288
 289   MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, lpddi->tszInstanceName, MAX_PATH);
 290   /* ioctl JSIOCGNAME(len) */
 291   MultiByteToWideChar(CP_ACP, 0, "Wine Joystick", -1, lpddi->tszProductName, MAX_PATH);
 292   return TRUE;
 293 }
 294
 295 static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput)
 296 {
 297   JoystickImpl* newDevice;
 298   int i;
 299
 300   newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
 301   newDevice->lpVtbl = jvt;
 302   newDevice->ref = 1;
 303   newDevice->joyfd = -1;
 304   newDevice->dinput = dinput;
 305 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
 306   newDevice->ff_state = FF_STATUS_STOPPED;
 307 #endif
 308   memcpy(&(newDevice->guid),rguid,sizeof(*rguid));
 309   for (i=0;i<ABS_MAX;i++) {
 310     newDevice->wantmin[i] = -32768;
 311     newDevice->wantmax[i] =  32767;
 312     /* TODO:
 313      * direct input defines a default for the deadzone somewhere; but as long
 314      * as in map_axis the code for the dead zone is commented out its no
 315      * problem
 316      */
 317     newDevice->deadz[i]   =  0;
 318   }
 319   fake_current_js_state(newDevice);
 320   return newDevice;
 321 }
 322
 323 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
 324 {
 325   int havejoy = 0;
 326
 327   havejoy = joydev_have(FALSE);
 328
 329   if (!havejoy)
 330       return DIERR_DEVICENOTREG;
 331
 332   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 333       (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 334     if ((riid == NULL) ||
 335         IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
 336         IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
 337         IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
 338         IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
 339       *pdev = (IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput);
 340       TRACE("Creating a Joystick device (%p)\n", *pdev);
 341       return DI_OK;
 342     } else
 343       return DIERR_NOINTERFACE;
 344   }
 345
 346   return DIERR_DEVICENOTREG;
 347 }
 348
 349
 350 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
 351 {
 352   int havejoy = 0;
 353
 354   havejoy = joydev_have(FALSE);
 355
 356   if (!havejoy)
 357       return DIERR_DEVICENOTREG;
 358
 359   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 360       (IsEqualGUID(&DInput_Wine_Joystick_GUID,rguid))) {
 361     if ((riid == NULL) ||
 362         IsEqualGUID(&IID_IDirectInputDeviceW,riid) ||
 363         IsEqualGUID(&IID_IDirectInputDevice2W,riid) ||
 364         IsEqualGUID(&IID_IDirectInputDevice7W,riid) ||
 365         IsEqualGUID(&IID_IDirectInputDevice8W,riid)) {
 366       *pdev = (IDirectInputDeviceW*) alloc_device(rguid, &JoystickWvt, dinput);
 367       TRACE("Creating a Joystick device (%p)\n", *pdev);
 368       return DI_OK;
 369     } else
 370       return DIERR_NOINTERFACE;
 371   }
 372
 373   return DIERR_DEVICENOTREG;
 374 }
 375
 376 const struct dinput_device joystick_linuxinput_device = {
 377   "Wine Linux-input joystick driver",
 378   joydev_enum_deviceA,
 379   joydev_enum_deviceW,
 380   joydev_create_deviceA,
 381   joydev_create_deviceW
 382 };
 383
 384 /******************************************************************************
 385  *      Joystick
 386  */
 387 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
 388 {
 389         JoystickImpl *This = (JoystickImpl *)iface;
 390         ULONG ref;
 391
 392         ref = InterlockedDecrement(&(This->ref));
 393         if (ref)
 394                 return ref;
 395
 396         /* Reset the FF state, free all effects, etc */
 397         iface->lpVtbl->SendForceFeedbackCommand(iface, DISFFC_RESET);
 398
 399         /* Free the data queue */
 400         HeapFree(GetProcessHeap(),0,This->data_queue);
 401
 402         /* Free the DataFormat */
 403         HeapFree(GetProcessHeap(), 0, This->df);
 404
 405         HeapFree(GetProcessHeap(),0,This);
 406         return 0;
 407 }
 408
 409 /******************************************************************************
 410   *   SetDataFormat : the application can choose the format of the data
 411   *   the device driver sends back with GetDeviceState.
 412   */
 413 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
 414         LPDIRECTINPUTDEVICE8A iface,LPCDIDATAFORMAT df
 415 )
 416 {
 417   JoystickImpl *This = (JoystickImpl *)iface;
 418
 419   TRACE("(this=%p,%p)\n",This,df);
 420
 421   _dump_DIDATAFORMAT(df);
 422
 423   /* Store the new data format */
 424   This->df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
 425   memcpy(This->df, df, df->dwSize);
 426   This->df->rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
 427   memcpy(This->df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
 428
 429   return 0;
 430 }
 431
 432 /******************************************************************************
 433   *     Acquire : gets exclusive control of the joystick
 434   */
 435 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
 436 {
 437     int         i;
 438     JoystickImpl *This = (JoystickImpl *)iface;
 439     char        buf[200];
 440     BOOL        readonly = TRUE;
 441
 442     TRACE("(this=%p)\n",This);
 443     if (This->joyfd!=-1)
 444         return 0;
 445     for (i=0;i<64;i++) {
 446       sprintf(buf,EVDEVPREFIX"%d",i);
 447       if (-1==(This->joyfd=open(buf,O_RDWR))) {
 448         if (-1==(This->joyfd=open(buf,O_RDONLY))) {
 449           /* Couldn't open the device at all */
 450           if (errno==ENODEV)
 451             return DIERR_NOTFOUND;
 452           perror(buf);
 453           continue;
 454         }
 455         else {
 456           /* Couldn't open in r/w but opened in read-only. */
 457           WARN("Could not open %s in read-write mode.  Force feedback will be disabled.\n",buf);
 458         }
 459       }
 460       else {
 461         /* Opened device in read-write */
 462         readonly = FALSE;
 463       }
 464       if ((-1!=ioctl(This->joyfd,EVIOCGBIT(0,sizeof(This->evbits)),This->evbits)) &&
 465           (-1!=ioctl(This->joyfd,EVIOCGBIT(EV_ABS,sizeof(This->absbits)),This->absbits)) &&
 466           (-1!=ioctl(This->joyfd,EVIOCGBIT(EV_KEY,sizeof(This->keybits)),This->keybits)) &&
 467           (test_bit(This->absbits,ABS_X) && test_bit(This->absbits,ABS_Y) &&
 468            (test_bit(This->keybits,BTN_TRIGGER)||
 469             test_bit(This->keybits,BTN_A)        ||
 470             test_bit(This->keybits,BTN_1)
 471           )
 472          )
 473       )
 474         break;
 475       close(This->joyfd);
 476       This->joyfd = -1;
 477     }
 478     if (This->joyfd==-1)
 479         return DIERR_NOTFOUND;
 480
 481     This->has_ff = FALSE;
 482     This->num_effects = 0;
 483
 484 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
 485     if (!readonly && test_bit(This->evbits, EV_FF)) {
 486         if (-1!=ioctl(This->joyfd,EVIOCGBIT(EV_FF,sizeof(This->ffbits)),This->ffbits)) {
 487             if (-1!=ioctl(This->joyfd,EVIOCGEFFECTS,&This->num_effects)
 488                 && This->num_effects > 0) {
 489                 This->has_ff = TRUE;
 490                 TRACE("Joystick seems to be capable of force feedback.\n");
 491             }
 492             else {
 493                 TRACE("Joystick does not support any effects, disabling force feedback.\n");
 494             }
 495         }
 496         else {
 497             TRACE("Could not get EV_FF bits; disabling force feedback.\n");
 498         }
 499     }
 500     else {
 501         TRACE("Force feedback disabled (device is readonly or joystick incapable).\n");
 502     }
 503 #endif
 504
 505     for (i=0;i<ABS_MAX;i++) {
 506         if (test_bit(This->absbits,i)) {
 507           if (-1==ioctl(This->joyfd,EVIOCGABS(i),&(This->axes[i])))
 508             continue;
 509           FIXME("axe %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
 510               i,
 511               This->axes[i][AXE_ABS],
 512               This->axes[i][AXE_ABSMIN],
 513               This->axes[i][AXE_ABSMAX],
 514               This->axes[i][AXE_ABSFUZZ],
 515               This->axes[i][AXE_ABSFLAT]
 516           );
 517           This->havemin[i] = This->axes[i][AXE_ABSMIN];
 518           This->havemax[i] = This->axes[i][AXE_ABSMAX];
 519         }
 520     }
 521     MESSAGE("\n");
 522
 523         fake_current_js_state(This);
 524
 525     return 0;
 526 }
 527
 528 /******************************************************************************
 529   *     Unacquire : frees the joystick
 530   */
 531 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
 532 {
 533     JoystickImpl *This = (JoystickImpl *)iface;
 534
 535     TRACE("(this=%p)\n",This);
 536     if (This->joyfd!=-1) {
 537         close(This->joyfd);
 538         This->joyfd = -1;
 539         return DI_OK;
 540     }
 541     else
 542         return DI_NOEFFECT;
 543 }
 544
 545 /*
 546  * This maps the read value (from the input event) to a value in the
 547  * 'wanted' range. It also autodetects the possible range of the axe and
 548  * adapts values accordingly.
 549  */
 550 static int
 551 map_axis(JoystickImpl* This, int axis, int val) {
 552     int xmin = This->axes[axis][AXE_ABSMIN];
 553     int xmax = This->axes[axis][AXE_ABSMAX];
 554     int hmax = This->havemax[axis];
 555     int hmin = This->havemin[axis];
 556     int wmin = This->wantmin[axis];
 557     int wmax = This->wantmax[axis];
 558     int ret;
 559
 560     if (val > hmax) This->havemax[axis] = hmax = val;
 561     if (val < hmin) This->havemin[axis] = hmin = val;
 562
 563     if (xmin == xmax) return val;
 564
 565     /* map the value from the hmin-hmax range into the wmin-wmax range */
 566     ret = ((val-hmin) * (wmax-wmin)) / (hmax-hmin) + wmin;
 567
 568     TRACE("xmin=%d xmax=%d hmin=%d hmax=%d wmin=%d wmax=%d val=%d ret=%d\n", xmin, xmax, hmin, hmax, wmin, wmax, val, ret);
 569
 570 #if 0
 571     /* deadzone doesn't work comfortably enough right now. needs more testing*/
 572     if ((ret > -deadz/2 ) && (ret < deadz/2)) {
 573         FIXME("%d in deadzone, return mid.\n",val);
 574         return (wmax-wmin)/2+wmin;
 575     }
 576 #endif
 577     return ret;
 578 }
 579
 580 /*
 581  * set the current state of the js device as it would be with the middle
 582  * values on the axes
 583  */
 584 static void fake_current_js_state(JoystickImpl *ji)
 585 {
 586         ji->js.lX  = map_axis(ji, ABS_X,  ji->axes[ABS_X ][AXE_ABS]);
 587         ji->js.lY  = map_axis(ji, ABS_Y,  ji->axes[ABS_Y ][AXE_ABS]);
 588         ji->js.lZ  = map_axis(ji, ABS_Z,  ji->axes[ABS_Z ][AXE_ABS]);
 589         ji->js.lRx = map_axis(ji, ABS_RX, ji->axes[ABS_RX][AXE_ABS]);
 590         ji->js.lRy = map_axis(ji, ABS_RY, ji->axes[ABS_RY][AXE_ABS]);
 591         ji->js.lRz = map_axis(ji, ABS_RZ, ji->axes[ABS_RZ][AXE_ABS]);
 592         ji->js.rglSlider[0] = map_axis(ji, ABS_THROTTLE, ji->axes[ABS_THROTTLE][AXE_ABS]);
 593         ji->js.rglSlider[1] = map_axis(ji, ABS_RUDDER,   ji->axes[ABS_RUDDER  ][AXE_ABS]);
 594 }
 595
 596 static void joy_polldev(JoystickImpl *This) {
 597     struct timeval tv;
 598     fd_set      readfds;
 599     struct      input_event ie;
 600
 601     if (This->joyfd==-1)
 602         return;
 603
 604     while (1) {
 605         memset(&tv,0,sizeof(tv));
 606         FD_ZERO(&readfds);
 607         FD_SET(This->joyfd,&readfds);
 608
 609         if (1>select(This->joyfd+1,&readfds,NULL,NULL,&tv))
 610             return;
 611
 612         /* we have one event, so we can read */
 613         if (sizeof(ie)!=read(This->joyfd,&ie,sizeof(ie)))
 614             return;
 615
 616         TRACE("input_event: type %d, code %d, value %d\n",ie.type,ie.code,ie.value);
 617         switch (ie.type) {
 618         case EV_KEY:    /* button */
 619             switch (ie.code) {
 620             case BTN_TRIGGER:   /* normal flight stick */
 621             case BTN_A:         /* gamepad */
 622             case BTN_1:         /* generic */
 623                 This->js.rgbButtons[0] = ie.value?0x80:0x00;
 624                 GEN_EVENT(DIJOFS_BUTTON(0),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 625                 break;
 626             case BTN_THUMB:
 627             case BTN_B:
 628             case BTN_2:
 629                 This->js.rgbButtons[1] = ie.value?0x80:0x00;
 630                 GEN_EVENT(DIJOFS_BUTTON(1),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 631                 break;
 632             case BTN_THUMB2:
 633             case BTN_C:
 634             case BTN_3:
 635                 This->js.rgbButtons[2] = ie.value?0x80:0x00;
 636                 GEN_EVENT(DIJOFS_BUTTON(2),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 637                 break;
 638             case BTN_TOP:
 639             case BTN_X:
 640             case BTN_4:
 641                 This->js.rgbButtons[3] = ie.value?0x80:0x00;
 642                 GEN_EVENT(DIJOFS_BUTTON(3),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 643                 break;
 644             case BTN_TOP2:
 645             case BTN_Y:
 646             case BTN_5:
 647                 This->js.rgbButtons[4] = ie.value?0x80:0x00;
 648                 GEN_EVENT(DIJOFS_BUTTON(4),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 649                 break;
 650             case BTN_PINKIE:
 651             case BTN_Z:
 652             case BTN_6:
 653                 This->js.rgbButtons[5] = ie.value?0x80:0x00;
 654                 GEN_EVENT(DIJOFS_BUTTON(5),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 655                 break;
 656             case BTN_BASE:
 657             case BTN_TL:
 658             case BTN_7:
 659                 This->js.rgbButtons[6] = ie.value?0x80:0x00;
 660                 GEN_EVENT(DIJOFS_BUTTON(6),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 661                 break;
 662             case BTN_BASE2:
 663             case BTN_TR:
 664             case BTN_8:
 665                 This->js.rgbButtons[7] = ie.value?0x80:0x00;
 666                 GEN_EVENT(DIJOFS_BUTTON(7),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 667                 break;
 668             case BTN_BASE3:
 669             case BTN_TL2:
 670             case BTN_9:
 671                 This->js.rgbButtons[8] = ie.value?0x80:0x00;
 672                 GEN_EVENT(DIJOFS_BUTTON(8),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 673                 break;
 674             case BTN_BASE4:
 675             case BTN_TR2:
 676                 This->js.rgbButtons[9] = ie.value?0x80:0x00;
 677                 GEN_EVENT(DIJOFS_BUTTON(9),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 678                 break;
 679             case BTN_BASE5:
 680             case BTN_SELECT:
 681                 This->js.rgbButtons[10] = ie.value?0x80:0x00;
 682                 GEN_EVENT(DIJOFS_BUTTON(10),ie.value?0x80:0x0,ie.time.tv_usec,(This->dinput->evsequence)++);
 683                 break;
 684             default:
 685                 FIXME("unhandled joystick button %x, value %d\n",ie.code,ie.value);
 686                 break;
 687             }
 688             break;
 689         case EV_ABS:
 690             switch (ie.code) {
 691             case ABS_X:
 692                 This->js.lX = map_axis(This,ABS_X,ie.value);
 693                 GEN_EVENT(DIJOFS_X,This->js.lX,ie.time.tv_usec,(This->dinput->evsequence)++);
 694                 break;
 695             case ABS_Y:
 696                 This->js.lY = map_axis(This,ABS_Y,ie.value);
 697                 GEN_EVENT(DIJOFS_Y,This->js.lY,ie.time.tv_usec,(This->dinput->evsequence)++);
 698                 break;
 699             case ABS_Z:
 700                 This->js.lZ = map_axis(This,ABS_Z,ie.value);
 701                 GEN_EVENT(DIJOFS_Z,This->js.lZ,ie.time.tv_usec,(This->dinput->evsequence)++);
 702                 break;
 703             case ABS_RX:
 704                 This->js.lRx = map_axis(This,ABS_RX,ie.value);
 705                 GEN_EVENT(DIJOFS_RX,This->js.lRx,ie.time.tv_usec,(This->dinput->evsequence)++);
 706                 break;
 707             case ABS_RY:
 708                 This->js.lRy = map_axis(This,ABS_RY,ie.value);
 709                 GEN_EVENT(DIJOFS_RY,This->js.lRy,ie.time.tv_usec,(This->dinput->evsequence)++);
 710                 break;
 711             case ABS_RZ:
 712                 This->js.lRz = map_axis(This,ABS_RZ,ie.value);
 713                 GEN_EVENT(DIJOFS_RZ,This->js.lRz,ie.time.tv_usec,(This->dinput->evsequence)++);
 714                 break;
 715             case ABS_THROTTLE:
 716                 This->js.rglSlider[0] = map_axis(This,ABS_THROTTLE,ie.value);
 717                 GEN_EVENT(DIJOFS_SLIDER(0),This->js.rglSlider[0],ie.time.tv_usec,(This->dinput->evsequence)++);
 718                 break;
 719             case ABS_RUDDER:
 720                 This->js.rglSlider[1] = map_axis(This,ABS_RUDDER,ie.value);
 721                 GEN_EVENT(DIJOFS_SLIDER(1),This->js.rglSlider[1],ie.time.tv_usec,(This->dinput->evsequence)++);
 722                 break;
 723             default:
 724                 FIXME("unhandled joystick axe event (code %d, value %d)\n",ie.code,ie.value);
 725                 break;
 726             }
 727             break;
 728 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
 729         case EV_FF_STATUS:
 730             This->ff_state = ie.value;
 731             break;
 732 #endif
 733         default:
 734             FIXME("joystick cannot handle type %d event (code %d)\n",ie.type,ie.code);
 735             break;
 736         }
 737     }
 738 }
 739
 740 /******************************************************************************
 741   *     GetDeviceState : returns the "state" of the joystick.
 742   *
 743   */
 744 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
 745         LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
 746 ) {
 747     JoystickImpl *This = (JoystickImpl *)iface;
 748
 749     joy_polldev(This);
 750
 751     TRACE("(this=%p,0x%08lx,%p)\n",This,len,ptr);
 752     if ((len != sizeof(DIJOYSTATE)) && (len != sizeof(DIJOYSTATE2))) {
 753         FIXME("len %ld is not sizeof(DIJOYSTATE) or DIJOYSTATE2, unsupported format.\n",len);
 754         return E_FAIL;
 755     }
 756     memcpy(ptr,&(This->js),len);
 757     This->queue_head = 0;
 758     This->queue_tail = 0;
 759     return 0;
 760 }
 761
 762 /******************************************************************************
 763   *     GetDeviceData : gets buffered input data.
 764   */
 765 static HRESULT WINAPI JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE8A iface,
 766                                               DWORD dodsize,
 767                                               LPDIDEVICEOBJECTDATA dod,
 768                                               LPDWORD entries,
 769                                               DWORD flags
 770 ) {
 771   JoystickImpl *This = (JoystickImpl *)iface;
 772
 773   FIXME("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx),STUB!\n",This,dodsize,*entries,flags);
 774
 775   joy_polldev(This);
 776   if (flags & DIGDD_PEEK)
 777     FIXME("DIGDD_PEEK\n");
 778
 779   if (dod == NULL) {
 780   } else {
 781   }
 782   return 0;
 783 }
 784
 785 /******************************************************************************
 786   *     SetProperty : change input device properties
 787   */
 788 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
 789                                             REFGUID rguid,
 790                                             LPCDIPROPHEADER ph)
 791 {
 792   JoystickImpl *This = (JoystickImpl *)iface;
 793
 794   FIXME("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
 795   FIXME("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph->dwSize, ph->dwHeaderSize,ph->dwObj,ph->dwHow);
 796
 797   if (!HIWORD(rguid)) {
 798     switch ((DWORD)rguid) {
 799     case (DWORD) DIPROP_BUFFERSIZE: {
 800       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 801
 802       FIXME("buffersize = %ld\n",pd->dwData);
 803       break;
 804     }
 805     case (DWORD)DIPROP_RANGE: {
 806       LPCDIPROPRANGE    pr = (LPCDIPROPRANGE)ph;
 807
 808       FIXME("proprange(%ld,%ld)\n",pr->lMin,pr->lMax);
 809       switch (ph->dwObj) {
 810       case 0:   /* X */
 811       case 4:   /* Y */
 812       case 8:   /* Z */
 813       case 12:  /* Rx */
 814       case 16:  /* Ry */
 815       case 20:  /* Rz */
 816       case 24:  /* Slider 0 -> Throttle */
 817       case 28:  /* Slider 1 -> Rudder */
 818           This->wantmin[ph->dwObj/4] = pr->lMin;
 819           This->wantmax[ph->dwObj/4] = pr->lMax;
 820           break;
 821       default:
 822           FIXME("setting proprange %ld - %ld for dwObj %ld\n",pr->lMin,pr->lMax,ph->dwObj);
 823       }
 824       break;
 825     }
 826     case (DWORD)DIPROP_DEADZONE: {
 827       LPCDIPROPDWORD    pd = (LPCDIPROPDWORD)ph;
 828
 829       FIXME("setting deadzone(%ld)\n",pd->dwData);
 830       This->deadz[ph->dwObj/4] = pd->dwData;
 831       break;
 832     }
 833     default:
 834       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
 835       break;
 836     }
 837   }
 838   fake_current_js_state(This);
 839   return 0;
 840 }
 841
 842 /******************************************************************************
 843   *     SetEventNotification : specifies event to be sent on state change
 844   */
 845 static HRESULT WINAPI JoystickAImpl_SetEventNotification(
 846         LPDIRECTINPUTDEVICE8A iface, HANDLE hnd
 847 ) {
 848     JoystickImpl *This = (JoystickImpl *)iface;
 849
 850     TRACE("(this=%p,0x%08lx)\n",This,(DWORD)hnd);
 851     This->hEvent = hnd;
 852     return DI_OK;
 853 }
 854
 855 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
 856         LPDIRECTINPUTDEVICE8A iface,
 857         LPDIDEVCAPS lpDIDevCaps)
 858 {
 859     JoystickImpl *This = (JoystickImpl *)iface;
 860     int         xfd = This->joyfd;
 861     int         i,axes,buttons;
 862     int         wasacquired = 1;
 863
 864     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
 865     if (xfd==-1) {
 866         /* yes, games assume we return something, even if unacquired */
 867         JoystickAImpl_Acquire(iface);
 868         xfd = This->joyfd;
 869         wasacquired = 0;
 870     }
 871     lpDIDevCaps->dwFlags        = DIDC_ATTACHED;
 872     if (This->dinput->dwVersion >= 0x0800)
 873         lpDIDevCaps->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 874     else
 875         lpDIDevCaps->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 876
 877     axes=0;
 878     for (i=0;i<ABS_MAX;i++) if (test_bit(This->absbits,i)) axes++;
 879     buttons=0;
 880     for (i=0;i<KEY_MAX;i++) if (test_bit(This->keybits,i)) buttons++;
 881
 882     if (This->has_ff)
 883          lpDIDevCaps->dwFlags |= DIDC_FORCEFEEDBACK;
 884
 885     lpDIDevCaps->dwAxes = axes;
 886     lpDIDevCaps->dwButtons = buttons;
 887
 888     if (!wasacquired)
 889         JoystickAImpl_Unacquire(iface);
 890
 891     return DI_OK;
 892 }
 893
 894 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface) {
 895     JoystickImpl *This = (JoystickImpl *)iface;
 896     TRACE("(),stub!\n");
 897
 898     joy_polldev(This);
 899     return DI_OK;
 900 }
 901
 902 /******************************************************************************
 903   *     EnumObjects : enumerate the different buttons and axis...
 904   */
 905 static HRESULT WINAPI JoystickAImpl_EnumObjects(
 906         LPDIRECTINPUTDEVICE8A iface,
 907         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
 908         LPVOID lpvRef,
 909         DWORD dwFlags)
 910 {
 911   JoystickImpl *This = (JoystickImpl *)iface;
 912   DIDEVICEOBJECTINSTANCEA ddoi;
 913   int xfd = This->joyfd;
 914
 915
 916   TRACE("(this=%p,%p,%p,%08lx)\n", This, lpCallback, lpvRef, dwFlags);
 917   if (TRACE_ON(dinput)) {
 918     TRACE("  - flags = ");
 919     _dump_EnumObjects_flags(dwFlags);
 920     TRACE("\n");
 921   }
 922
 923   if (xfd == -1) return DIERR_NOTACQUIRED;
 924
 925   /* Only the fields till dwFFMaxForce are relevant */
 926   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
 927
 928   /* For the joystick, do as is done in the GetCapabilities function */
 929   /* FIXME: needs more items */
 930   if ((dwFlags == DIDFT_ALL) ||
 931       (dwFlags & DIDFT_AXIS)) {
 932     BYTE i;
 933
 934     for (i = 0; i < ABS_MAX; i++) {
 935       if (!test_bit(This->absbits,i)) continue;
 936
 937       switch (i) {
 938       case ABS_X:
 939         ddoi.guidType = GUID_XAxis;
 940         ddoi.dwOfs = DIJOFS_X;
 941         break;
 942       case ABS_Y:
 943         ddoi.guidType = GUID_YAxis;
 944         ddoi.dwOfs = DIJOFS_Y;
 945         break;
 946       case ABS_Z:
 947         ddoi.guidType = GUID_ZAxis;
 948         ddoi.dwOfs = DIJOFS_Z;
 949         break;
 950       case ABS_RX:
 951         ddoi.guidType = GUID_RxAxis;
 952         ddoi.dwOfs = DIJOFS_RX;
 953         break;
 954       case ABS_RY:
 955         ddoi.guidType = GUID_RyAxis;
 956         ddoi.dwOfs = DIJOFS_RY;
 957         break;
 958       case ABS_RZ:
 959         ddoi.guidType = GUID_RzAxis;
 960         ddoi.dwOfs = DIJOFS_RZ;
 961         break;
 962       case ABS_THROTTLE:
 963         ddoi.guidType = GUID_Slider;
 964         ddoi.dwOfs = DIJOFS_SLIDER(0);
 965         break;
 966       case ABS_RUDDER:
 967         ddoi.guidType = GUID_Slider;
 968         ddoi.dwOfs = DIJOFS_SLIDER(1);
 969         break;
 970       default:
 971         FIXME("unhandled abs axis %d, ignoring!\n",i);
 972       }
 973       ddoi.dwType = DIDFT_MAKEINSTANCE((1<<i) << WINE_JOYSTICK_AXIS_BASE) | DIDFT_ABSAXIS;
 974       sprintf(ddoi.tszName, "%d-Axis", i);
 975       _dump_OBJECTINSTANCEA(&ddoi);
 976       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
 977           return DI_OK;
 978     }
 979   }
 980
 981   if ((dwFlags == DIDFT_ALL) ||
 982       (dwFlags & DIDFT_BUTTON)) {
 983     int i;
 984
 985     /*The DInput SDK says that GUID_Button is only for mouse buttons but well*/
 986
 987     ddoi.guidType = GUID_Button;
 988
 989     for (i = 0; i < KEY_MAX; i++) {
 990       if (!test_bit(This->keybits,i)) continue;
 991
 992       switch (i) {
 993       case BTN_TRIGGER:
 994       case BTN_A:
 995       case BTN_1:
 996           ddoi.dwOfs = DIJOFS_BUTTON(0);
 997           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 0) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
 998           break;
 999         case BTN_THUMB:
1000         case BTN_B:
1001         case BTN_2:
1002           ddoi.dwOfs = DIJOFS_BUTTON(1);
1003           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 1) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1004           break;
1005         case BTN_THUMB2:
1006         case BTN_C:
1007         case BTN_3:
1008           ddoi.dwOfs = DIJOFS_BUTTON(2);
1009           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 2) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1010           break;
1011         case BTN_TOP:
1012         case BTN_X:
1013         case BTN_4:
1014           ddoi.dwOfs = DIJOFS_BUTTON(3);
1015           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 3) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1016           break;
1017         case BTN_TOP2:
1018         case BTN_Y:
1019         case BTN_5:
1020           ddoi.dwOfs = DIJOFS_BUTTON(4);
1021           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 4) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1022           break;
1023         case BTN_PINKIE:
1024         case BTN_Z:
1025         case BTN_6:
1026           ddoi.dwOfs = DIJOFS_BUTTON(5);
1027           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 5) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1028           break;
1029         case BTN_BASE:
1030         case BTN_TL:
1031         case BTN_7:
1032           ddoi.dwOfs = DIJOFS_BUTTON(6);
1033           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 6) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1034           break;
1035         case BTN_BASE2:
1036         case BTN_TR:
1037         case BTN_8:
1038           ddoi.dwOfs = DIJOFS_BUTTON(7);
1039           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 7) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1040           break;
1041         case BTN_BASE3:
1042         case BTN_TL2:
1043         case BTN_9:
1044           ddoi.dwOfs = DIJOFS_BUTTON(8);
1045           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 8) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1046           break;
1047         case BTN_BASE4:
1048         case BTN_TR2:
1049           ddoi.dwOfs = DIJOFS_BUTTON(9);
1050           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 9) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1051           break;
1052         case BTN_BASE5:
1053         case BTN_SELECT:
1054           ddoi.dwOfs = DIJOFS_BUTTON(10);
1055           ddoi.dwType = DIDFT_MAKEINSTANCE((0x0001 << 10) << WINE_JOYSTICK_BUTTON_BASE) | DIDFT_PSHBUTTON;
1056           break;
1057       }
1058       sprintf(ddoi.tszName, "%d-Button", i);
1059       _dump_OBJECTINSTANCEA(&ddoi);
1060       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
1061           return DI_OK;
1062     }
1063   }
1064
1065   if (xfd!=This->joyfd)
1066     close(xfd);
1067
1068   return DI_OK;
1069 }
1070
1071 static HRESULT WINAPI JoystickWImpl_EnumObjects(LPDIRECTINPUTDEVICE8W iface,
1072                                                 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
1073                                                 LPVOID lpvRef,
1074                                                 DWORD dwFlags)
1075 {
1076   JoystickImpl *This = (JoystickImpl *)iface;
1077
1078   device_enumobjects_AtoWcb_data data;
1079
1080   data.lpCallBack = lpCallback;
1081   data.lpvRef = lpvRef;
1082
1083   return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A) This, (LPDIENUMDEVICEOBJECTSCALLBACKA) DIEnumDevicesCallbackAtoW, (LPVOID) &data, dwFlags);
1084 }
1085
1086 /******************************************************************************
1087   *     GetProperty : get input device properties
1088   */
1089 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
1090                                                 REFGUID rguid,
1091                                                 LPDIPROPHEADER pdiph)
1092 {
1093   JoystickImpl *This = (JoystickImpl *)iface;
1094
1095   TRACE("(this=%p,%s,%p)\n",
1096         iface, debugstr_guid(rguid), pdiph);
1097
1098   if (TRACE_ON(dinput))
1099     _dump_DIPROPHEADER(pdiph);
1100
1101   if (!HIWORD(rguid)) {
1102     switch ((DWORD)rguid) {
1103     case (DWORD) DIPROP_BUFFERSIZE: {
1104       LPDIPROPDWORD     pd = (LPDIPROPDWORD)pdiph;
1105
1106       TRACE(" return buffersize = %d\n",This->queue_len);
1107       pd->dwData = This->queue_len;
1108       break;
1109     }
1110
1111     case (DWORD) DIPROP_RANGE: {
1112       /* LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph; */
1113       if ((pdiph->dwHow == DIPH_BYID) &&
1114           (pdiph->dwObj & DIDFT_ABSAXIS)) {
1115         /* The app is querying the current range of the axis : return the lMin and lMax values */
1116         FIXME("unimplemented axis range query.\n");
1117       }
1118
1119       break;
1120     }
1121
1122     default:
1123       FIXME("Unknown type %ld (%s)\n",(DWORD)rguid,debugstr_guid(rguid));
1124       break;
1125     }
1126   }
1127
1128
1129   return DI_OK;
1130 }
1131
1132 /******************************************************************************
1133   *     CreateEffect - Create a new FF effect with the specified params
1134   */
1135 static HRESULT WINAPI JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface,
1136                                                  REFGUID rguid,
1137                                                  LPCDIEFFECT lpeff,
1138                                                  LPDIRECTINPUTEFFECT *ppdef,
1139                                                  LPUNKNOWN pUnkOuter)
1140 {
1141 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1142     EffectListItem* new = NULL;
1143     HRESULT retval = DI_OK;
1144 #endif
1145
1146     JoystickImpl* This = (JoystickImpl*)iface;
1147     TRACE("(this=%p,%p,%p,%p,%p)\n", This, rguid, lpeff, ppdef, pUnkOuter);
1148
1149 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
1150     TRACE("not available (compiled w/o ff support)\n");
1151     *ppdef = NULL;
1152     return DI_OK;
1153 #else
1154
1155     new = malloc(sizeof(EffectListItem));
1156     new->next = This->top_effect;
1157     This->top_effect = new;
1158
1159     retval = linuxinput_create_effect(This->joyfd, rguid, &(new->ref));
1160     if (retval != DI_OK)
1161         return retval;
1162
1163     if (lpeff != NULL)
1164         retval = new->ref->lpVtbl->SetParameters(new->ref, lpeff, 0);
1165     if (retval != DI_OK)
1166         return retval;
1167
1168     *ppdef = new->ref;
1169
1170     if (pUnkOuter != NULL)
1171         FIXME("Interface aggregation not implemented.\n");
1172
1173     return DI_OK;
1174
1175 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1176 }
1177
1178 /*******************************************************************************
1179  *      EnumEffects - Enumerate available FF effects
1180  */
1181 static HRESULT WINAPI JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface,
1182                                                 LPDIENUMEFFECTSCALLBACKA lpCallback,
1183                                                 LPVOID pvRef,
1184                                                 DWORD dwEffType)
1185 {
1186     DIEFFECTINFOA dei; /* feif */
1187     DWORD type = DIEFT_GETTYPE(dwEffType);
1188     JoystickImpl* This = (JoystickImpl*)iface;
1189     int xfd = This->joyfd;
1190
1191     TRACE("(this=%p,%p,%ld) type=%ld fd=%d\n", This, pvRef, dwEffType, type, xfd);
1192
1193 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1194     dei.dwSize = sizeof(DIEFFECTINFOA);
1195
1196     /* We need to return something even if we're not yet acquired */
1197     if (xfd == -1)
1198         iface->lpVtbl->Acquire(iface);
1199
1200     if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1201         && test_bit(This->ffbits, FF_CONSTANT)) {
1202         iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1203         (*lpCallback)(&dei, pvRef);
1204     }
1205
1206     if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1207         && test_bit(This->ffbits, FF_PERIODIC)) {
1208         if (test_bit(This->ffbits, FF_SQUARE)) {
1209             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Square);
1210             (*lpCallback)(&dei, pvRef);
1211         }
1212         if (test_bit(This->ffbits, FF_SINE)) {
1213             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Sine);
1214             (*lpCallback)(&dei, pvRef);
1215         }
1216         if (test_bit(This->ffbits, FF_TRIANGLE)) {
1217             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Triangle);
1218             (*lpCallback)(&dei, pvRef);
1219         }
1220         if (test_bit(This->ffbits, FF_SAW_UP)) {
1221             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1222             (*lpCallback)(&dei, pvRef);
1223         }
1224         if (test_bit(This->ffbits, FF_SAW_DOWN)) {
1225             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1226             (*lpCallback)(&dei, pvRef);
1227         }
1228     }
1229
1230     if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1231         && test_bit(This->ffbits, FF_RAMP)) {
1232         iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_RampForce);
1233         (*lpCallback)(&dei, pvRef);
1234     }
1235
1236     if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1237         if (test_bit(This->ffbits, FF_SPRING)) {
1238             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Spring);
1239             (*lpCallback)(&dei, pvRef);
1240         }
1241         if (test_bit(This->ffbits, FF_DAMPER)) {
1242             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Damper);
1243             (*lpCallback)(&dei, pvRef);
1244         }
1245         if (test_bit(This->ffbits, FF_INERTIA)) {
1246             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Inertia);
1247             (*lpCallback)(&dei, pvRef);
1248         }
1249         if (test_bit(This->ffbits, FF_FRICTION)) {
1250             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Friction);
1251             (*lpCallback)(&dei, pvRef);
1252         }
1253     }
1254
1255     /* return to unaquired state if that's where it was */
1256     if (xfd == -1)
1257         iface->lpVtbl->Unacquire(iface);
1258 #endif
1259
1260     return DI_OK;
1261 }
1262
1263 static HRESULT WINAPI JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface,
1264                                                 LPDIENUMEFFECTSCALLBACKW lpCallback,
1265                                                 LPVOID pvRef,
1266                                                 DWORD dwEffType)
1267 {
1268     /* seems silly to duplicate all this code but all the structures and functions
1269      * are actually different (A/W) */
1270     DIEFFECTINFOW dei; /* feif */
1271     DWORD type = DIEFT_GETTYPE(dwEffType);
1272     JoystickImpl* This = (JoystickImpl*)iface;
1273     int xfd = This->joyfd;
1274
1275     TRACE("(this=%p,%p,%ld) type=%ld fd=%d\n", This, pvRef, dwEffType, type, xfd);
1276
1277 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1278     dei.dwSize = sizeof(DIEFFECTINFOW);
1279
1280     /* We need to return something even if we're not yet acquired */
1281     if (xfd == -1)
1282         iface->lpVtbl->Acquire(iface);
1283
1284     if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1285         && test_bit(This->ffbits, FF_CONSTANT)) {
1286         iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1287         (*lpCallback)(&dei, pvRef);
1288     }
1289
1290     if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1291         && test_bit(This->ffbits, FF_PERIODIC)) {
1292         if (test_bit(This->ffbits, FF_SQUARE)) {
1293             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Square);
1294             (*lpCallback)(&dei, pvRef);
1295         }
1296         if (test_bit(This->ffbits, FF_SINE)) {
1297             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Sine);
1298             (*lpCallback)(&dei, pvRef);
1299         }
1300         if (test_bit(This->ffbits, FF_TRIANGLE)) {
1301             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Triangle);
1302             (*lpCallback)(&dei, pvRef);
1303         }
1304         if (test_bit(This->ffbits, FF_SAW_UP)) {
1305             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1306             (*lpCallback)(&dei, pvRef);
1307         }
1308         if (test_bit(This->ffbits, FF_SAW_DOWN)) {
1309             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1310             (*lpCallback)(&dei, pvRef);
1311         }
1312     }
1313
1314     if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1315         && test_bit(This->ffbits, FF_RAMP)) {
1316         iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_RampForce);
1317         (*lpCallback)(&dei, pvRef);
1318     }
1319
1320     if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1321         if (test_bit(This->ffbits, FF_SPRING)) {
1322             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Spring);
1323             (*lpCallback)(&dei, pvRef);
1324         }
1325         if (test_bit(This->ffbits, FF_DAMPER)) {
1326             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Damper);
1327             (*lpCallback)(&dei, pvRef);
1328         }
1329         if (test_bit(This->ffbits, FF_INERTIA)) {
1330             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Inertia);
1331             (*lpCallback)(&dei, pvRef);
1332         }
1333         if (test_bit(This->ffbits, FF_FRICTION)) {
1334             iface->lpVtbl->GetEffectInfo(iface, &dei, &GUID_Friction);
1335             (*lpCallback)(&dei, pvRef);
1336         }
1337     }
1338
1339     /* return to unaquired state if that's where it was */
1340     if (xfd == -1)
1341         iface->lpVtbl->Unacquire(iface);
1342 #endif
1343
1344     return DI_OK;
1345 }
1346
1347 /*******************************************************************************
1348  *      GetEffectInfo - Get information about a particular effect
1349  */
1350 static HRESULT WINAPI JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface,
1351                                                   LPDIEFFECTINFOA pdei,
1352                                                   REFGUID guid)
1353 {
1354     JoystickImpl* This = (JoystickImpl*)iface;
1355
1356     TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1357
1358 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1359     return linuxinput_get_info_A(This->joyfd, guid, pdei);
1360 #else
1361     return DI_OK;
1362 #endif
1363 }
1364
1365 static HRESULT WINAPI JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface,
1366                                                   LPDIEFFECTINFOW pdei,
1367                                                   REFGUID guid)
1368 {
1369     JoystickImpl* This = (JoystickImpl*)iface;
1370
1371     TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1372
1373 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1374     return linuxinput_get_info_W(This->joyfd, guid, pdei);
1375 #else
1376     return DI_OK;
1377 #endif
1378 }
1379
1380 /*******************************************************************************
1381  *      GetForceFeedbackState - Get information about the device's FF state
1382  */
1383 static HRESULT WINAPI JoystickAImpl_GetForceFeedbackState(
1384         LPDIRECTINPUTDEVICE8A iface,
1385         LPDWORD pdwOut)
1386 {
1387     JoystickImpl* This = (JoystickImpl*)iface;
1388
1389     TRACE("(this=%p,%p)\n", This, pdwOut);
1390
1391     (*pdwOut) = 0;
1392
1393 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1394     /* DIGFFS_STOPPED is the only mandatory flag to report */
1395     if (This->ff_state == FF_STATUS_STOPPED)
1396         (*pdwOut) |= DIGFFS_STOPPED;
1397 #endif
1398
1399     return DI_OK;
1400 }
1401
1402 /*******************************************************************************
1403  *      SendForceFeedbackCommand - Send a command to the device's FF system
1404  */
1405 static HRESULT WINAPI JoystickAImpl_SendForceFeedbackCommand(
1406         LPDIRECTINPUTDEVICE8A iface,
1407         DWORD dwFlags)
1408 {
1409     JoystickImpl* This = (JoystickImpl*)iface;
1410     TRACE("(this=%p,%ld)\n", This, dwFlags);
1411
1412 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1413     if (dwFlags == DISFFC_STOPALL) {
1414         /* Stop all effects */
1415         EffectListItem* itr = This->top_effect;
1416         while (itr) {
1417             itr->ref->lpVtbl->Stop(itr->ref);
1418             itr = itr->next;
1419         }
1420     } else if (dwFlags == DISFFC_RESET) {
1421         /* Stop, unload, release and free all effects */
1422         /* This returns the device to its "bare" state */
1423         while (This->top_effect) {
1424             EffectListItem* temp = This->top_effect;
1425             temp->ref->lpVtbl->Stop(temp->ref);
1426             temp->ref->lpVtbl->Unload(temp->ref);
1427             temp->ref->lpVtbl->Release(temp->ref);
1428             This->top_effect = temp->next;
1429             free(temp);
1430         }
1431     } else if (dwFlags == DISFFC_PAUSE || dwFlags == DISFFC_CONTINUE) {
1432         FIXME("No support for Pause or Continue in linux\n");
1433     } else if (dwFlags == DISFFC_SETACTUATORSOFF
1434                 || dwFlags == DISFFC_SETACTUATORSON) {
1435         FIXME("No direct actuator control in linux\n");
1436     } else {
1437         FIXME("Unknown Force Feedback Command!\n");
1438         return DIERR_INVALIDPARAM;
1439     }
1440     return DI_OK;
1441 #else
1442     return DIERR_UNSUPPORTED;
1443 #endif
1444 }
1445
1446 /*******************************************************************************
1447  *      EnumCreatedEffectObjects - Enumerate all the effects that have been
1448  *              created for this device.
1449  */
1450 static HRESULT WINAPI JoystickAImpl_EnumCreatedEffectObjects(
1451         LPDIRECTINPUTDEVICE8A iface,
1452         LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
1453         LPVOID pvRef,
1454         DWORD dwFlags)
1455 {
1456     /* this function is safe to call on non-ff-enabled builds */
1457
1458     JoystickImpl* This = (JoystickImpl*)iface;
1459     EffectListItem* itr = This->top_effect;
1460     TRACE("(this=%p,%p,%p,%ld)\n", This, lpCallback, pvRef, dwFlags);
1461
1462     if (!lpCallback)
1463         return DIERR_INVALIDPARAM;
1464
1465     if (dwFlags != 0)
1466         FIXME("Flags specified, but no flags exist yet (DX9)!");
1467
1468     while (itr) {
1469         (*lpCallback)(itr->ref, pvRef);
1470         itr = itr->next;
1471     }
1472
1473     return DI_OK;
1474 }
1475
1476 static const IDirectInputDevice8AVtbl JoystickAvt =
1477 {
1478         IDirectInputDevice2AImpl_QueryInterface,
1479         IDirectInputDevice2AImpl_AddRef,
1480         JoystickAImpl_Release,
1481         JoystickAImpl_GetCapabilities,
1482         JoystickAImpl_EnumObjects,
1483         JoystickAImpl_GetProperty,
1484         JoystickAImpl_SetProperty,
1485         JoystickAImpl_Acquire,
1486         JoystickAImpl_Unacquire,
1487         JoystickAImpl_GetDeviceState,
1488         JoystickAImpl_GetDeviceData,
1489         JoystickAImpl_SetDataFormat,
1490         JoystickAImpl_SetEventNotification,
1491         IDirectInputDevice2AImpl_SetCooperativeLevel,
1492         IDirectInputDevice2AImpl_GetObjectInfo,
1493         IDirectInputDevice2AImpl_GetDeviceInfo,
1494         IDirectInputDevice2AImpl_RunControlPanel,
1495         IDirectInputDevice2AImpl_Initialize,
1496         JoystickAImpl_CreateEffect,
1497         JoystickAImpl_EnumEffects,
1498         JoystickAImpl_GetEffectInfo,
1499         JoystickAImpl_GetForceFeedbackState,
1500         JoystickAImpl_SendForceFeedbackCommand,
1501         JoystickAImpl_EnumCreatedEffectObjects,
1502         IDirectInputDevice2AImpl_Escape,
1503         JoystickAImpl_Poll,
1504         IDirectInputDevice2AImpl_SendDeviceData,
1505         IDirectInputDevice7AImpl_EnumEffectsInFile,
1506         IDirectInputDevice7AImpl_WriteEffectToFile,
1507         IDirectInputDevice8AImpl_BuildActionMap,
1508         IDirectInputDevice8AImpl_SetActionMap,
1509         IDirectInputDevice8AImpl_GetImageInfo
1510 };
1511
1512 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1513 # define XCAST(fun)     (typeof(JoystickWvt.fun))
1514 #else
1515 # define XCAST(fun)     (void*)
1516 #endif
1517
1518 static const IDirectInputDevice8WVtbl JoystickWvt =
1519 {
1520         IDirectInputDevice2WImpl_QueryInterface,
1521         XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1522         XCAST(Release)JoystickAImpl_Release,
1523         XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1524         JoystickWImpl_EnumObjects,
1525         XCAST(GetProperty)JoystickAImpl_GetProperty,
1526         XCAST(SetProperty)JoystickAImpl_SetProperty,
1527         XCAST(Acquire)JoystickAImpl_Acquire,
1528         XCAST(Unacquire)JoystickAImpl_Unacquire,
1529         XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1530         XCAST(GetDeviceData)JoystickAImpl_GetDeviceData,
1531         XCAST(SetDataFormat)JoystickAImpl_SetDataFormat,
1532         XCAST(SetEventNotification)JoystickAImpl_SetEventNotification,
1533         XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1534         IDirectInputDevice2WImpl_GetObjectInfo,
1535         IDirectInputDevice2WImpl_GetDeviceInfo,
1536         XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1537         XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1538         XCAST(CreateEffect)JoystickAImpl_CreateEffect,
1539         JoystickWImpl_EnumEffects,
1540         JoystickWImpl_GetEffectInfo,
1541         XCAST(GetForceFeedbackState)JoystickAImpl_GetForceFeedbackState,
1542         XCAST(SendForceFeedbackCommand)JoystickAImpl_SendForceFeedbackCommand,
1543         XCAST(EnumCreatedEffectObjects)JoystickAImpl_EnumCreatedEffectObjects,
1544         XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1545         XCAST(Poll)JoystickAImpl_Poll,
1546         XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1547         IDirectInputDevice7WImpl_EnumEffectsInFile,
1548         IDirectInputDevice7WImpl_WriteEffectToFile,
1549         IDirectInputDevice8WImpl_BuildActionMap,
1550         IDirectInputDevice8WImpl_SetActionMap,
1551         IDirectInputDevice8WImpl_GetImageInfo
1552 };
1553 #undef XCAST
1554
1555 #else  /* HAVE_CORRECT_LINUXINPUT_H */
1556
1557 const struct dinput_device joystick_linuxinput_device = {
1558   "Wine Linux-input joystick driver",
1559   NULL,
1560   NULL,
1561   NULL,
1562   NULL
1563 };
1564
1565 #endif  /* HAVE_CORRECT_LINUXINPUT_H */