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