?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.61.
[wine/gsoc-2012-control.git] / dlls / dinput / joystick_linux.c
blobdf5d77b69647da19aa8d2e4c381610c6b0f5cd83
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 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif
38 #ifdef HAVE_SYS_TIME_H
39 # include <sys/time.h>
40 #endif
41 #include <fcntl.h>
42 #ifdef HAVE_SYS_IOCTL_H
43 # include <sys/ioctl.h>
44 #endif
45 #include <errno.h>
46 #ifdef HAVE_SYS_ERRNO_H
47 # include <sys/errno.h>
48 #endif
49 #ifdef HAVE_LINUX_IOCTL_H
50 # include <linux/ioctl.h>
51 #endif
52 #ifdef HAVE_LINUX_JOYSTICK_H
53 # include <linux/joystick.h>
54 # undef SW_MAX
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 JoystickImpl JoystickImpl;
79 static const IDirectInputDevice8AVtbl JoystickAvt;
80 static const IDirectInputDevice8WVtbl JoystickWvt;
81 struct JoystickImpl
82 {
83 struct IDirectInputDevice2AImpl base;
84
85 char dev[32];
86
87 /* joystick private */
88 int joyfd;
89 DIJOYSTATE2 js; /* wine data */
90 ObjProps *props;
91 char *name;
92 DIDEVCAPS devcaps;
93 LONG deadzone;
94 int *axis_map;
95 int axes;
96 int buttons;
97 POINTL povs[4];
98 };
99
100 static const GUID DInput_Wine_Joystick_GUID = { /* 9e573ed9-7734-11d2-8d4a-23903fb6bdf7 */
101 0x9e573ed9,
102 0x7734,
103 0x11d2,
104 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
105 };
106
107 static void _dump_DIDEVCAPS(const DIDEVCAPS *lpDIDevCaps)
108 {
109 TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
110 TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
111 TRACE("dwDevType: %08x %s\n", lpDIDevCaps->dwDevType,
112 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
113 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
114 lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
115 lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
116 lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
117 lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
118 TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
119 TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
120 TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
121 if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
122 TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
123 TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
124 TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
125 TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
126 TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
127 }
128 }
129
130 #define MAX_JOYSTICKS 64
131 static INT joystick_devices_count = -1;
132 static LPSTR joystick_devices[MAX_JOYSTICKS];
133
134 static INT find_joystick_devices(void)
135 {
136 INT i;
137
138 if (joystick_devices_count != -1) return joystick_devices_count;
139
140 joystick_devices_count = 0;
141 for (i = 0; i < MAX_JOYSTICKS; i++)
142 {
143 CHAR device_name[MAX_PATH], *str;
144 INT len;
145 int fd;
146
147 len = sprintf(device_name, "%s%d", JOYDEV_NEW, i) + 1;
148 if ((fd = open(device_name, O_RDONLY)) < 0)
149 {
150 len = sprintf(device_name, "%s%d", JOYDEV_OLD, i) + 1;
151 if ((fd = open(device_name, O_RDONLY)) < 0) continue;
152 }
153
154 close(fd);
155
156 if (!(str = HeapAlloc(GetProcessHeap(), 0, len))) break;
157 memcpy(str, device_name, len);
158
159 joystick_devices[joystick_devices_count++] = str;
160 }
161
162 return joystick_devices_count;
163 }
164
165 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
166 {
167 int fd = -1;
168
169 if (id >= find_joystick_devices()) return FALSE;
170
171 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
172 WARN("force feedback not supported\n");
173 return FALSE;
174 }
175
176 if ((dwDevType == 0) ||
177 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
178 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
179 /* check whether we have a joystick */
180 if ((fd = open(joystick_devices[id], O_RDONLY)) < 0)
181 {
182 WARN("open(%s, O_RDONLY) failed: %s\n", joystick_devices[id], strerror(errno));
183 return FALSE;
184 }
185
186 /* Return joystick */
187 lpddi->guidInstance = DInput_Wine_Joystick_GUID;
188 lpddi->guidInstance.Data3 = id;
189 lpddi->guidProduct = DInput_Wine_Joystick_GUID;
190 /* we only support traditional joysticks for now */
191 if (version >= 0x0800)
192 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
193 else
194 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
195 sprintf(lpddi->tszInstanceName, "Joystick %d", id);
196 #if defined(JSIOCGNAME)
197 if (ioctl(fd,JSIOCGNAME(sizeof(lpddi->tszProductName)),lpddi->tszProductName) < 0) {
198 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", joystick_devices[id], strerror(errno));
199 strcpy(lpddi->tszProductName, "Wine Joystick");
200 }
201 #else
202 strcpy(lpddi->tszProductName, "Wine Joystick");
203 #endif
204
205 lpddi->guidFFDriver = GUID_NULL;
206 close(fd);
207 TRACE("Enumerating the linux Joystick device: %s (%s)\n", joystick_devices[id], lpddi->tszProductName);
208 return TRUE;
209 }
210
211 return FALSE;
212 }
213
214 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
215 {
216 int fd = -1;
217 char name[MAX_PATH];
218 char friendly[32];
219
220 if (id >= find_joystick_devices()) return FALSE;
221
222 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
223 WARN("force feedback not supported\n");
224 return FALSE;
225 }
226
227 if ((dwDevType == 0) ||
228 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
229 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
230 /* check whether we have a joystick */
231 if ((fd = open(joystick_devices[id], O_RDONLY)) < 0)
232 {
233 WARN("open(%s,O_RDONLY) failed: %s\n", joystick_devices[id], strerror(errno));
234 return FALSE;
235 }
236
237 /* Return joystick */
238 lpddi->guidInstance = DInput_Wine_Joystick_GUID;
239 lpddi->guidInstance.Data3 = id;
240 lpddi->guidProduct = DInput_Wine_Joystick_GUID;
241 /* we only support traditional joysticks for now */
242 if (version >= 0x0800)
243 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
244 else
245 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
246 sprintf(friendly, "Joystick %d", id);
247 MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH);
248 #if defined(JSIOCGNAME)
249 if (ioctl(fd,JSIOCGNAME(sizeof(name)),name) < 0) {
250 WARN("ioctl(%s, JSIOCGNAME) failed: %s\n", joystick_devices[id], strerror(errno));
251 strcpy(name, "Wine Joystick");
252 }
253 #else
254 strcpy(name, "Wine Joystick");
255 #endif
256 MultiByteToWideChar(CP_ACP, 0, name, -1, lpddi->tszProductName, MAX_PATH);
257 lpddi->guidFFDriver = GUID_NULL;
258 close(fd);
259 TRACE("Enumerating the linux Joystick device: %s (%s)\n", joystick_devices[id], name);
260 return TRUE;
261 }
262
263 return FALSE;
264 }
265
266 /*
267 * Setup the dinput options.
268 */
269
270 static HRESULT setup_dinput_options(JoystickImpl * device)
271 {
272 char buffer[MAX_PATH+16];
273 HKEY hkey, appkey;
274 int tokens = 0;
275 int axis = 0;
276 int pov = 0;
277
278 buffer[MAX_PATH]='\0';
279
280 get_app_key(&hkey, &appkey);
281
282 /* get options */
283
284 if (!get_config_key( hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH )) {
285 device->deadzone = atoi(buffer);
286 TRACE("setting default deadzone to: \"%s\" %d\n", buffer, device->deadzone);
287 }
288
289 device->axis_map = HeapAlloc(GetProcessHeap(), 0, device->axes * sizeof(int));
290 if (!device->axis_map) return DIERR_OUTOFMEMORY;
291
292 if (!get_config_key( hkey, appkey, device->name, buffer, MAX_PATH )) {
293 const char *delim = ",";
294 char * ptr;
295 TRACE("\"%s\" = \"%s\"\n", device->name, buffer);
296
297 if ((ptr = strtok(buffer, delim)) != NULL) {
298 do {
299 if (strcmp(ptr, "X") == 0) {
300 device->axis_map[tokens] = 0;
301 axis++;
302 } else if (strcmp(ptr, "Y") == 0) {
303 device->axis_map[tokens] = 1;
304 axis++;
305 } else if (strcmp(ptr, "Z") == 0) {
306 device->axis_map[tokens] = 2;
307 axis++;
308 } else if (strcmp(ptr, "Rx") == 0) {
309 device->axis_map[tokens] = 3;
310 axis++;
311 } else if (strcmp(ptr, "Ry") == 0) {
312 device->axis_map[tokens] = 4;
313 axis++;
314 } else if (strcmp(ptr, "Rz") == 0) {
315 device->axis_map[tokens] = 5;
316 axis++;
317 } else if (strcmp(ptr, "Slider1") == 0) {
318 device->axis_map[tokens] = 6;
319 axis++;
320 } else if (strcmp(ptr, "Slider2") == 0) {
321 device->axis_map[tokens] = 7;
322 axis++;
323 } else if (strcmp(ptr, "POV1") == 0) {
324 device->axis_map[tokens++] = 8;
325 device->axis_map[tokens] = 8;
326 pov++;
327 } else if (strcmp(ptr, "POV2") == 0) {
328 device->axis_map[tokens++] = 9;
329 device->axis_map[tokens] = 9;
330 pov++;
331 } else if (strcmp(ptr, "POV3") == 0) {
332 device->axis_map[tokens++] = 10;
333 device->axis_map[tokens] = 10;
334 pov++;
335 } else if (strcmp(ptr, "POV4") == 0) {
336 device->axis_map[tokens++] = 11;
337 device->axis_map[tokens] = 11;
338 pov++;
339 } else {
340 ERR("invalid joystick axis type: %s\n", ptr);
341 device->axis_map[tokens] = tokens;
342 axis++;
343 }
344
345 tokens++;
346 } while ((ptr = strtok(NULL, delim)) != NULL);
347
348 if (tokens != device->devcaps.dwAxes) {
349 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n", device->axes, axis, pov,tokens);
350 while (tokens < device->axes) {
351 device->axis_map[tokens] = tokens;
352 tokens++;
353 }
354 }
355 }
356
357 }
358 else
359 {
360 for (tokens = 0; tokens < device->axes; tokens++)
361 {
362 if (tokens < 8)
363 device->axis_map[tokens] = axis++;
364 else
365 {
366 device->axis_map[tokens++] = 8 + pov;
367 device->axis_map[tokens ] = 8 + pov++;
368 }
369 }
370 }
371 device->devcaps.dwAxes = axis;
372 device->devcaps.dwPOVs = pov;
373
374 if (appkey)
375 RegCloseKey( appkey );
376
377 if (hkey)
378 RegCloseKey( hkey );
379
380 return DI_OK;
381 }
382
383 static HRESULT alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput,
384 LPDIRECTINPUTDEVICEA* pdev, unsigned short index)
385 {
386 DWORD i;
387 JoystickImpl* newDevice;
388 char name[MAX_PATH];
389 HRESULT hr;
390 LPDIDATAFORMAT df = NULL;
391 int idx = 0;
392
393 TRACE("%s %p %p %p %hu\n", debugstr_guid(rguid), jvt, dinput, pdev, index);
394
395 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
396 if (newDevice == 0) {
397 WARN("out of memory\n");
398 *pdev = 0;
399 return DIERR_OUTOFMEMORY;
400 }
401
402 if (!lstrcpynA(newDevice->dev, joystick_devices[index], sizeof(newDevice->dev)) ||
403 (newDevice->joyfd = open(newDevice->dev, O_RDONLY)) < 0)
404 {
405 WARN("open(%s, O_RDONLY) failed: %s\n", newDevice->dev, strerror(errno));
406 HeapFree(GetProcessHeap(), 0, newDevice);
407 return DIERR_DEVICENOTREG;
408 }
409
410 /* get the device name */
411 #if defined(JSIOCGNAME)
412 if (ioctl(newDevice->joyfd,JSIOCGNAME(MAX_PATH),name) < 0) {
413 WARN("ioctl(%s,JSIOCGNAME) failed: %s\n", newDevice->dev, strerror(errno));
414 strcpy(name, "Wine Joystick");
415 }
416 #else
417 strcpy(name, "Wine Joystick");
418 #endif
419
420 /* copy the device name */
421 newDevice->name = HeapAlloc(GetProcessHeap(),0,strlen(name) + 1);
422 strcpy(newDevice->name, name);
423
424 #ifdef JSIOCGAXES
425 if (ioctl(newDevice->joyfd,JSIOCGAXES,&newDevice->axes) < 0) {
426 WARN("ioctl(%s,JSIOCGAXES) failed: %s, defauting to 2\n", newDevice->dev, strerror(errno));
427 newDevice->axes = 2;
428 }
429 #endif
430 #ifdef JSIOCGBUTTONS
431 if (ioctl(newDevice->joyfd,JSIOCGBUTTONS,&newDevice->buttons) < 0) {
432 WARN("ioctl(%s,JSIOCGBUTTONS) failed: %s, defauting to 2\n", newDevice->dev, strerror(errno));
433 newDevice->buttons = 2;
434 }
435 #endif
436
437 if (newDevice->axes > 16)
438 {
439 /* There are 24 more axes for velocity that we can use */
440 FIXME("Can't support %d axes. Clamping down to 16\n", newDevice->axes);
441 newDevice->axes = 16;
442 }
443
444 if (newDevice->buttons > 128)
445 {
446 WARN("Can't support %d buttons. Clamping down to 128\n", newDevice->buttons);
447 newDevice->buttons = 128;
448 }
449
450 newDevice->base.lpVtbl = jvt;
451 newDevice->base.ref = 1;
452 newDevice->base.dinput = dinput;
453 newDevice->base.guid = *rguid;
454 InitializeCriticalSection(&newDevice->base.crit);
455 newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit");
456
457 /* setup_dinput_options may change these */
458 newDevice->deadzone = 0;
459 newDevice->devcaps.dwButtons = newDevice->buttons;
460
461 /* do any user specified configuration */
462 hr = setup_dinput_options(newDevice);
463 if (hr != DI_OK)
464 goto FAILED1;
465
466 /* Create copy of default data format */
467 if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto FAILED;
468 memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
469
470 df->dwNumObjs = newDevice->devcaps.dwAxes + newDevice->devcaps.dwPOVs + newDevice->buttons;
471 if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto FAILED;
472
473 for (i = 0; i < newDevice->axes; i++)
474 {
475 int wine_obj = newDevice->axis_map[i];
476
477 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[wine_obj], df->dwObjSize);
478 if (wine_obj < 8)
479 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(wine_obj) | DIDFT_ABSAXIS;
480 else
481 {
482 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(wine_obj - 8) | DIDFT_POV;
483 i++; /* POV takes 2 axes */
484 }
485 }
486 for (i = 0; i < newDevice->buttons; i++)
487 {
488 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + 12], df->dwObjSize);
489 df->rgodf[idx ].pguid = &GUID_Button;
490 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_PSHBUTTON;
491 }
492 newDevice->base.data_format.wine_df = df;
493
494 /* create default properties */
495 newDevice->props = HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2.dwNumObjs*sizeof(ObjProps));
496 if (newDevice->props == 0)
497 goto FAILED;
498
499 /* initialize default properties */
500 for (i = 0; i < c_dfDIJoystick2.dwNumObjs; i++) {
501 newDevice->props[i].lDevMin = -32767;
502 newDevice->props[i].lDevMax = +32767;
503 newDevice->props[i].lMin = 0;
504 newDevice->props[i].lMax = 0xffff;
505 newDevice->props[i].lDeadZone = newDevice->deadzone; /* % * 1000 */
506 newDevice->props[i].lSaturation = 0;
507 }
508
509 IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput);
510
511 newDevice->devcaps.dwSize = sizeof(newDevice->devcaps);
512 newDevice->devcaps.dwFlags = DIDC_ATTACHED;
513 if (newDevice->base.dinput->dwVersion >= 0x0800)
514 newDevice->devcaps.dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
515 else
516 newDevice->devcaps.dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
517 newDevice->devcaps.dwFFSamplePeriod = 0;
518 newDevice->devcaps.dwFFMinTimeResolution = 0;
519 newDevice->devcaps.dwFirmwareRevision = 0;
520 newDevice->devcaps.dwHardwareRevision = 0;
521 newDevice->devcaps.dwFFDriverVersion = 0;
522
523 if (TRACE_ON(dinput)) {
524 _dump_DIDATAFORMAT(newDevice->base.data_format.wine_df);
525 for (i = 0; i < (newDevice->axes); i++)
526 TRACE("axis_map[%d] = %d\n", i, newDevice->axis_map[i]);
527 _dump_DIDEVCAPS(&newDevice->devcaps);
528 }
529
530 *pdev = (LPDIRECTINPUTDEVICEA)newDevice;
531
532 return DI_OK;
533
534 FAILED:
535 hr = DIERR_OUTOFMEMORY;
536 FAILED1:
537 if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
538 HeapFree(GetProcessHeap(), 0, df);
539 release_DataFormat(&newDevice->base.data_format);
540 HeapFree(GetProcessHeap(),0,newDevice->axis_map);
541 HeapFree(GetProcessHeap(),0,newDevice->name);
542 HeapFree(GetProcessHeap(),0,newDevice->props);
543 HeapFree(GetProcessHeap(),0,newDevice);
544 *pdev = 0;
545
546 return hr;
547 }
548
549 /******************************************************************************
550 * get_joystick_index : Get the joystick index from a given GUID
551 */
552 static unsigned short get_joystick_index(REFGUID guid)
553 {
554 GUID wine_joystick = DInput_Wine_Joystick_GUID;
555 GUID dev_guid = *guid;
556
557 wine_joystick.Data3 = 0;
558 dev_guid.Data3 = 0;
559
560 /* for the standard joystick GUID use index 0 */
561 if(IsEqualGUID(&GUID_Joystick,guid)) return 0;
562
563 /* for the wine joystick GUIDs use the index stored in Data3 */
564 if(IsEqualGUID(&wine_joystick, &dev_guid)) return guid->Data3;
565
566 return MAX_JOYSTICKS;
567 }
568
569 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
570 {
571 unsigned short index;
572
573 TRACE("%p %s %p %p\n",dinput, debugstr_guid(rguid), riid, pdev);
574 find_joystick_devices();
575 *pdev = NULL;
576
577 if ((index = get_joystick_index(rguid)) < MAX_JOYSTICKS &&
578 joystick_devices_count && index < joystick_devices_count)
579 {
580 if ((riid == NULL) ||
581 IsEqualGUID(&IID_IDirectInputDeviceA, riid) ||
582 IsEqualGUID(&IID_IDirectInputDevice2A, riid) ||
583 IsEqualGUID(&IID_IDirectInputDevice7A, riid) ||
584 IsEqualGUID(&IID_IDirectInputDevice8A, riid))
585 {
586 return alloc_device(rguid, &JoystickAvt, dinput, pdev, index);
587 }
588
589 WARN("no interface\n");
590 return DIERR_NOINTERFACE;
591 }
592
593 return DIERR_DEVICENOTREG;
594 }
595
596 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
597 {
598 unsigned short index;
599
600 TRACE("%p %s %p %p\n",dinput, debugstr_guid(rguid), riid, pdev);
601 find_joystick_devices();
602 *pdev = NULL;
603
604 if ((index = get_joystick_index(rguid)) < MAX_JOYSTICKS &&
605 joystick_devices_count && index < joystick_devices_count)
606 {
607 if ((riid == NULL) ||
608 IsEqualGUID(&IID_IDirectInputDeviceW, riid) ||
609 IsEqualGUID(&IID_IDirectInputDevice2W, riid) ||
610 IsEqualGUID(&IID_IDirectInputDevice7W, riid) ||
611 IsEqualGUID(&IID_IDirectInputDevice8W, riid))
612 {
613 return alloc_device(rguid, &JoystickWvt, dinput, (LPDIRECTINPUTDEVICEA *)pdev, index);
614 }
615 WARN("no interface\n");
616 return DIERR_NOINTERFACE;
617 }
618
619 WARN("invalid device GUID %s\n",debugstr_guid(rguid));
620 return DIERR_DEVICENOTREG;
621 }
622
623 #undef MAX_JOYSTICKS
624
625 const struct dinput_device joystick_linux_device = {
626 "Wine Linux joystick driver",
627 joydev_enum_deviceA,
628 joydev_enum_deviceW,
629 joydev_create_deviceA,
630 joydev_create_deviceW
631 };
632
633 /******************************************************************************
634 * Acquire : gets exclusive control of the joystick
635 */
636 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
637 {
638 JoystickImpl *This = (JoystickImpl *)iface;
639
640 TRACE("(%p)\n",This);
641
642 if (This->base.acquired) {
643 WARN("already acquired\n");
644 return S_FALSE;
645 }
646
647 /* open the joystick device */
648 if (This->joyfd==-1) {
649 TRACE("opening joystick device %s\n", This->dev);
650
651 This->joyfd=open(This->dev,O_RDONLY);
652 if (This->joyfd==-1) {
653 ERR("open(%s) failed: %s\n", This->dev, strerror(errno));
654 return DIERR_NOTFOUND;
655 }
656 }
657
658 This->base.acquired = 1;
659
660 return DI_OK;
661 }
662
663 /******************************************************************************
664 * Unacquire : frees the joystick
665 */
666 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
667 {
668 JoystickImpl *This = (JoystickImpl *)iface;
669 HRESULT res;
670
671 TRACE("(%p)\n",This);
672
673 if ((res = IDirectInputDevice2AImpl_Unacquire(iface)) != DI_OK) return res;
674
675 if (This->joyfd!=-1) {
676 TRACE("closing joystick device\n");
677 close(This->joyfd);
678 This->joyfd = -1;
679 return DI_OK;
680 }
681
682 return DI_NOEFFECT;
683 }
684
685 static void joy_polldev(JoystickImpl *This) {
686 struct pollfd plfd;
687 struct js_event jse;
688 TRACE("(%p)\n", This);
689
690 if (This->joyfd==-1) {
691 WARN("no device\n");
692 return;
693 }
694 while (1)
695 {
696 LONG value;
697 int inst_id = -1;
698
699 plfd.fd = This->joyfd;
700 plfd.events = POLLIN;
701 if (poll(&plfd,1,0) != 1)
702 return;
703 /* we have one event, so we can read */
704 if (sizeof(jse)!=read(This->joyfd,&jse,sizeof(jse))) {
705 return;
706 }
707 TRACE("js_event: type 0x%x, number %d, value %d\n",
708 jse.type,jse.number,jse.value);
709 if (jse.type & JS_EVENT_BUTTON)
710 {
711 inst_id = DIDFT_MAKEINSTANCE(jse.number) | DIDFT_PSHBUTTON;
712 This->js.rgbButtons[jse.number] = value = jse.value ? 0x80 : 0x00;
713 }
714 else if (jse.type & JS_EVENT_AXIS)
715 {
716 int number = This->axis_map[jse.number]; /* wine format object index */
717
718 if (number < 0) return;
719 inst_id = DIDFT_MAKEINSTANCE(number) | (number < 8 ? DIDFT_ABSAXIS : DIDFT_POV);
720 value = joystick_map_axis(&This->props[id_to_object(This->base.data_format.wine_df, inst_id)], jse.value);
721
722 TRACE("changing axis %d => %d\n", jse.number, number);
723 switch (number)
724 {
725 case 0: This->js.lX = value; break;
726 case 1: This->js.lY = value; break;
727 case 2: This->js.lZ = value; break;
728 case 3: This->js.lRx = value; break;
729 case 4: This->js.lRy = value; break;
730 case 5: This->js.lRz = value; break;
731 case 6: This->js.rglSlider[0] = value; break;
732 case 7: This->js.rglSlider[1] = value; break;
733 case 8: case 9: case 10: case 11:
734 {
735 int idx = number - 8;
736
737 if (jse.number % 2)
738 This->povs[idx].y = jse.value;
739 else
740 This->povs[idx].x = jse.value;
741
742 This->js.rgdwPOV[idx] = value = joystick_map_pov(&This->povs[idx]);
743 break;
744 }
745 default:
746 WARN("axis %d not supported\n", number);
747 }
748 }
749 if (inst_id >= 0)
750 queue_event((LPDIRECTINPUTDEVICE8A)This,
751 id_to_offset(&This->base.data_format, inst_id),
752 value, jse.time, This->base.dinput->evsequence++);
753 }
754 }
755
756 /******************************************************************************
757 * GetDeviceState : returns the "state" of the joystick.
758 *
759 */
760 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
761 LPDIRECTINPUTDEVICE8A iface,
762 DWORD len,
763 LPVOID ptr)
764 {
765 JoystickImpl *This = (JoystickImpl *)iface;
766
767 TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
768
769 if (!This->base.acquired) {
770 WARN("not acquired\n");
771 return DIERR_NOTACQUIRED;
772 }
773
774 /* update joystick state */
775 joy_polldev(This);
776
777 /* convert and copy data to user supplied buffer */
778 fill_DataFormat(ptr, &This->js, &This->base.data_format);
779
780 return DI_OK;
781 }
782
783 /******************************************************************************
784 * SetProperty : change input device properties
785 */
786 static HRESULT WINAPI JoystickAImpl_SetProperty(
787 LPDIRECTINPUTDEVICE8A iface,
788 REFGUID rguid,
789 LPCDIPROPHEADER ph)
790 {
791 JoystickImpl *This = (JoystickImpl *)iface;
792 int i;
793
794 TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
795
796 if (ph == NULL) {
797 WARN("invalid parameter: ph == NULL\n");
798 return DIERR_INVALIDPARAM;
799 }
800
801 if (TRACE_ON(dinput))
802 _dump_DIPROPHEADER(ph);
803
804 if (!HIWORD(rguid)) {
805 switch (LOWORD(rguid)) {
806 case (DWORD)DIPROP_RANGE: {
807 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
808 if (ph->dwHow == DIPH_DEVICE) {
809 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
810 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
811 This->props[i].lMin = pr->lMin;
812 This->props[i].lMax = pr->lMax;
813 }
814 } else {
815 int obj = find_property(&This->base.data_format, ph);
816
817 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
818 if (obj >= 0) {
819 This->props[obj].lMin = pr->lMin;
820 This->props[obj].lMax = pr->lMax;
821 return DI_OK;
822 }
823 }
824 break;
825 }
826 case (DWORD)DIPROP_DEADZONE: {
827 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
828 if (ph->dwHow == DIPH_DEVICE) {
829 TRACE("deadzone(%d) all\n", pd->dwData);
830 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
831 This->props[i].lDeadZone = pd->dwData;
832 } else {
833 int obj = find_property(&This->base.data_format, ph);
834
835 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
836 if (obj >= 0) {
837 This->props[obj].lDeadZone = pd->dwData;
838 return DI_OK;
839 }
840 }
841 break;
842 }
843 case (DWORD)DIPROP_SATURATION: {
844 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
845 if (ph->dwHow == DIPH_DEVICE) {
846 TRACE("saturation(%d) all\n", pd->dwData);
847 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
848 This->props[i].lSaturation = pd->dwData;
849 } else {
850 int obj = find_property(&This->base.data_format, ph);
851
852 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
853 if (obj >= 0) {
854 This->props[obj].lSaturation = pd->dwData;
855 return DI_OK;
856 }
857 }
858 break;
859 }
860 default:
861 return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
862 }
863 }
864
865 return DI_OK;
866 }
867
868 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
869 LPDIRECTINPUTDEVICE8A iface,
870 LPDIDEVCAPS lpDIDevCaps)
871 {
872 JoystickImpl *This = (JoystickImpl *)iface;
873 int size;
874
875 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
876
877 if (lpDIDevCaps == NULL) {
878 WARN("invalid pointer\n");
879 return E_POINTER;
880 }
881
882 size = lpDIDevCaps->dwSize;
883
884 if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
885 WARN("invalid parameter\n");
886 return DIERR_INVALIDPARAM;
887 }
888
889 CopyMemory(lpDIDevCaps, &This->devcaps, size);
890 lpDIDevCaps->dwSize = size;
891
892 if (TRACE_ON(dinput))
893 _dump_DIDEVCAPS(lpDIDevCaps);
894
895 return DI_OK;
896 }
897
898 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
899 {
900 JoystickImpl *This = (JoystickImpl *)iface;
901
902 TRACE("(%p)\n",This);
903
904 if (!This->base.acquired) {
905 WARN("not acquired\n");
906 return DIERR_NOTACQUIRED;
907 }
908
909 joy_polldev(This);
910 return DI_OK;
911 }
912
913 /******************************************************************************
914 * GetProperty : get input device properties
915 */
916 static HRESULT WINAPI JoystickAImpl_GetProperty(
917 LPDIRECTINPUTDEVICE8A iface,
918 REFGUID rguid,
919 LPDIPROPHEADER pdiph)
920 {
921 JoystickImpl *This = (JoystickImpl *)iface;
922
923 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
924
925 if (TRACE_ON(dinput))
926 _dump_DIPROPHEADER(pdiph);
927
928 if (!HIWORD(rguid)) {
929 switch (LOWORD(rguid)) {
930 case (DWORD) DIPROP_RANGE: {
931 LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
932 int obj = find_property(&This->base.data_format, pdiph);
933
934 /* The app is querying the current range of the axis
935 * return the lMin and lMax values */
936 if (obj >= 0) {
937 pr->lMin = This->props[obj].lMin;
938 pr->lMax = This->props[obj].lMax;
939 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
940 return DI_OK;
941 }
942 break;
943 }
944 case (DWORD) DIPROP_DEADZONE: {
945 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
946 int obj = find_property(&This->base.data_format, pdiph);
947
948 if (obj >= 0) {
949 pd->dwData = This->props[obj].lDeadZone;
950 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
951 return DI_OK;
952 }
953 break;
954 }
955 case (DWORD) DIPROP_SATURATION: {
956 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
957 int obj = find_property(&This->base.data_format, pdiph);
958
959 if (obj >= 0) {
960 pd->dwData = This->props[obj].lSaturation;
961 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
962 return DI_OK;
963 }
964 break;
965 }
966 default:
967 return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
968 }
969 }
970
971 return DI_OK;
972 }
973
974 /******************************************************************************
975 * GetObjectInfo : get object info
976 */
977 static HRESULT WINAPI JoystickWImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
978 LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
979 {
980 static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
981 static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
982 static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
983 HRESULT res;
984
985 res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
986 if (res != DI_OK) return res;
987
988 if (pdidoi->dwType & DIDFT_AXIS)
989 sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
990 else if (pdidoi->dwType & DIDFT_POV)
991 sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
992 else if (pdidoi->dwType & DIDFT_BUTTON)
993 sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
994
995 _dump_OBJECTINSTANCEW(pdidoi);
996 return res;
997 }
998
999 static HRESULT WINAPI JoystickAImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
1000 LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
1001 {
1002 HRESULT res;
1003 DIDEVICEOBJECTINSTANCEW didoiW;
1004 DWORD dwSize = pdidoi->dwSize;
1005
1006 didoiW.dwSize = sizeof(didoiW);
1007 res = JoystickWImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W)iface, &didoiW, dwObj, dwHow);
1008 if (res != DI_OK) return res;
1009
1010 memset(pdidoi, 0, pdidoi->dwSize);
1011 memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
1012 pdidoi->dwSize = dwSize;
1013 WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
1014 sizeof(pdidoi->tszName), NULL, NULL);
1015
1016 return res;
1017 }
1018
1019 /******************************************************************************
1020 * GetDeviceInfo : get information about a device's identity
1021 */
1022 static HRESULT WINAPI JoystickAImpl_GetDeviceInfo(
1023 LPDIRECTINPUTDEVICE8A iface,
1024 LPDIDEVICEINSTANCEA pdidi)
1025 {
1026 JoystickImpl *This = (JoystickImpl *)iface;
1027
1028 TRACE("(%p,%p)\n", iface, pdidi);
1029
1030 if (pdidi == NULL) {
1031 WARN("invalid pointer\n");
1032 return E_POINTER;
1033 }
1034
1035 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
1036 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
1037 WARN("invalid parameter: pdidi->dwSize = %d != %d or %d\n",
1038 pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3A),
1039 sizeof(DIDEVICEINSTANCEA));
1040 return DIERR_INVALIDPARAM;
1041 }
1042
1043 /* Return joystick */
1044 pdidi->guidInstance = GUID_Joystick;
1045 pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1046 /* we only support traditional joysticks for now */
1047 pdidi->dwDevType = This->devcaps.dwDevType;
1048 strcpy(pdidi->tszInstanceName, "Joystick");
1049 strcpy(pdidi->tszProductName, This->name);
1050 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
1051 pdidi->guidFFDriver = GUID_NULL;
1052 pdidi->wUsagePage = 0;
1053 pdidi->wUsage = 0;
1054 }
1055
1056 return DI_OK;
1057 }
1058
1059 /******************************************************************************
1060 * GetDeviceInfo : get information about a device's identity
1061 */
1062 static HRESULT WINAPI JoystickWImpl_GetDeviceInfo(
1063 LPDIRECTINPUTDEVICE8W iface,
1064 LPDIDEVICEINSTANCEW pdidi)
1065 {
1066 JoystickImpl *This = (JoystickImpl *)iface;
1067
1068 TRACE("(%p,%p)\n", iface, pdidi);
1069
1070 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
1071 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
1072 WARN("invalid parameter: pdidi->dwSize = %d != %d or %d\n",
1073 pdidi->dwSize, sizeof(DIDEVICEINSTANCE_DX3W),
1074 sizeof(DIDEVICEINSTANCEW));
1075 return DIERR_INVALIDPARAM;
1076 }
1077
1078 /* Return joystick */
1079 pdidi->guidInstance = GUID_Joystick;
1080 pdidi->guidProduct = DInput_Wine_Joystick_GUID;
1081 /* we only support traditional joysticks for now */
1082 pdidi->dwDevType = This->devcaps.dwDevType;
1083 MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
1084 MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
1085 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
1086 pdidi->guidFFDriver = GUID_NULL;
1087 pdidi->wUsagePage = 0;
1088 pdidi->wUsage = 0;
1089 }
1090
1091 return DI_OK;
1092 }
1093
1094 static const IDirectInputDevice8AVtbl JoystickAvt =
1095 {
1096 IDirectInputDevice2AImpl_QueryInterface,
1097 IDirectInputDevice2AImpl_AddRef,
1098 IDirectInputDevice2AImpl_Release,
1099 JoystickAImpl_GetCapabilities,
1100 IDirectInputDevice2AImpl_EnumObjects,
1101 JoystickAImpl_GetProperty,
1102 JoystickAImpl_SetProperty,
1103 JoystickAImpl_Acquire,
1104 JoystickAImpl_Unacquire,
1105 JoystickAImpl_GetDeviceState,
1106 IDirectInputDevice2AImpl_GetDeviceData,
1107 IDirectInputDevice2AImpl_SetDataFormat,
1108 IDirectInputDevice2AImpl_SetEventNotification,
1109 IDirectInputDevice2AImpl_SetCooperativeLevel,
1110 JoystickAImpl_GetObjectInfo,
1111 JoystickAImpl_GetDeviceInfo,
1112 IDirectInputDevice2AImpl_RunControlPanel,
1113 IDirectInputDevice2AImpl_Initialize,
1114 IDirectInputDevice2AImpl_CreateEffect,
1115 IDirectInputDevice2AImpl_EnumEffects,
1116 IDirectInputDevice2AImpl_GetEffectInfo,
1117 IDirectInputDevice2AImpl_GetForceFeedbackState,
1118 IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1119 IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1120 IDirectInputDevice2AImpl_Escape,
1121 JoystickAImpl_Poll,
1122 IDirectInputDevice2AImpl_SendDeviceData,
1123 IDirectInputDevice7AImpl_EnumEffectsInFile,
1124 IDirectInputDevice7AImpl_WriteEffectToFile,
1125 IDirectInputDevice8AImpl_BuildActionMap,
1126 IDirectInputDevice8AImpl_SetActionMap,
1127 IDirectInputDevice8AImpl_GetImageInfo
1128 };
1129
1130 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1131 # define XCAST(fun) (typeof(JoystickWvt.fun))
1132 #else
1133 # define XCAST(fun) (void*)
1134 #endif
1135
1136 static const IDirectInputDevice8WVtbl JoystickWvt =
1137 {
1138 IDirectInputDevice2WImpl_QueryInterface,
1139 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1140 XCAST(Release)IDirectInputDevice2AImpl_Release,
1141 XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1142 IDirectInputDevice2WImpl_EnumObjects,
1143 XCAST(GetProperty)JoystickAImpl_GetProperty,
1144 XCAST(SetProperty)JoystickAImpl_SetProperty,
1145 XCAST(Acquire)JoystickAImpl_Acquire,
1146 XCAST(Unacquire)JoystickAImpl_Unacquire,
1147 XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1148 XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
1149 XCAST(SetDataFormat)IDirectInputDevice2AImpl_SetDataFormat,
1150 XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
1151 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1152 IDirectInputDevice2WImpl_GetObjectInfo,
1153 JoystickWImpl_GetDeviceInfo,
1154 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1155 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1156 XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
1157 IDirectInputDevice2WImpl_EnumEffects,
1158 IDirectInputDevice2WImpl_GetEffectInfo,
1159 XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
1160 XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1161 XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1162 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1163 XCAST(Poll)JoystickAImpl_Poll,
1164 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1165 IDirectInputDevice7WImpl_EnumEffectsInFile,
1166 IDirectInputDevice7WImpl_WriteEffectToFile,
1167 IDirectInputDevice8WImpl_BuildActionMap,
1168 IDirectInputDevice8WImpl_SetActionMap,
1169 IDirectInputDevice8WImpl_GetImageInfo
1170 };
1171 #undef XCAST
1172
1173 #else /* HAVE_LINUX_22_JOYSTICK_API */
1174
1175 const struct dinput_device joystick_linux_device = {
1176 "Wine Linux joystick driver",
1177 NULL,
1178 NULL,
1179 NULL,
1180 NULL
1181 };
1182
1183 #endif /* HAVE_LINUX_22_JOYSTICK_API */
GSOC 2012 project to enhance the control panel