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

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