dlls/dinput/joystick_linux.c

   1 /*              DirectInput Joystick device
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /*
  23  * To Do:
  24  *      dead zone
  25  *      force feedback
  26  */
  27
  28 #include "config.h"
  29 #include "wine/port.h"
  30
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <time.h>
  35 #include <errno.h>
  36 #ifdef HAVE_UNISTD_H
  37 # include <unistd.h>
  38 #endif
  39 #ifdef HAVE_SYS_TIME_H
  40 # include <sys/time.h>
  41 #endif
  42 #include <sys/fcntl.h>
  43 #ifdef HAVE_SYS_IOCTL_H
  44 # include <sys/ioctl.h>
  45 #endif
  46 #include <errno.h>
  47 #ifdef HAVE_SYS_ERRNO_H
  48 # include <sys/errno.h>
  49 #endif
  50 #ifdef HAVE_LINUX_IOCTL_H
  51 # include <linux/ioctl.h>
  52 #endif
  53 #ifdef HAVE_LINUX_JOYSTICK_H
  54 # include <linux/joystick.h>
  55 #endif
  56 #ifdef HAVE_SYS_POLL_H
  57 # include <sys/poll.h>
  58 #endif
  59
  60 #include "wine/debug.h"
  61 #include "wine/unicode.h"
  62 #include "windef.h"
  63 #include "winbase.h"
  64 #include "winerror.h"
  65 #include "winreg.h"
  66 #include "dinput.h"
  67
  68 #include "dinput_private.h"
  69 #include "device_private.h"
  70
  71 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  72
  73 #ifdef HAVE_LINUX_22_JOYSTICK_API
  74
  75 #define JOYDEV_NEW "/dev/input/js"
  76 #define JOYDEV_OLD "/dev/js"
  77
  78 typedef struct {
  79     LONG lMin;
  80     LONG lMax;
  81     LONG lDeadZone;
  82     LONG lSaturation;
  83 } ObjProps;
  84
  85 typedef struct {
  86     LONG lX;
  87     LONG lY;
  88 } POV;
  89
  90 typedef struct JoystickImpl JoystickImpl;
  91 static const IDirectInputDevice8AVtbl JoystickAvt;
  92 static const IDirectInputDevice8WVtbl JoystickWvt;
  93 struct JoystickImpl
  94 {
  95         struct IDirectInputDevice2AImpl base;
  96
  97         char                            dev[32];
  98
  99         /* The 'parent' DInput */
 100         IDirectInputImpl               *dinput;
 101
 102         /* joystick private */
 103         int                             joyfd;
 104         DIJOYSTATE2                     js;             /* wine data */
 105         LPDIDATAFORMAT                  user_df;        /* user defined format */
 106         DataFormat                      *transform;     /* wine to user format converter */
 107         int                             *offsets;       /* object offsets */
 108         ObjProps                        *props;
 109         char                            *name;
 110         DIDEVCAPS                       devcaps;
 111         LONG                            deadzone;
 112         int                             *axis_map;
 113         int                             axes;
 114         int                             buttons;
 115         POV                             povs[4];
 116 };
 117
 118 static GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
 119   0x9e573ed9,
 120   0x7734,
 121   0x11d2,
 122   {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
 123 };
 124
 125 static void _dump_DIDEVCAPS(LPDIDEVCAPS lpDIDevCaps)
 126 {
 127     TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
 128     TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
 129     TRACE("dwDevType: %08x %s\n", lpDIDevCaps->dwDevType,
 130           lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
 131           lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
 132           lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
 133           lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
 134           lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
 135           lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
 136     TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
 137     TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
 138     TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
 139     if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
 140         TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
 141         TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
 142         TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
 143         TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
 144         TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
 145     }
 146 }
 147
 148 static int joydev_get_device(char *dev, int id)
 149 {
 150     int ret;
 151     sprintf(dev, "%s%d", JOYDEV_NEW, id);
 152     if ((ret = open(dev, O_RDONLY)) < 0) {
 153         sprintf(dev, "%s%d", JOYDEV_OLD, id);
 154         if ((ret = open(dev, O_RDONLY)) < 0) {
 155             return -1;
 156         }
 157     }
 158     return ret;
 159 }
 160
 161 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
 162 {
 163     int fd = -1;
 164     char dev[32];
 165
 166     if (dwFlags & DIEDFL_FORCEFEEDBACK) {
 167         WARN("force feedback not supported\n");
 168         return FALSE;
 169     }
 170
 171     if ((dwDevType == 0) ||
 172         ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
 173         (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
 174         /* check whether we have a joystick */
 175         if ((fd = joydev_get_device(dev, id)) < 0) {
 176             WARN("open(%s,O_RDONLY) failed: %s\n", dev, strerror(errno));
 177             return FALSE;
 178         }
 179
 180         /* Return joystick */
 181         lpddi->guidInstance = DInput_Wine_Joystick_GUID;
 182         lpddi->guidInstance.Data3 = id;
 183         lpddi->guidProduct = DInput_Wine_Joystick_GUID;
 184         /* we only support traditional joysticks for now */
 185         if (version >= 0x0800)
 186             lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 187         else
 188             lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 189         sprintf(lpddi->tszInstanceName, "Joystick %d", id);
 190 #if defined(JSIOCGNAME)
 191         if (ioctl(fd,JSIOCGNAME(sizeof(lpddi->tszProductName)),lpddi->tszProductName) < 0) {
 192             WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", dev, strerror(errno));
 193             strcpy(lpddi->tszProductName, "Wine Joystick");
 194         }
 195 #else
 196         strcpy(lpddi->tszProductName, "Wine Joystick");
 197 #endif
 198
 199         lpddi->guidFFDriver = GUID_NULL;
 200         close(fd);
 201         TRACE("Enumerating the linux Joystick device: %s (%s)\n", dev, lpddi->tszProductName);
 202         return TRUE;
 203     }
 204
 205     return FALSE;
 206 }
 207
 208 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
 209 {
 210     int fd = -1;
 211     char name[MAX_PATH];
 212     char dev[32];
 213     char friendly[32];
 214
 215     if (dwFlags & DIEDFL_FORCEFEEDBACK) {
 216         WARN("force feedback not supported\n");
 217         return FALSE;
 218     }
 219
 220     if ((dwDevType == 0) ||
 221         ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
 222         (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
 223         /* check whether we have a joystick */
 224         if ((fd = joydev_get_device(dev, id)) < 0) {
 225             WARN("open(%s,O_RDONLY) failed: %s\n", dev, strerror(errno));
 226             return FALSE;
 227         }
 228
 229         /* Return joystick */
 230         lpddi->guidInstance = DInput_Wine_Joystick_GUID;
 231         lpddi->guidInstance.Data3 = id;
 232         lpddi->guidProduct = DInput_Wine_Joystick_GUID;
 233         /* we only support traditional joysticks for now */
 234         if (version >= 0x0800)
 235             lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 236         else
 237             lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 238         sprintf(friendly, "Joystick %d", id);
 239         MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH);
 240 #if defined(JSIOCGNAME)
 241         if (ioctl(fd,JSIOCGNAME(sizeof(name)),name) < 0) {
 242             WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", dev, strerror(errno));
 243             strcpy(name, "Wine Joystick");
 244         }
 245 #else
 246         strcpy(name, "Wine Joystick");
 247 #endif
 248         MultiByteToWideChar(CP_ACP, 0, name, -1, lpddi->tszProductName, MAX_PATH);
 249         lpddi->guidFFDriver = GUID_NULL;
 250         close(fd);
 251         TRACE("Enumerating the linux Joystick device: %s (%s)\n",dev,name);
 252         return TRUE;
 253     }
 254
 255     return FALSE;
 256 }
 257
 258 /*
 259  * Get a config key from either the app-specific or the default config
 260  */
 261
 262 inline static DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
 263                                     char *buffer, DWORD size )
 264 {
 265     if (appkey && !RegQueryValueExA( appkey, name, 0, NULL, (LPBYTE)buffer, &size ))
 266         return 0;
 267
 268     if (defkey && !RegQueryValueExA( defkey, name, 0, NULL, (LPBYTE)buffer, &size ))
 269         return 0;
 270
 271     return ERROR_FILE_NOT_FOUND;
 272 }
 273
 274 /*
 275  * Setup the dinput options.
 276  */
 277
 278 static HRESULT setup_dinput_options(JoystickImpl * device)
 279 {
 280     char buffer[MAX_PATH+16];
 281     HKEY hkey, appkey = 0;
 282     DWORD len;
 283
 284     buffer[MAX_PATH]='\0';
 285
 286     /* @@ Wine registry key: HKCU\Software\Wine\DirectInput */
 287     if (RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\DirectInput", &hkey)) hkey = 0;
 288
 289     len = GetModuleFileNameA( 0, buffer, MAX_PATH );
 290     if (len && len < MAX_PATH) {
 291         HKEY tmpkey;
 292         /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\DirectInput */
 293         if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmpkey ))
 294         {
 295             char *p, *appname = buffer;
 296             if ((p = strrchr( appname, '/' ))) appname = p + 1;
 297             if ((p = strrchr( appname, '\\' ))) appname = p + 1;
 298             strcat( appname, "\\DirectInput" );
 299             if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
 300             RegCloseKey( tmpkey );
 301         }
 302     }
 303
 304     /* get options */
 305
 306     if (!get_config_key( hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH )) {
 307         device->deadzone = atoi(buffer);
 308         TRACE("setting default deadzone to: \"%s\" %d\n", buffer, device->deadzone);
 309     }
 310
 311     if (!get_config_key( hkey, appkey, device->name, buffer, MAX_PATH )) {
 312         int tokens = 0;
 313         int axis = 0;
 314         int pov = 0;
 315         const char *delim = ",";
 316         char * ptr;
 317         TRACE("\"%s\" = \"%s\"\n", device->name, buffer);
 318
 319         device->axis_map = HeapAlloc(GetProcessHeap(), 0, device->axes * sizeof(int));
 320         if (device->axis_map == 0)
 321             return DIERR_OUTOFMEMORY;
 322
 323         if ((ptr = strtok(buffer, delim)) != NULL) {
 324             do {
 325                 if (strcmp(ptr, "X") == 0) {
 326                     device->axis_map[tokens] = 0;
 327                     axis++;
 328                 } else if (strcmp(ptr, "Y") == 0) {
 329                     device->axis_map[tokens] = 1;
 330                     axis++;
 331                 } else if (strcmp(ptr, "Z") == 0) {
 332                     device->axis_map[tokens] = 2;
 333                     axis++;
 334                 } else if (strcmp(ptr, "Rx") == 0) {
 335                     device->axis_map[tokens] = 3;
 336                     axis++;
 337                 } else if (strcmp(ptr, "Ry") == 0) {
 338                     device->axis_map[tokens] = 4;
 339                     axis++;
 340                 } else if (strcmp(ptr, "Rz") == 0) {
 341                     device->axis_map[tokens] = 5;
 342                     axis++;
 343                 } else if (strcmp(ptr, "Slider1") == 0) {
 344                     device->axis_map[tokens] = 6;
 345                     axis++;
 346                 } else if (strcmp(ptr, "Slider2") == 0) {
 347                     device->axis_map[tokens] = 7;
 348                     axis++;
 349                 } else if (strcmp(ptr, "POV1") == 0) {
 350                     device->axis_map[tokens++] = 8;
 351                     device->axis_map[tokens] = 8;
 352                     pov++;
 353                 } else if (strcmp(ptr, "POV2") == 0) {
 354                     device->axis_map[tokens++] = 9;
 355                     device->axis_map[tokens] = 9;
 356                     pov++;
 357                 } else if (strcmp(ptr, "POV3") == 0) {
 358                     device->axis_map[tokens++] = 10;
 359                     device->axis_map[tokens] = 10;
 360                     pov++;
 361                 } else if (strcmp(ptr, "POV4") == 0) {
 362                     device->axis_map[tokens++] = 11;
 363                     device->axis_map[tokens] = 11;
 364                     pov++;
 365                 } else {
 366                     ERR("invalid joystick axis type: %s\n", ptr);
 367                     device->axis_map[tokens] = tokens;
 368                     axis++;
 369                 }
 370
 371                 tokens++;
 372             } while ((ptr = strtok(NULL, delim)) != NULL);
 373
 374             if (tokens != device->devcaps.dwAxes) {
 375                 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n", device->axes, axis, pov,tokens);
 376                 while (tokens < device->axes) {
 377                     device->axis_map[tokens] = tokens;
 378                     tokens++;
 379                 }
 380             }
 381         }
 382
 383         device->devcaps.dwAxes = axis;
 384         device->devcaps.dwPOVs = pov;
 385     }
 386
 387     if (appkey)
 388         RegCloseKey( appkey );
 389
 390     if (hkey)
 391         RegCloseKey( hkey );
 392
 393     return DI_OK;
 394 }
 395
 396 static HRESULT alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, LPDIRECTINPUTDEVICEA* pdev)
 397 {
 398     DWORD i;
 399     JoystickImpl* newDevice;
 400     char name[MAX_PATH];
 401     HRESULT hr;
 402
 403     newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
 404     if (newDevice == 0) {
 405         WARN("out of memory\n");
 406         *pdev = 0;
 407         return DIERR_OUTOFMEMORY;
 408     }
 409
 410     if ((newDevice->joyfd = joydev_get_device(newDevice->dev, rguid->Data3)) < 0) {
 411         WARN("open(%s,O_RDONLY) failed: %s\n", newDevice->dev, strerror(errno));
 412         HeapFree(GetProcessHeap(), 0, newDevice);
 413         return DIERR_DEVICENOTREG;
 414     }
 415
 416     /* get the device name */
 417 #if defined(JSIOCGNAME)
 418     if (ioctl(newDevice->joyfd,JSIOCGNAME(MAX_PATH),name) < 0) {
 419         WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", newDevice->dev, strerror(errno));
 420         strcpy(name, "Wine Joystick");
 421     }
 422 #else
 423     strcpy(name, "Wine Joystick");
 424 #endif
 425
 426     /* copy the device name */
 427     newDevice->name = HeapAlloc(GetProcessHeap(),0,strlen(name) + 1);
 428     strcpy(newDevice->name, name);
 429
 430 #ifdef JSIOCGAXES
 431     if (ioctl(newDevice->joyfd,JSIOCGAXES,&newDevice->axes) < 0) {
 432         WARN("ioctl(%s,JSIOCGAXES) failed: %s, defauting to 2\n", newDevice->dev, strerror(errno));
 433         newDevice->axes = 2;
 434     }
 435 #endif
 436 #ifdef JSIOCGBUTTONS
 437     if (ioctl(newDevice->joyfd,JSIOCGBUTTONS,&newDevice->buttons) < 0) {
 438         WARN("ioctl(%s,JSIOCGBUTTONS) failed: %s, defauting to 2\n", newDevice->dev, strerror(errno));
 439         newDevice->buttons = 2;
 440     }
 441 #endif
 442
 443     newDevice->base.lpVtbl = jvt;
 444     newDevice->base.ref = 1;
 445     newDevice->dinput = dinput;
 446     CopyMemory(&newDevice->base.guid, rguid, sizeof(*rguid));
 447     InitializeCriticalSection(&newDevice->base.crit);
 448     newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)"DINPUT_joystick";
 449
 450     /* setup_dinput_options may change these */
 451     newDevice->deadzone = 5000;
 452     newDevice->devcaps.dwButtons = newDevice->buttons;
 453     newDevice->devcaps.dwAxes = newDevice->axes;
 454     newDevice->devcaps.dwPOVs = 0;
 455
 456     /* do any user specified configuration */
 457     hr = setup_dinput_options(newDevice);
 458     if (hr != DI_OK)
 459         goto FAILED1;
 460
 461     if (newDevice->axis_map == 0) {
 462         newDevice->axis_map = HeapAlloc(GetProcessHeap(), 0, newDevice->axes * sizeof(int));
 463         if (newDevice->axis_map == 0)
 464             goto FAILED;
 465
 466         for (i = 0; i < newDevice->axes; i++)
 467             newDevice->axis_map[i] = i;
 468     }
 469
 470     /* wine uses DIJOYSTATE2 as it's internal format so copy
 471      * the already defined format c_dfDIJoystick2 */
 472     newDevice->user_df = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwSize);
 473     if (newDevice->user_df == 0)
 474         goto FAILED;
 475
 476     CopyMemory(newDevice->user_df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
 477
 478     /* copy default objects */
 479     newDevice->user_df->rgodf = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwNumObjs*c_dfDIJoystick2.dwObjSize);
 480     if (newDevice->user_df->rgodf == 0)
 481         goto FAILED;
 482
 483     CopyMemory(newDevice->user_df->rgodf,c_dfDIJoystick2.rgodf,c_dfDIJoystick2.dwNumObjs*c_dfDIJoystick2.dwObjSize);
 484
 485     /* create default properties */
 486     newDevice->props = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwNumObjs*sizeof(ObjProps));
 487     if (newDevice->props == 0)
 488         goto FAILED;
 489
 490     /* initialize default properties */
 491     for (i = 0; i < c_dfDIJoystick2.dwNumObjs; i++) {
 492         newDevice->props[i].lMin = 0;
 493         newDevice->props[i].lMax = 0xffff;
 494         newDevice->props[i].lDeadZone = newDevice->deadzone;    /* % * 1000 */
 495         newDevice->props[i].lSaturation = 0;
 496     }
 497
 498     /* create an offsets array */
 499     newDevice->offsets = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,c_dfDIJoystick2.dwNumObjs*sizeof(int));
 500     if (newDevice->offsets == 0)
 501         goto FAILED;
 502
 503     /* create the default transform filter */
 504     newDevice->transform = create_DataFormat(&c_dfDIJoystick2, newDevice->user_df, newDevice->offsets);
 505
 506     IDirectInputDevice_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->dinput);
 507
 508     newDevice->devcaps.dwSize = sizeof(newDevice->devcaps);
 509     newDevice->devcaps.dwFlags = DIDC_ATTACHED;
 510     if (newDevice->dinput->dwVersion >= 0x0800)
 511         newDevice->devcaps.dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 512     else
 513         newDevice->devcaps.dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 514     newDevice->devcaps.dwFFSamplePeriod = 0;
 515     newDevice->devcaps.dwFFMinTimeResolution = 0;
 516     newDevice->devcaps.dwFirmwareRevision = 0;
 517     newDevice->devcaps.dwHardwareRevision = 0;
 518     newDevice->devcaps.dwFFDriverVersion = 0;
 519
 520     if (TRACE_ON(dinput)) {
 521         _dump_DIDATAFORMAT(newDevice->user_df);
 522        for (i = 0; i < (newDevice->axes); i++)
 523            TRACE("axis_map[%d] = %d\n", i, newDevice->axis_map[i]);
 524         _dump_DIDEVCAPS(&newDevice->devcaps);
 525     }
 526
 527     *pdev = (LPDIRECTINPUTDEVICEA)newDevice;
 528
 529     return DI_OK;
 530
 531 FAILED:
 532     hr = DIERR_OUTOFMEMORY;
 533 FAILED1:
 534     HeapFree(GetProcessHeap(),0,newDevice->axis_map);
 535     HeapFree(GetProcessHeap(),0,newDevice->name);
 536     HeapFree(GetProcessHeap(),0,newDevice->props);
 537     HeapFree(GetProcessHeap(),0,newDevice->user_df->rgodf);
 538     HeapFree(GetProcessHeap(),0,newDevice->user_df);
 539     HeapFree(GetProcessHeap(),0,newDevice);
 540     *pdev = 0;
 541
 542     return hr;
 543 }
 544
 545 static BOOL IsJoystickGUID(REFGUID guid)
 546 {
 547     GUID wine_joystick = DInput_Wine_Joystick_GUID;
 548     GUID dev_guid = *guid;
 549
 550     wine_joystick.Data3 = 0;
 551     dev_guid.Data3 = 0;
 552
 553     return IsEqualGUID(&wine_joystick, &dev_guid);
 554 }
 555
 556 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
 557 {
 558   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 559       (IsJoystickGUID(rguid))) {
 560     if ((riid == NULL) ||
 561         IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
 562         IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
 563         IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
 564         IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
 565       return alloc_device(rguid, &JoystickAvt, dinput, pdev);
 566     } else {
 567       WARN("no interface\n");
 568       *pdev = 0;
 569       return DIERR_NOINTERFACE;
 570     }
 571   }
 572
 573   WARN("invalid device GUID\n");
 574   *pdev = 0;
 575   return DIERR_DEVICENOTREG;
 576 }
 577
 578 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
 579 {
 580   if ((IsEqualGUID(&GUID_Joystick,rguid)) ||
 581       (IsJoystickGUID(rguid))) {
 582     if ((riid == NULL) ||
 583         IsEqualGUID(&IID_IDirectInputDeviceW,riid) ||
 584         IsEqualGUID(&IID_IDirectInputDevice2W,riid) ||
 585         IsEqualGUID(&IID_IDirectInputDevice7W,riid) ||
 586         IsEqualGUID(&IID_IDirectInputDevice8W,riid)) {
 587       return alloc_device(rguid, &JoystickWvt, dinput, (LPDIRECTINPUTDEVICEA *)pdev);
 588     } else {
 589       WARN("no interface\n");
 590       *pdev = 0;
 591       return DIERR_NOINTERFACE;
 592     }
 593   }
 594
 595   WARN("invalid device GUID\n");
 596   *pdev = 0;
 597   return DIERR_DEVICENOTREG;
 598 }
 599
 600 const struct dinput_device joystick_linux_device = {
 601   "Wine Linux joystick driver",
 602   joydev_enum_deviceA,
 603   joydev_enum_deviceW,
 604   joydev_create_deviceA,
 605   joydev_create_deviceW
 606 };
 607
 608 /******************************************************************************
 609  *      Joystick
 610  */
 611 static ULONG WINAPI JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface)
 612 {
 613     JoystickImpl *This = (JoystickImpl *)iface;
 614     ULONG ref;
 615
 616     ref = InterlockedDecrement(&This->base.ref);
 617     if (ref)
 618         return ref;
 619
 620     /* Free the device name */
 621     HeapFree(GetProcessHeap(),0,This->name);
 622
 623     /* Free the axis map */
 624     HeapFree(GetProcessHeap(),0,This->axis_map);
 625
 626     /* Free the data queue */
 627     HeapFree(GetProcessHeap(), 0, This->base.data_queue);
 628
 629     /* Free the DataFormat */
 630     HeapFree(GetProcessHeap(), 0, This->user_df->rgodf);
 631     HeapFree(GetProcessHeap(), 0, This->user_df);
 632
 633     /* Free the properties */
 634     HeapFree(GetProcessHeap(), 0, This->props);
 635
 636     /* Free the offsets array */
 637     HeapFree(GetProcessHeap(),0,This->offsets);
 638
 639     /* release the data transform filter */
 640     release_DataFormat(This->transform);
 641
 642     This->base.crit.DebugInfo->Spare[0] = 0;
 643     DeleteCriticalSection(&This->base.crit);
 644     IDirectInputDevice_Release((LPDIRECTINPUTDEVICE8A)This->dinput);
 645
 646     HeapFree(GetProcessHeap(),0,This);
 647     return 0;
 648 }
 649
 650 /******************************************************************************
 651   *   SetDataFormat : the application can choose the format of the data
 652   *   the device driver sends back with GetDeviceState.
 653   */
 654 static HRESULT WINAPI JoystickAImpl_SetDataFormat(
 655     LPDIRECTINPUTDEVICE8A iface,
 656     LPCDIDATAFORMAT df)
 657 {
 658     JoystickImpl *This = (JoystickImpl *)iface;
 659     unsigned int i;
 660     LPDIDATAFORMAT new_df = 0;
 661     LPDIOBJECTDATAFORMAT new_rgodf = 0;
 662     ObjProps * new_props = 0;
 663
 664     TRACE("(%p,%p)\n",This,df);
 665
 666     if (df == NULL) {
 667         WARN("invalid pointer\n");
 668         return E_POINTER;
 669     }
 670
 671     if (df->dwSize != sizeof(*df)) {
 672         WARN("invalid argument\n");
 673         return DIERR_INVALIDPARAM;
 674     }
 675
 676     if (This->base.acquired) {
 677         WARN("acquired\n");
 678         return DIERR_ACQUIRED;
 679     }
 680
 681     if (TRACE_ON(dinput))
 682         _dump_DIDATAFORMAT(df);
 683
 684     /* Store the new data format */
 685     new_df = HeapAlloc(GetProcessHeap(),0,df->dwSize);
 686     if (new_df == 0)
 687         goto FAILED;
 688
 689     new_rgodf = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*df->dwObjSize);
 690     if (new_rgodf == 0)
 691         goto FAILED;
 692
 693     new_props = HeapAlloc(GetProcessHeap(),0,df->dwNumObjs*sizeof(ObjProps));
 694     if (new_props == 0)
 695         goto FAILED;
 696
 697     HeapFree(GetProcessHeap(),0,This->user_df);
 698     HeapFree(GetProcessHeap(),0,This->user_df->rgodf);
 699     HeapFree(GetProcessHeap(),0,This->props);
 700     release_DataFormat(This->transform);
 701
 702     This->user_df = new_df;
 703     CopyMemory(This->user_df, df, df->dwSize);
 704     This->user_df->rgodf = new_rgodf;
 705     CopyMemory(This->user_df->rgodf,df->rgodf,df->dwNumObjs*df->dwObjSize);
 706     This->props = new_props;
 707     for (i = 0; i < df->dwNumObjs; i++) {
 708         This->props[i].lMin = 0;
 709         This->props[i].lMax = 0xffff;
 710         This->props[i].lDeadZone = 1000;
 711         This->props[i].lSaturation = 0;
 712     }
 713     This->transform = create_DataFormat(&c_dfDIJoystick2, This->user_df, This->offsets);
 714
 715     return DI_OK;
 716
 717 FAILED:
 718     WARN("out of memory\n");
 719     HeapFree(GetProcessHeap(),0,new_props);
 720     HeapFree(GetProcessHeap(),0,new_rgodf);
 721     HeapFree(GetProcessHeap(),0,new_df);
 722     return DIERR_OUTOFMEMORY;
 723 }
 724
 725 /******************************************************************************
 726   *     Acquire : gets exclusive control of the joystick
 727   */
 728 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
 729 {
 730     JoystickImpl *This = (JoystickImpl *)iface;
 731
 732     TRACE("(%p)\n",This);
 733
 734     if (This->base.acquired) {
 735         WARN("already acquired\n");
 736         return S_FALSE;
 737     }
 738
 739     /* open the joystick device */
 740     if (This->joyfd==-1) {
 741         TRACE("opening joystick device %s\n", This->dev);
 742
 743         This->joyfd=open(This->dev,O_RDONLY);
 744         if (This->joyfd==-1) {
 745             ERR("open(%s) failed: %s\n", This->dev, strerror(errno));
 746             return DIERR_NOTFOUND;
 747         }
 748     }
 749
 750     This->base.acquired = 1;
 751
 752     return DI_OK;
 753 }
 754
 755 /******************************************************************************
 756   *     Unacquire : frees the joystick
 757   */
 758 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
 759 {
 760     JoystickImpl *This = (JoystickImpl *)iface;
 761     HRESULT res;
 762
 763     TRACE("(%p)\n",This);
 764
 765     if ((res = IDirectInputDevice2AImpl_Unacquire(iface)) != DI_OK) return res;
 766
 767     if (This->joyfd!=-1) {
 768         TRACE("closing joystick device\n");
 769         close(This->joyfd);
 770         This->joyfd = -1;
 771         return DI_OK;
 772     }
 773
 774     return DI_NOEFFECT;
 775 }
 776
 777 static LONG map_axis(JoystickImpl * This, short val, short index)
 778 {
 779     double    fval = val;
 780     double    fmin = This->props[index].lMin;
 781     double    fmax = This->props[index].lMax;
 782     double    fret;
 783
 784     fret = (((fval + 32767.0) * (fmax - fmin)) / (32767.0*2.0)) + fmin;
 785
 786     if (fret >= 0.0)
 787         fret += 0.5;
 788     else
 789         fret -= 0.5;
 790
 791     return fret;
 792 }
 793
 794 /* convert wine format offset to user format object index */
 795 static int offset_to_object(JoystickImpl *This, int offset)
 796 {
 797     int i;
 798
 799     for (i = 0; i < This->user_df->dwNumObjs; i++) {
 800         if (This->user_df->rgodf[i].dwOfs == offset)
 801             return i;
 802     }
 803
 804     return -1;
 805 }
 806
 807 static LONG calculate_pov(JoystickImpl *This, int index)
 808 {
 809     if (This->povs[index].lX < -16384) {
 810         if (This->povs[index].lY < -16384)
 811             This->js.rgdwPOV[index] = 31500;
 812         else if (This->povs[index].lY > 16384)
 813             This->js.rgdwPOV[index] = 22500;
 814         else
 815             This->js.rgdwPOV[index] = 27000;
 816     } else if (This->povs[index].lX > 16384) {
 817         if (This->povs[index].lY < -16384)
 818             This->js.rgdwPOV[index] = 4500;
 819         else if (This->povs[index].lY > 16384)
 820             This->js.rgdwPOV[index] = 13500;
 821         else
 822             This->js.rgdwPOV[index] = 9000;
 823     } else {
 824         if (This->povs[index].lY < -16384)
 825             This->js.rgdwPOV[index] = 0;
 826         else if (This->povs[index].lY > 16384)
 827             This->js.rgdwPOV[index] = 18000;
 828         else
 829             This->js.rgdwPOV[index] = -1;
 830     }
 831
 832     return This->js.rgdwPOV[index];
 833 }
 834
 835 static void joy_polldev(JoystickImpl *This) {
 836     struct pollfd plfd;
 837     struct      js_event jse;
 838     TRACE("(%p)\n", This);
 839
 840     if (This->joyfd==-1) {
 841         WARN("no device\n");
 842         return;
 843     }
 844     while (1) {
 845         plfd.fd = This->joyfd;
 846         plfd.events = POLLIN;
 847         if (poll(&plfd,1,0) != 1)
 848             return;
 849         /* we have one event, so we can read */
 850         if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
 851             return;
 852         }
 853         TRACE("js_event: type 0x%x, number %d, value %d\n",
 854               jse.type,jse.number,jse.value);
 855         if (jse.type & JS_EVENT_BUTTON) {
 856             int offset = This->offsets[jse.number + 12];
 857             int value = jse.value?0x80:0x00;
 858
 859             This->js.rgbButtons[jse.number] = value;
 860             queue_event((LPDIRECTINPUTDEVICE8A)This, offset, value, jse.time, This->dinput->evsequence++);
 861         } else if (jse.type & JS_EVENT_AXIS) {
 862             int number = This->axis_map[jse.number];    /* wine format object index */
 863             if (number < 12) {
 864                 int offset = This->offsets[number];
 865                 int index = offset_to_object(This, offset);
 866                 LONG value = map_axis(This, jse.value, index);
 867
 868                 /* FIXME do deadzone and saturation here */
 869
 870                 TRACE("changing axis %d => %d\n", jse.number, number);
 871                 switch (number) {
 872                 case 0:
 873                     This->js.lX = value;
 874                     break;
 875                 case 1:
 876                     This->js.lY = value;
 877                     break;
 878                 case 2:
 879                     This->js.lZ = value;
 880                     break;
 881                 case 3:
 882                     This->js.lRx = value;
 883                     break;
 884                 case 4:
 885                     This->js.lRy = value;
 886                     break;
 887                 case 5:
 888                     This->js.lRz = value;
 889                     break;
 890                 case 6:
 891                     This->js.rglSlider[0] = value;
 892                     break;
 893                 case 7:
 894                     This->js.rglSlider[1] = value;
 895                     break;
 896                 case 8:
 897                     /* FIXME don't go off array */
 898                     if (This->axis_map[jse.number + 1] == number)
 899                         This->povs[0].lX = jse.value;
 900                     else if (This->axis_map[jse.number - 1] == number)
 901                         This->povs[0].lY = jse.value;
 902                     value = calculate_pov(This, 0);
 903                     break;
 904                 case 9:
 905                     if (This->axis_map[jse.number + 1] == number)
 906                         This->povs[1].lX = jse.value;
 907                     else if (This->axis_map[jse.number - 1] == number)
 908                         This->povs[1].lY = jse.value;
 909                     value = calculate_pov(This, 1);
 910                     break;
 911                 case 10:
 912                     if (This->axis_map[jse.number + 1] == number)
 913                         This->povs[2].lX = jse.value;
 914                     else if (This->axis_map[jse.number - 1] == number)
 915                         This->povs[2].lY = jse.value;
 916                     value = calculate_pov(This, 2);
 917                     break;
 918                 case 11:
 919                     if (This->axis_map[jse.number + 1] == number)
 920                         This->povs[3].lX = jse.value;
 921                     else if (This->axis_map[jse.number - 1] == number)
 922                         This->povs[3].lY = jse.value;
 923                     value = calculate_pov(This, 3);
 924                     break;
 925                 }
 926
 927                 queue_event((LPDIRECTINPUTDEVICE8A)This, offset, value, jse.time, This->dinput->evsequence++);
 928             } else
 929                 WARN("axis %d not supported\n", number);
 930         }
 931     }
 932 }
 933
 934 /******************************************************************************
 935   *     GetDeviceState : returns the "state" of the joystick.
 936   *
 937   */
 938 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
 939     LPDIRECTINPUTDEVICE8A iface,
 940     DWORD len,
 941     LPVOID ptr)
 942 {
 943     JoystickImpl *This = (JoystickImpl *)iface;
 944
 945     TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
 946
 947     if (!This->base.acquired) {
 948         WARN("not acquired\n");
 949         return DIERR_NOTACQUIRED;
 950     }
 951
 952     /* update joystick state */
 953     joy_polldev(This);
 954
 955     /* convert and copy data to user supplied buffer */
 956     fill_DataFormat(ptr, &This->js, This->transform);
 957
 958     return DI_OK;
 959 }
 960
 961 static int find_property(JoystickImpl * This, LPCDIPROPHEADER ph)
 962 {
 963     int i;
 964     if (ph->dwHow == DIPH_BYOFFSET) {
 965         return offset_to_object(This, ph->dwObj);
 966     } else if (ph->dwHow == DIPH_BYID) {
 967         for (i = 0; i < This->user_df->dwNumObjs; i++) {
 968             if ((This->user_df->rgodf[i].dwType & 0x00ffffff) == (ph->dwObj & 0x00ffffff)) {
 969                 return i;
 970             }
 971         }
 972     }
 973
 974     return -1;
 975 }
 976
 977 /******************************************************************************
 978   *     SetProperty : change input device properties
 979   */
 980 static HRESULT WINAPI JoystickAImpl_SetProperty(
 981     LPDIRECTINPUTDEVICE8A iface,
 982     REFGUID rguid,
 983     LPCDIPROPHEADER ph)
 984 {
 985     JoystickImpl *This = (JoystickImpl *)iface;
 986     int i;
 987
 988     TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
 989
 990     if (ph == NULL) {
 991         WARN("invalid parameter: ph == NULL\n");
 992         return DIERR_INVALIDPARAM;
 993     }
 994
 995     if (TRACE_ON(dinput))
 996         _dump_DIPROPHEADER(ph);
 997
 998     if (!HIWORD(rguid)) {
 999         switch (LOWORD(rguid)) {
1000         case (DWORD)DIPROP_RANGE: {
1001             LPCDIPROPRANGE      pr = (LPCDIPROPRANGE)ph;
1002             if (ph->dwHow == DIPH_DEVICE) {
1003                 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
1004                 for (i = 0; i < This->user_df->dwNumObjs; i++) {
1005                     This->props[i].lMin = pr->lMin;
1006                     This->props[i].lMax = pr->lMax;
1007                 }
1008             } else {
1009                 int obj = find_property(This, ph);
1010                 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
1011                 if (obj >= 0) {
1012                     This->props[obj].lMin = pr->lMin;
1013                     This->props[obj].lMax = pr->lMax;
1014                     return DI_OK;
1015                 }
1016             }
1017             break;
1018         }
1019         case (DWORD)DIPROP_DEADZONE: {
1020             LPCDIPROPDWORD      pd = (LPCDIPROPDWORD)ph;
1021             if (ph->dwHow == DIPH_DEVICE) {
1022                 TRACE("deadzone(%d) all\n", pd->dwData);
1023                 for (i = 0; i < This->user_df->dwNumObjs; i++)
1024                     This->props[i].lDeadZone  = pd->dwData;
1025             } else {
1026                 int obj = find_property(This, ph);
1027                 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
1028                 if (obj >= 0) {
1029                     This->props[obj].lDeadZone  = pd->dwData;
1030                     return DI_OK;
1031                 }
1032             }
1033             break;
1034         }
1035         case (DWORD)DIPROP_SATURATION: {
1036             LPCDIPROPDWORD      pd = (LPCDIPROPDWORD)ph;
1037             if (ph->dwHow == DIPH_DEVICE) {
1038                 TRACE("saturation(%d) all\n", pd->dwData);
1039                 for (i = 0; i < This->user_df->dwNumObjs; i++)
1040                     This->props[i].lSaturation = pd->dwData;
1041             } else {
1042                 int obj = find_property(This, ph);
1043                 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
1044                 if (obj >= 0) {
1045                     This->props[obj].lSaturation = pd->dwData;
1046                     return DI_OK;
1047                 }
1048             }
1049             break;
1050         }
1051         default:
1052             return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
1053         }
1054     }
1055
1056     return DI_OK;
1057 }
1058
1059 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
1060         LPDIRECTINPUTDEVICE8A iface,
1061         LPDIDEVCAPS lpDIDevCaps)
1062 {
1063     JoystickImpl *This = (JoystickImpl *)iface;
1064     int size;
1065
1066     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
1067
1068     if (lpDIDevCaps == NULL) {
1069         WARN("invalid pointer\n");
1070         return E_POINTER;
1071     }
1072
1073     size = lpDIDevCaps->dwSize;
1074
1075     if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
1076         WARN("invalid parameter\n");
1077         return DIERR_INVALIDPARAM;
1078     }
1079
1080     CopyMemory(lpDIDevCaps, &This->devcaps, size);
1081     lpDIDevCaps->dwSize = size;
1082
1083     if (TRACE_ON(dinput))
1084         _dump_DIDEVCAPS(lpDIDevCaps);
1085
1086     return DI_OK;
1087 }
1088
1089 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
1090 {
1091     JoystickImpl *This = (JoystickImpl *)iface;
1092
1093     TRACE("(%p)\n",This);
1094
1095     if (!This->base.acquired) {
1096         WARN("not acquired\n");
1097         return DIERR_NOTACQUIRED;
1098     }
1099
1100     joy_polldev(This);
1101     return DI_OK;
1102 }
1103
1104 /******************************************************************************
1105   *     EnumObjects : enumerate the different buttons and axis...
1106   */
1107 static HRESULT WINAPI JoystickAImpl_EnumObjects(
1108         LPDIRECTINPUTDEVICE8A iface,
1109         LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback,
1110         LPVOID lpvRef,
1111         DWORD dwFlags)
1112 {
1113   JoystickImpl *This = (JoystickImpl *)iface;
1114   DIDEVICEOBJECTINSTANCEA ddoi;
1115   BYTE i;
1116   int user_offset;
1117   int user_object;
1118
1119   TRACE("(this=%p,%p,%p,%08x)\n", This, lpCallback, lpvRef, dwFlags);
1120   if (TRACE_ON(dinput)) {
1121     TRACE("  - flags = ");
1122     _dump_EnumObjects_flags(dwFlags);
1123     TRACE("\n");
1124   }
1125
1126   /* Only the fields till dwFFMaxForce are relevant */
1127   ddoi.dwSize = FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA, dwFFMaxForce);
1128
1129   /* For the joystick, do as is done in the GetCapabilities function */
1130   if ((dwFlags == DIDFT_ALL) ||
1131       (dwFlags & DIDFT_AXIS) ||
1132       (dwFlags & DIDFT_POV)) {
1133     int pov[4] = { 0, 0, 0, 0 };
1134     int axes = 0;
1135     int povs = 0;
1136
1137     for (i = 0; i < This->axes; i++) {
1138       int wine_obj = This->axis_map[i];
1139       BOOL skip = FALSE;
1140
1141       switch (wine_obj) {
1142       case 0:
1143         ddoi.guidType = GUID_XAxis;
1144         break;
1145       case 1:
1146         ddoi.guidType = GUID_YAxis;
1147         break;
1148       case 2:
1149         ddoi.guidType = GUID_ZAxis;
1150         break;
1151       case 3:
1152         ddoi.guidType = GUID_RxAxis;
1153         break;
1154       case 4:
1155         ddoi.guidType = GUID_RyAxis;
1156         break;
1157       case 5:
1158         ddoi.guidType = GUID_RzAxis;
1159         break;
1160       case 6:
1161         ddoi.guidType = GUID_Slider;
1162         break;
1163       case 7:
1164         ddoi.guidType = GUID_Slider;
1165         break;
1166       case 8:
1167         pov[0]++;
1168         ddoi.guidType = GUID_POV;
1169         break;
1170       case 9:
1171         pov[1]++;
1172         ddoi.guidType = GUID_POV;
1173         break;
1174       case 10:
1175         pov[2]++;
1176         ddoi.guidType = GUID_POV;
1177         break;
1178       case 11:
1179         pov[3]++;
1180         ddoi.guidType = GUID_POV;
1181         break;
1182       default:
1183         ddoi.guidType = GUID_Unknown;
1184       }
1185       if (wine_obj < 8) {
1186           user_offset = This->offsets[wine_obj];        /* get user offset from wine index */
1187           user_object = offset_to_object(This, user_offset);
1188
1189           ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1190           ddoi.dwOfs =  This->user_df->rgodf[user_object].dwOfs;
1191           sprintf(ddoi.tszName, "Axis %d", axes);
1192           axes++;
1193       } else {
1194           if (pov[wine_obj - 8] < 2) {
1195               user_offset = This->offsets[wine_obj];    /* get user offset from wine index */
1196               user_object = offset_to_object(This, user_offset);
1197
1198               ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1199               ddoi.dwOfs =  This->user_df->rgodf[user_object].dwOfs;
1200               sprintf(ddoi.tszName, "POV %d", povs);
1201               povs++;
1202           } else
1203               skip = TRUE;
1204       }
1205       if (!skip) {
1206           _dump_OBJECTINSTANCEA(&ddoi);
1207           if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE)
1208               return DI_OK;
1209       }
1210     }
1211   }
1212
1213   if ((dwFlags == DIDFT_ALL) ||
1214       (dwFlags & DIDFT_BUTTON)) {
1215
1216     /* The DInput SDK says that GUID_Button is only for mouse buttons but well... */
1217     ddoi.guidType = GUID_Button;
1218
1219     for (i = 0; i < This->buttons; i++) {
1220       user_offset = This->offsets[i + 12];      /* get user offset from wine index */
1221       user_object = offset_to_object(This, user_offset);
1222       ddoi.guidType = GUID_Button;
1223       ddoi.dwType = This->user_df->rgodf[user_object].dwType & 0x00ffffff;
1224       ddoi.dwOfs =  This->user_df->rgodf[user_object].dwOfs;
1225       sprintf(ddoi.tszName, "Button %d", i);
1226       _dump_OBJECTINSTANCEA(&ddoi);
1227       if (lpCallback(&ddoi, lpvRef) != DIENUM_CONTINUE) return DI_OK;
1228     }
1229   }
1230
1231   return DI_OK;
1232 }
1233
1234 /******************************************************************************
1235   *     EnumObjects : enumerate the different buttons and axis...
1236   */
1237 static HRESULT WINAPI JoystickWImpl_EnumObjects(
1238         LPDIRECTINPUTDEVICE8W iface,
1239         LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback,
1240         LPVOID lpvRef,
1241         DWORD dwFlags)
1242 {
1243   JoystickImpl *This = (JoystickImpl *)iface;
1244
1245   device_enumobjects_AtoWcb_data data;
1246
1247   data.lpCallBack = lpCallback;
1248   data.lpvRef = lpvRef;
1249
1250   return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A) This, (LPDIENUMDEVICEOBJECTSCALLBACKA) DIEnumDevicesCallbackAtoW, (LPVOID) &data, dwFlags);
1251 }
1252
1253 /******************************************************************************
1254   *     GetProperty : get input device properties
1255   */
1256 static HRESULT WINAPI JoystickAImpl_GetProperty(
1257     LPDIRECTINPUTDEVICE8A iface,
1258     REFGUID rguid,
1259     LPDIPROPHEADER pdiph)
1260 {
1261     JoystickImpl *This = (JoystickImpl *)iface;
1262
1263     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
1264
1265     if (TRACE_ON(dinput))
1266         _dump_DIPROPHEADER(pdiph);
1267
1268     if (!HIWORD(rguid)) {
1269         switch (LOWORD(rguid)) {
1270         case (DWORD) DIPROP_RANGE: {
1271             LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
1272             int obj = find_property(This, pdiph);
1273             /* The app is querying the current range of the axis
1274              * return the lMin and lMax values */
1275             if (obj >= 0) {
1276                 pr->lMin = This->props[obj].lMin;
1277                 pr->lMax = This->props[obj].lMax;
1278                 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
1279                 return DI_OK;
1280             }
1281             break;
1282         }
1283         case (DWORD) DIPROP_DEADZONE: {
1284             LPDIPROPDWORD       pd = (LPDIPROPDWORD)pdiph;
1285             int obj = find_property(This, pdiph);
1286             if (obj >= 0) {
1287                 pd->dwData = This->props[obj].lDeadZone;
1288                 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
1289                 return DI_OK;
1290             }
1291             break;
1292         }
1293         case (DWORD) DIPROP_SATURATION: {
1294             LPDIPROPDWORD       pd = (LPDIPROPDWORD)pdiph;
1295             int obj = find_property(This, pdiph);
1296             if (obj >= 0) {
1297                 pd->dwData = This->props[obj].lSaturation;
1298                 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
1299                 return DI_OK;
1300             }
1301             break;
1302         }
1303         default:
1304             return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
1305         }
1306     }
1307
1308     return DI_OK;
1309 }
1310
1311 /******************************************************************************
1312   *     GetObjectInfo : get object info
1313   */
1314 HRESULT WINAPI JoystickAImpl_GetObjectInfo(
1315         LPDIRECTINPUTDEVICE8A iface,
1316         LPDIDEVICEOBJECTINSTANCEA pdidoi,
1317         DWORD dwObj,
1318         DWORD dwHow)
1319 {
1320     JoystickImpl *This = (JoystickImpl *)iface;
1321     DIDEVICEOBJECTINSTANCEA didoiA;
1322     unsigned int i;
1323
1324     TRACE("(%p,%p,%d,0x%08x(%s))\n",
1325           iface, pdidoi, dwObj, dwHow,
1326           dwHow == DIPH_BYOFFSET ? "DIPH_BYOFFSET" :
1327           dwHow == DIPH_BYID ? "DIPH_BYID" :
1328           dwHow == DIPH_BYUSAGE ? "DIPH_BYUSAGE" :
1329           "UNKNOWN");
1330
1331     if (pdidoi == NULL) {
1332         WARN("invalid parameter: pdidoi = NULL\n");
1333         return DIERR_INVALIDPARAM;
1334     }
1335
1336     if ((pdidoi->dwSize != sizeof(DIDEVICEOBJECTINSTANCEA)) &&
1337         (pdidoi->dwSize != sizeof(DIDEVICEOBJECTINSTANCE_DX3A))) {
1338         WARN("invalid parameter: pdidoi->dwSize = %d != %d or %d\n",
1339              pdidoi->dwSize, sizeof(DIDEVICEOBJECTINSTANCEA),
1340              sizeof(DIDEVICEOBJECTINSTANCE_DX3A));
1341         return DIERR_INVALIDPARAM;
1342     }
1343
1344     ZeroMemory(&didoiA, sizeof(didoiA));
1345     didoiA.dwSize = pdidoi->dwSize;
1346
1347     switch (dwHow) {
1348     case DIPH_BYOFFSET: {
1349         int axis = 0;
1350         int pov = 0;
1351         int button = 0;
1352         for (i = 0; i < This->user_df->dwNumObjs; i++) {
1353             if (This->user_df->rgodf[i].dwOfs == dwObj) {
1354                 if (This->user_df->rgodf[i].pguid)
1355                     didoiA.guidType = *This->user_df->rgodf[i].pguid;
1356                 else
1357                     didoiA.guidType = GUID_NULL;
1358
1359                 didoiA.dwOfs = dwObj;
1360                 didoiA.dwType = This->user_df->rgodf[i].dwType;
1361                 didoiA.dwFlags = This->user_df->rgodf[i].dwFlags;
1362
1363                 if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_AXIS)
1364                     sprintf(didoiA.tszName, "Axis %d", axis);
1365                 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_POV)
1366                     sprintf(didoiA.tszName, "POV %d", pov);
1367                 else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
1368                     sprintf(didoiA.tszName, "Button %d", button);
1369
1370                 CopyMemory(pdidoi, &didoiA, pdidoi->dwSize);
1371                 return DI_OK;
1372             }
1373
1374             if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_AXIS)
1375                 axis++;
1376             else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_POV)
1377                 pov++;
1378             else if (DIDFT_GETTYPE(This->user_df->rgodf[i].dwType) & DIDFT_BUTTON)
1379                 button++;
1380         }
1381         break;
1382     }
1383     case DIPH_BYID:
1384         FIXME("dwHow = DIPH_BYID not implemented\n");
1385         break;
1386     case DIPH_BYUSAGE:
1387         FIXME("dwHow = DIPH_BYUSAGE not implemented\n");
1388         break;
1389     default:
1390         WARN("invalid parameter: dwHow = %08x\n", dwHow);
1391         return DIERR_INVALIDPARAM;
1392     }
1393
1394     CopyMemory(pdidoi, &didoiA, pdidoi->dwSize);
1395
1396     return DI_OK;
1397 }
1398
1399 /******************************************************************************
1400   *     GetDeviceInfo : get information about a device's identity
1401   */
1402 HRESULT WINAPI JoystickAImpl_GetDeviceInfo(
1403     LPDIRECTINPUTDEVICE8A iface,
1404     LPDIDEVICEINSTANCEA pdidi)
1405 {
1406     JoystickImpl *This = (JoystickImpl *)iface;
1407
1408     TRACE("(%p,%p)\n", iface, pdidi);
1409
1410     if (pdidi == NULL) {
1411         WARN("invalid pointer\n");
1412         return E_POINTER;
1413     }
1414
1415     if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
1416         (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
1417         WARN("invalid parameter: pdidi->dwSize = %d != %d or %d\n",
1418              pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3A),
1419              sizeof(DIDEVICEINSTANCEA));
1420         return DIERR_INVALIDPARAM;
1421     }
1422
1423     /* Return joystick */
1424     pdidi->guidInstance = GUID_Joystick;
1425     pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1426     /* we only support traditional joysticks for now */
1427     pdidi->dwDevType = This->devcaps.dwDevType;
1428     strcpy(pdidi->tszInstanceName, "Joystick");
1429     strcpy(pdidi->tszProductName, This->name);
1430     if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
1431         pdidi->guidFFDriver = GUID_NULL;
1432         pdidi->wUsagePage = 0;
1433         pdidi->wUsage = 0;
1434     }
1435
1436     return DI_OK;
1437 }
1438
1439 /******************************************************************************
1440   *     GetDeviceInfo : get information about a device's identity
1441   */
1442 HRESULT WINAPI JoystickWImpl_GetDeviceInfo(
1443     LPDIRECTINPUTDEVICE8W iface,
1444     LPDIDEVICEINSTANCEW pdidi)
1445 {
1446     JoystickImpl *This = (JoystickImpl *)iface;
1447
1448     TRACE("(%p,%p)\n", iface, pdidi);
1449
1450     if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
1451         (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
1452         WARN("invalid parameter: pdidi->dwSize = %d != %d or %d\n",
1453              pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3W),
1454              sizeof(DIDEVICEINSTANCEW));
1455         return DIERR_INVALIDPARAM;
1456     }
1457
1458     /* Return joystick */
1459     pdidi->guidInstance = GUID_Joystick;
1460     pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1461     /* we only support traditional joysticks for now */
1462     pdidi->dwDevType = This->devcaps.dwDevType;
1463     MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
1464     MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
1465     if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
1466         pdidi->guidFFDriver = GUID_NULL;
1467         pdidi->wUsagePage = 0;
1468         pdidi->wUsage = 0;
1469     }
1470
1471     return DI_OK;
1472 }
1473
1474 static const IDirectInputDevice8AVtbl JoystickAvt =
1475 {
1476         IDirectInputDevice2AImpl_QueryInterface,
1477         IDirectInputDevice2AImpl_AddRef,
1478         JoystickAImpl_Release,
1479         JoystickAImpl_GetCapabilities,
1480         JoystickAImpl_EnumObjects,
1481         JoystickAImpl_GetProperty,
1482         JoystickAImpl_SetProperty,
1483         JoystickAImpl_Acquire,
1484         JoystickAImpl_Unacquire,
1485         JoystickAImpl_GetDeviceState,
1486         IDirectInputDevice2AImpl_GetDeviceData,
1487         JoystickAImpl_SetDataFormat,
1488         IDirectInputDevice2AImpl_SetEventNotification,
1489         IDirectInputDevice2AImpl_SetCooperativeLevel,
1490         JoystickAImpl_GetObjectInfo,
1491         JoystickAImpl_GetDeviceInfo,
1492         IDirectInputDevice2AImpl_RunControlPanel,
1493         IDirectInputDevice2AImpl_Initialize,
1494         IDirectInputDevice2AImpl_CreateEffect,
1495         IDirectInputDevice2AImpl_EnumEffects,
1496         IDirectInputDevice2AImpl_GetEffectInfo,
1497         IDirectInputDevice2AImpl_GetForceFeedbackState,
1498         IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1499         IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1500         IDirectInputDevice2AImpl_Escape,
1501         JoystickAImpl_Poll,
1502         IDirectInputDevice2AImpl_SendDeviceData,
1503         IDirectInputDevice7AImpl_EnumEffectsInFile,
1504         IDirectInputDevice7AImpl_WriteEffectToFile,
1505         IDirectInputDevice8AImpl_BuildActionMap,
1506         IDirectInputDevice8AImpl_SetActionMap,
1507         IDirectInputDevice8AImpl_GetImageInfo
1508 };
1509
1510 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1511 # define XCAST(fun)     (typeof(SysJoystickWvt.fun))
1512 #else
1513 # define XCAST(fun)     (void*)
1514 #endif
1515
1516 static const IDirectInputDevice8WVtbl SysJoystickWvt =
1517 {
1518         IDirectInputDevice2WImpl_QueryInterface,
1519         XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1520         XCAST(Release)JoystickAImpl_Release,
1521         XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1522         JoystickWImpl_EnumObjects,
1523         XCAST(GetProperty)JoystickAImpl_GetProperty,
1524         XCAST(SetProperty)JoystickAImpl_SetProperty,
1525         XCAST(Acquire)JoystickAImpl_Acquire,
1526         XCAST(Unacquire)JoystickAImpl_Unacquire,
1527         XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1528         XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
1529         XCAST(SetDataFormat)JoystickAImpl_SetDataFormat,
1530         XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
1531         XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1532         IDirectInputDevice2WImpl_GetObjectInfo,
1533         JoystickWImpl_GetDeviceInfo,
1534         XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1535         XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1536         XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
1537         IDirectInputDevice2WImpl_EnumEffects,
1538         IDirectInputDevice2WImpl_GetEffectInfo,
1539         XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
1540         XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1541         XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1542         XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1543         XCAST(Poll)JoystickAImpl_Poll,
1544         XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1545         IDirectInputDevice7WImpl_EnumEffectsInFile,
1546         IDirectInputDevice7WImpl_WriteEffectToFile,
1547         IDirectInputDevice8WImpl_BuildActionMap,
1548         IDirectInputDevice8WImpl_SetActionMap,
1549         IDirectInputDevice8WImpl_GetImageInfo
1550 };
1551 #undef XCAST
1552
1553 #else  /* HAVE_LINUX_22_JOYSTICK_API */
1554
1555 const struct dinput_device joystick_linux_device = {
1556   "Wine Linux joystick driver",
1557   NULL,
1558   NULL,
1559   NULL,
1560   NULL
1561 };
1562
1563 #endif  /* HAVE_LINUX_22_JOYSTICK_API */