?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dinput: On Unacquire, stop all effects and unload them.
[wine.git] / dlls / dinput / joystick_linuxinput.c
blobda2d0bca25bd690949e7628656ca9fa0cb5fb468
1 /* DirectInput Joystick device
2 *
3 * Copyright 1998,2000 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2005 Daniel Remenak
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <time.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34 #ifdef HAVE_SYS_TIME_H
35 # include <sys/time.h>
36 #endif
37 #include <fcntl.h>
38 #ifdef HAVE_SYS_IOCTL_H
39 # include <sys/ioctl.h>
40 #endif
41 #include <errno.h>
42 #ifdef HAVE_SYS_ERRNO_H
43 # include <sys/errno.h>
44 #endif
45 #ifdef HAVE_LINUX_INPUT_H
46 # include <linux/input.h>
47 # undef SW_MAX
48 # if defined(EVIOCGBIT) && defined(EV_ABS) && defined(BTN_PINKIE)
49 # define HAVE_CORRECT_LINUXINPUT_H
50 # endif
51 #endif
52 #ifdef HAVE_SYS_POLL_H
53 # include <sys/poll.h>
54 #endif
55
56 #include "wine/debug.h"
57 #include "wine/unicode.h"
58 #include "wine/list.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
71 /*
72 * Maps POV x & y event values to a DX "clock" position:
73 * 0
74 * 31500 4500
75 * 27000 -1 9000
76 * 22500 13500
77 * 18000
78 */
79 DWORD joystick_map_pov(POINTL *p)
80 {
81 if (p->x > 0)
82 return p->y < 0 ? 4500 : !p->y ? 9000 : 13500;
83 else if (p->x < 0)
84 return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
85 else
86 return p->y < 0 ? 0 : !p->y ? -1 : 18000;
87 }
88
89 /*
90 * This maps the read value (from the input event) to a value in the
91 * 'wanted' range.
92 * Notes:
93 * Dead zone is in % multiplied by a 100 (range 0..10000)
94 */
95 LONG joystick_map_axis(ObjProps *props, int val)
96 {
97 LONG ret;
98 LONG dead_zone = MulDiv( props->lDeadZone, props->lDevMax - props->lDevMin, 10000 );
99 LONG dev_range = props->lDevMax - props->lDevMin - dead_zone;
100
101 /* Center input */
102 val -= (props->lDevMin + props->lDevMax) / 2;
103
104 /* Remove dead zone */
105 if (abs( val ) <= dead_zone / 2)
106 val = 0;
107 else
108 val = val < 0 ? val + dead_zone / 2 : val - dead_zone / 2;
109
110 /* Scale and map the value from the device range into the required range */
111 ret = MulDiv( val, props->lMax - props->lMin, dev_range ) +
112 (props->lMin + props->lMax) / 2;
113
114 /* Clamp in case or rounding errors */
115 if (ret > props->lMax) ret = props->lMax;
116 else if (ret < props->lMin) ret = props->lMin;
117
118 TRACE( "(%d <%d> %d) -> (%d <%d> %d): val=%d ret=%d\n",
119 props->lDevMin, dead_zone, props->lDevMax,
120 props->lMin, props->lDeadZone, props->lMax,
121 val, ret );
122
123 return ret;
124 }
125
126 #ifdef HAVE_CORRECT_LINUXINPUT_H
127
128 #define EVDEVPREFIX "/dev/input/event"
129
130 /* Wine joystick driver object instances */
131 #define WINE_JOYSTICK_MAX_AXES 8
132 #define WINE_JOYSTICK_MAX_POVS 4
133 #define WINE_JOYSTICK_MAX_BUTTONS 128
134
135 struct wine_input_absinfo {
136 LONG value;
137 LONG minimum;
138 LONG maximum;
139 LONG fuzz;
140 LONG flat;
141 };
142
143 /* implemented in effect_linuxinput.c */
144 HRESULT linuxinput_create_effect(int* fd, REFGUID rguid, struct list *parent_list_entry, LPDIRECTINPUTEFFECT* peff);
145 HRESULT linuxinput_get_info_A(int fd, REFGUID rguid, LPDIEFFECTINFOA info);
146 HRESULT linuxinput_get_info_W(int fd, REFGUID rguid, LPDIEFFECTINFOW info);
147
148 typedef struct JoystickImpl JoystickImpl;
149 static const IDirectInputDevice8AVtbl JoystickAvt;
150 static const IDirectInputDevice8WVtbl JoystickWvt;
151
152 struct JoyDev {
153 char *device;
154 char *name;
155 GUID guid;
156
157 int has_ff;
158 int num_effects;
159
160 /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
161 BYTE evbits[(EV_MAX+7)/8];
162 BYTE absbits[(ABS_MAX+7)/8];
163 BYTE keybits[(KEY_MAX+7)/8];
164 BYTE ffbits[(FF_MAX+7)/8];
165
166 /* data returned by the EVIOCGABS() ioctl */
167 struct wine_input_absinfo axes[ABS_MAX];
168 };
169
170 struct JoystickImpl
171 {
172 struct IDirectInputDevice2AImpl base;
173
174 struct JoyDev *joydev;
175
176 /* joystick private */
177 int joyfd;
178
179 DIJOYSTATE2 js;
180
181 ObjProps props[ABS_MAX];
182
183 int axes[ABS_MAX];
184 POINTL povs[4];
185
186 /* LUT for KEY_ to offset in rgbButtons */
187 BYTE buttons[KEY_MAX];
188
189 DWORD numAxes;
190 DWORD numPOVs;
191 DWORD numButtons;
192
193 /* Force feedback variables */
194 struct list ff_effects;
195 int ff_state;
196 };
197
198 static void fake_current_js_state(JoystickImpl *ji);
199 static void find_joydevs(void);
200
201 /* This GUID is slightly different from the linux joystick one. Take note. */
202 static const GUID DInput_Wine_Joystick_Base_GUID = { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
203 0x9e573eda,
204 0x7734,
205 0x11d2,
206 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
207 };
208
209 #define test_bit(arr,bit) (((BYTE*)(arr))[(bit)>>3]&(1<<((bit)&7)))
210
211 #define MAX_JOYDEV 64
212
213 static int have_joydevs = -1;
214 static struct JoyDev *joydevs = NULL;
215
216 static void find_joydevs(void)
217 {
218 int i;
219
220 if (InterlockedCompareExchange(&have_joydevs, 0, -1) != -1)
221 /* Someone beat us to it */
222 return;
223
224 for (i = 0; i < MAX_JOYDEV; i++)
225 {
226 char buf[MAX_PATH];
227 struct JoyDev joydev = {0};
228 int fd;
229 int no_ff_check = 0;
230 int j;
231 struct JoyDev *new_joydevs;
232
233 snprintf(buf, sizeof(buf), EVDEVPREFIX"%d", i);
234
235 if ((fd = open(buf, O_RDWR)) == -1)
236 {
237 fd = open(buf, O_RDONLY);
238 no_ff_check = 1;
239 }
240
241 if (fd == -1)
242 {
243 WARN("Failed to open \"%s\": %d %s\n", buf, errno, strerror(errno));
244 continue;
245 }
246
247 if (ioctl(fd, EVIOCGBIT(0, sizeof(joydev.evbits)), joydev.evbits) == -1)
248 {
249 WARN("ioct(EVIOCGBIT, 0) failed: %d %s\n", errno, strerror(errno));
250 close(fd);
251 continue;
252 }
253 if (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(joydev.absbits)), joydev.absbits) == -1)
254 {
255 WARN("ioct(EVIOCGBIT, EV_ABS) failed: %d %s\n", errno, strerror(errno));
256 close(fd);
257 continue;
258 }
259 if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(joydev.keybits)), joydev.keybits) == -1)
260 {
261 WARN("ioct(EVIOCGBIT, EV_KEY) failed: %d %s\n", errno, strerror(errno));
262 close(fd);
263 continue;
264 }
265
266 /* A true joystick has at least axis X and Y, and at least 1
267 * button. copied from linux/drivers/input/joydev.c */
268 if (!test_bit(joydev.absbits, ABS_X) || !test_bit(joydev.absbits, ABS_Y) ||
269 !(test_bit(joydev.keybits, BTN_TRIGGER) ||
270 test_bit(joydev.keybits, BTN_A) ||
271 test_bit(joydev.keybits, BTN_1)))
272 {
273 close(fd);
274 continue;
275 }
276
277 if (!(joydev.device = HeapAlloc(GetProcessHeap(), 0, strlen(buf) + 1)))
278 {
279 close(fd);
280 continue;
281 }
282 strcpy(joydev.device, buf);
283
284 buf[MAX_PATH - 1] = 0;
285 if (ioctl(fd, EVIOCGNAME(MAX_PATH - 1), buf) != -1 &&
286 (joydev.name = HeapAlloc(GetProcessHeap(), 0, strlen(buf) + 1)))
287 strcpy(joydev.name, buf);
288 else
289 joydev.name = joydev.device;
290
291 joydev.guid = DInput_Wine_Joystick_Base_GUID;
292 joydev.guid.Data3 += have_joydevs;
293
294 TRACE("Found a joystick on %s: %s (%s)\n",
295 joydev.device, joydev.name,
296 debugstr_guid(&joydev.guid)
297 );
298
299 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
300 if (!no_ff_check &&
301 test_bit(joydev.evbits, EV_FF) &&
302 ioctl(fd, EVIOCGBIT(EV_FF, sizeof(joydev.ffbits)), joydev.ffbits) != -1 &&
303 ioctl(fd, EVIOCGEFFECTS, &joydev.num_effects) != -1 &&
304 joydev.num_effects > 0)
305 {
306 TRACE(" ... with force feedback\n");
307 joydev.has_ff = 1;
308 }
309 #endif
310
311 for (j = 0; j < ABS_MAX;j ++)
312 {
313 if (!test_bit(joydev.absbits, j)) continue;
314 if (ioctl(fd, EVIOCGABS(j), &(joydev.axes[j])) != -1)
315 {
316 TRACE(" ... with axis %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
317 j,
318 joydev.axes[j].value,
319 joydev.axes[j].minimum,
320 joydev.axes[j].maximum,
321 joydev.axes[j].fuzz,
322 joydev.axes[j].flat
323 );
324 }
325 }
326
327 if (!have_joydevs)
328 new_joydevs = HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev));
329 else
330 new_joydevs = HeapReAlloc(GetProcessHeap(), 0, joydevs, (1 + have_joydevs) * sizeof(struct JoyDev));
331
332 if (!new_joydevs)
333 {
334 close(fd);
335 continue;
336 }
337 joydevs = new_joydevs;
338 memcpy(joydevs + have_joydevs, &joydev, sizeof(joydev));
339 have_joydevs++;
340
341 close(fd);
342 }
343 }
344
345 static void fill_joystick_dideviceinstanceA(LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
346 {
347 DWORD dwSize = lpddi->dwSize;
348
349 TRACE("%d %p\n", dwSize, lpddi);
350 memset(lpddi, 0, dwSize);
351
352 lpddi->dwSize = dwSize;
353 lpddi->guidInstance = joydevs[id].guid;
354 lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
355 lpddi->guidFFDriver = GUID_NULL;
356
357 if (version >= 0x0800)
358 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
359 else
360 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
361
362 strcpy(lpddi->tszInstanceName, joydevs[id].name);
363 strcpy(lpddi->tszProductName, joydevs[id].device);
364 }
365
366 static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
367 {
368 DWORD dwSize = lpddi->dwSize;
369
370 TRACE("%d %p\n", dwSize, lpddi);
371 memset(lpddi, 0, dwSize);
372
373 lpddi->dwSize = dwSize;
374 lpddi->guidInstance = joydevs[id].guid;
375 lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
376 lpddi->guidFFDriver = GUID_NULL;
377
378 if (version >= 0x0800)
379 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
380 else
381 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
382
383 MultiByteToWideChar(CP_ACP, 0, joydevs[id].name, -1, lpddi->tszInstanceName, MAX_PATH);
384 MultiByteToWideChar(CP_ACP, 0, joydevs[id].device, -1, lpddi->tszProductName, MAX_PATH);
385 }
386
387 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
388 {
389 find_joydevs();
390
391 if (id >= have_joydevs) {
392 return FALSE;
393 }
394
395 if (!((dwDevType == 0) ||
396 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
397 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
398 return FALSE;
399
400 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
401 if (dwFlags & DIEDFL_FORCEFEEDBACK)
402 return FALSE;
403 #endif
404
405 if (!(dwFlags & DIEDFL_FORCEFEEDBACK) || joydevs[id].has_ff) {
406 fill_joystick_dideviceinstanceA(lpddi, version, id);
407 return TRUE;
408 }
409 return FALSE;
410 }
411
412 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
413 {
414 find_joydevs();
415
416 if (id >= have_joydevs) {
417 return FALSE;
418 }
419
420 if (!((dwDevType == 0) ||
421 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
422 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
423 return FALSE;
424
425 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
426 if (dwFlags & DIEDFL_FORCEFEEDBACK)
427 return FALSE;
428 #endif
429
430 if (!(dwFlags & DIEDFL_FORCEFEEDBACK) || joydevs[id].has_ff) {
431 fill_joystick_dideviceinstanceW(lpddi, version, id);
432 return TRUE;
433 }
434 return FALSE;
435 }
436
437 static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, unsigned short index)
438 {
439 JoystickImpl* newDevice;
440 LPDIDATAFORMAT df = NULL;
441 int i, idx = 0;
442 char buffer[MAX_PATH+16];
443 HKEY hkey, appkey;
444 LONG def_deadzone = 0;
445
446 newDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(JoystickImpl));
447 if (!newDevice) return NULL;
448
449 newDevice->base.lpVtbl = jvt;
450 newDevice->base.ref = 1;
451 newDevice->base.guid = *rguid;
452 newDevice->base.dinput = dinput;
453 newDevice->joyfd = -1;
454 newDevice->joydev = &joydevs[index];
455 list_init(&newDevice->ff_effects);
456 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
457 newDevice->ff_state = FF_STATUS_STOPPED;
458 #endif
459 InitializeCriticalSection(&newDevice->base.crit);
460 newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit");
461
462 /* get options */
463 get_app_key(&hkey, &appkey);
464
465 if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, MAX_PATH))
466 {
467 def_deadzone = atoi(buffer);
468 TRACE("setting default deadzone to: %d\n", def_deadzone);
469 }
470 if (appkey) RegCloseKey(appkey);
471 if (hkey) RegCloseKey(hkey);
472
473 /* Create copy of default data format */
474 if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto failed;
475 memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
476 if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto failed;
477
478 /* Supported Axis & POVs should map 1-to-1 */
479 for (i = 0; i < WINE_JOYSTICK_MAX_AXES; i++)
480 {
481 if (!test_bit(newDevice->joydev->absbits, i)) {
482 newDevice->axes[i] = -1;
483 continue;
484 }
485
486 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i], df->dwObjSize);
487 newDevice->axes[i] = idx;
488 newDevice->props[idx].lDevMin = newDevice->joydev->axes[i].minimum;
489 newDevice->props[idx].lDevMax = newDevice->joydev->axes[i].maximum;
490 newDevice->props[idx].lMin = 0;
491 newDevice->props[idx].lMax = 0xffff;
492 newDevice->props[idx].lSaturation = 0;
493 newDevice->props[idx].lDeadZone = def_deadzone;
494
495 /* Linux supports force-feedback on X & Y axes only */
496 if (newDevice->joydev->has_ff && (i == 0 || i == 1))
497 df->rgodf[idx].dwFlags |= DIDOI_FFACTUATOR;
498
499 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numAxes++) | DIDFT_ABSAXIS;
500 }
501
502 for (i = 0; i < WINE_JOYSTICK_MAX_POVS; i++)
503 {
504 if (!test_bit(newDevice->joydev->absbits, ABS_HAT0X + i * 2) ||
505 !test_bit(newDevice->joydev->absbits, ABS_HAT0Y + i * 2)) {
506 newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = -1;
507 continue;
508 }
509
510 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + WINE_JOYSTICK_MAX_AXES], df->dwObjSize);
511 newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = i;
512 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numPOVs++) | DIDFT_POV;
513 }
514
515 /* Buttons can be anywhere, so check all */
516 for (i = 0; i < KEY_MAX && newDevice->numButtons < WINE_JOYSTICK_MAX_BUTTONS; i++)
517 {
518 if (!test_bit(newDevice->joydev->keybits, i)) continue;
519
520 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[newDevice->numButtons + WINE_JOYSTICK_MAX_AXES + WINE_JOYSTICK_MAX_POVS], df->dwObjSize);
521 newDevice->buttons[i] = 0x80 | newDevice->numButtons;
522 df->rgodf[idx ].pguid = &GUID_Button;
523 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numButtons++) | DIDFT_PSHBUTTON;
524 }
525 df->dwNumObjs = idx;
526
527 fake_current_js_state(newDevice);
528
529 newDevice->base.data_format.wine_df = df;
530 IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput);
531 return newDevice;
532
533 failed:
534 if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
535 HeapFree(GetProcessHeap(), 0, df);
536 HeapFree(GetProcessHeap(), 0, newDevice);
537 return NULL;
538 }
539
540 /******************************************************************************
541 * get_joystick_index : Get the joystick index from a given GUID
542 */
543 static unsigned short get_joystick_index(REFGUID guid)
544 {
545 GUID wine_joystick = DInput_Wine_Joystick_Base_GUID;
546 GUID dev_guid = *guid;
547
548 wine_joystick.Data3 = 0;
549 dev_guid.Data3 = 0;
550
551 /* for the standard joystick GUID use index 0 */
552 if(IsEqualGUID(&GUID_Joystick,guid)) return 0;
553
554 /* for the wine joystick GUIDs use the index stored in Data3 */
555 if(IsEqualGUID(&wine_joystick, &dev_guid)) return guid->Data3 - DInput_Wine_Joystick_Base_GUID.Data3;
556
557 return MAX_JOYDEV;
558 }
559
560 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
561 {
562 unsigned short index;
563
564 find_joydevs();
565
566 if ((index = get_joystick_index(rguid)) < MAX_JOYDEV &&
567 have_joydevs && index < have_joydevs)
568 {
569 if ((riid == NULL) ||
570 IsEqualGUID(&IID_IDirectInputDeviceA, riid) ||
571 IsEqualGUID(&IID_IDirectInputDevice2A, riid) ||
572 IsEqualGUID(&IID_IDirectInputDevice7A, riid) ||
573 IsEqualGUID(&IID_IDirectInputDevice8A, riid))
574 {
575 *pdev = (IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput, index);
576 TRACE("Created a Joystick device (%p)\n", *pdev);
577
578 if (*pdev == NULL)
579 {
580 ERR("out of memory\n");
581 return DIERR_OUTOFMEMORY;
582 }
583 return DI_OK;
584 }
585
586 WARN("no interface\n");
587 return DIERR_NOINTERFACE;
588 }
589
590 return DIERR_DEVICENOTREG;
591 }
592
593
594 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
595 {
596 unsigned short index;
597
598 find_joydevs();
599
600 if ((index = get_joystick_index(rguid)) < MAX_JOYDEV &&
601 have_joydevs && index < have_joydevs)
602 {
603 if ((riid == NULL) ||
604 IsEqualGUID(&IID_IDirectInputDeviceW, riid) ||
605 IsEqualGUID(&IID_IDirectInputDevice2W, riid) ||
606 IsEqualGUID(&IID_IDirectInputDevice7W, riid) ||
607 IsEqualGUID(&IID_IDirectInputDevice8W, riid))
608 {
609 *pdev = (IDirectInputDeviceW*) alloc_device(rguid, &JoystickWvt, dinput, index);
610 TRACE("Created a Joystick device (%p)\n", *pdev);
611
612 if (*pdev == NULL)
613 {
614 ERR("out of memory\n");
615 return DIERR_OUTOFMEMORY;
616 }
617 return DI_OK;
618 }
619 WARN("no interface\n");
620 return DIERR_NOINTERFACE;
621 }
622
623 WARN("invalid device GUID\n");
624 return DIERR_DEVICENOTREG;
625 }
626
627 const struct dinput_device joystick_linuxinput_device = {
628 "Wine Linux-input joystick driver",
629 joydev_enum_deviceA,
630 joydev_enum_deviceW,
631 joydev_create_deviceA,
632 joydev_create_deviceW
633 };
634
635 /******************************************************************************
636 * Acquire : gets exclusive control of the joystick
637 */
638 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
639 {
640 JoystickImpl *This = (JoystickImpl *)iface;
641 HRESULT res;
642
643 TRACE("(this=%p)\n",This);
644
645 if ((res = IDirectInputDevice2AImpl_Acquire(iface)) != DI_OK)
646 {
647 WARN("Failed to acquire: %x\n", res);
648 return res;
649 }
650
651 if ((This->joyfd = open(This->joydev->device, O_RDWR)) == -1)
652 {
653 if ((This->joyfd = open(This->joydev->device, O_RDONLY)) == -1)
654 {
655 /* Couldn't open the device at all */
656 ERR("Failed to open device %s: %d %s\n", This->joydev->device, errno, strerror(errno));
657 IDirectInputDevice2AImpl_Unacquire(iface);
658 return DIERR_NOTFOUND;
659 }
660 else
661 {
662 /* Couldn't open in r/w but opened in read-only. */
663 WARN("Could not open %s in read-write mode. Force feedback will be disabled.\n", This->joydev->device);
664 }
665 }
666
667 return DI_OK;
668 }
669
670 /******************************************************************************
671 * Unacquire : frees the joystick
672 */
673 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
674 {
675 JoystickImpl *This = (JoystickImpl *)iface;
676 HRESULT res;
677
678 TRACE("(this=%p)\n",This);
679 res = IDirectInputDevice2AImpl_Unacquire(iface);
680 if (res==DI_OK && This->joyfd!=-1) {
681 effect_list_item *itr;
682
683 /* For each known effect:
684 * - stop it
685 * - unload it
686 * But, unlike DISFFC_RESET, do not release the effect.
687 */
688 LIST_FOR_EACH_ENTRY(itr, &This->ff_effects, effect_list_item, entry) {
689 IDirectInputEffect_Stop(itr->ref);
690 IDirectInputEffect_Unload(itr->ref);
691 }
692
693 close(This->joyfd);
694 This->joyfd = -1;
695 }
696 return res;
697 }
698
699 /*
700 * set the current state of the js device as it would be with the middle
701 * values on the axes
702 */
703 #define CENTER_AXIS(a) \
704 (ji->axes[a] == -1 ? 0 : joystick_map_axis( &ji->props[ji->axes[a]], \
705 ji->joydev->axes[a].value ))
706 static void fake_current_js_state(JoystickImpl *ji)
707 {
708 int i;
709
710 /* center the axes */
711 ji->js.lX = CENTER_AXIS(ABS_X);
712 ji->js.lY = CENTER_AXIS(ABS_Y);
713 ji->js.lZ = CENTER_AXIS(ABS_Z);
714 ji->js.lRx = CENTER_AXIS(ABS_RX);
715 ji->js.lRy = CENTER_AXIS(ABS_RY);
716 ji->js.lRz = CENTER_AXIS(ABS_RZ);
717 ji->js.rglSlider[0] = CENTER_AXIS(ABS_THROTTLE);
718 ji->js.rglSlider[1] = CENTER_AXIS(ABS_RUDDER);
719
720 /* POV center is -1 */
721 for (i = 0; i < 4; i++)
722 ji->js.rgdwPOV[i] = -1;
723 }
724 #undef CENTER_AXIS
725
726 /* convert wine format offset to user format object index */
727 static void joy_polldev(JoystickImpl *This)
728 {
729 struct pollfd plfd;
730 struct input_event ie;
731
732 if (This->joyfd==-1)
733 return;
734
735 while (1)
736 {
737 LONG value = 0;
738 int inst_id = -1;
739
740 plfd.fd = This->joyfd;
741 plfd.events = POLLIN;
742
743 if (poll(&plfd,1,0) != 1)
744 return;
745
746 /* we have one event, so we can read */
747 if (sizeof(ie)!=read(This->joyfd,&ie,sizeof(ie)))
748 return;
749
750 TRACE("input_event: type %d, code %d, value %d\n",ie.type,ie.code,ie.value);
751 switch (ie.type) {
752 case EV_KEY: /* button */
753 {
754 int btn = This->buttons[ie.code];
755
756 TRACE("(%p) %d -> %d\n", This, ie.code, btn);
757 if (btn & 0x80)
758 {
759 btn &= 0x7F;
760 inst_id = DIDFT_MAKEINSTANCE(btn) | DIDFT_PSHBUTTON;
761 This->js.rgbButtons[btn] = value = ie.value ? 0x80 : 0x00;
762 }
763 break;
764 }
765 case EV_ABS:
766 {
767 int axis = This->axes[ie.code];
768 if (axis==-1) {
769 break;
770 }
771 inst_id = DIDFT_MAKEINSTANCE(axis) | (ie.code < ABS_HAT0X ? DIDFT_ABSAXIS : DIDFT_POV);
772 value = joystick_map_axis(&This->props[id_to_object(This->base.data_format.wine_df, inst_id)], ie.value);
773
774 switch (ie.code) {
775 case ABS_X: This->js.lX = value; break;
776 case ABS_Y: This->js.lY = value; break;
777 case ABS_Z: This->js.lZ = value; break;
778 case ABS_RX: This->js.lRx = value; break;
779 case ABS_RY: This->js.lRy = value; break;
780 case ABS_RZ: This->js.lRz = value; break;
781 case ABS_THROTTLE: This->js.rglSlider[0] = value; break;
782 case ABS_RUDDER: This->js.rglSlider[1] = value; break;
783 case ABS_HAT0X: case ABS_HAT0Y: case ABS_HAT1X: case ABS_HAT1Y:
784 case ABS_HAT2X: case ABS_HAT2Y: case ABS_HAT3X: case ABS_HAT3Y:
785 {
786 int idx = (ie.code - ABS_HAT0X) / 2;
787
788 if (ie.code % 2)
789 This->povs[idx].y = ie.value;
790 else
791 This->povs[idx].x = ie.value;
792
793 This->js.rgdwPOV[idx] = value = joystick_map_pov(&This->povs[idx]);
794 break;
795 }
796 default:
797 FIXME("unhandled joystick axis event (code %d, value %d)\n",ie.code,ie.value);
798 }
799 break;
800 }
801 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
802 case EV_FF_STATUS:
803 This->ff_state = ie.value;
804 break;
805 #endif
806 #ifdef EV_SYN
807 case EV_SYN:
808 /* there is nothing to do */
809 break;
810 #endif
811 default:
812 FIXME("joystick cannot handle type %d event (code %d)\n",ie.type,ie.code);
813 break;
814 }
815 if (inst_id >= 0)
816 queue_event((LPDIRECTINPUTDEVICE8A)This,
817 id_to_offset(&This->base.data_format, inst_id),
818 value, ie.time.tv_usec, This->base.dinput->evsequence++);
819 }
820 }
821
822 /******************************************************************************
823 * GetDeviceState : returns the "state" of the joystick.
824 *
825 */
826 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
827 LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
828 ) {
829 JoystickImpl *This = (JoystickImpl *)iface;
830
831 TRACE("(this=%p,0x%08x,%p)\n", This, len, ptr);
832
833 if (!This->base.acquired)
834 {
835 WARN("not acquired\n");
836 return DIERR_NOTACQUIRED;
837 }
838
839 joy_polldev(This);
840
841 /* convert and copy data to user supplied buffer */
842 fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
843
844 return DI_OK;
845 }
846
847 /******************************************************************************
848 * SetProperty : change input device properties
849 */
850 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
851 REFGUID rguid,
852 LPCDIPROPHEADER ph)
853 {
854 JoystickImpl *This = (JoystickImpl *)iface;
855
856 if (!ph) {
857 WARN("invalid argument\n");
858 return DIERR_INVALIDPARAM;
859 }
860
861 TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
862 TRACE("ph.dwSize = %d, ph.dwHeaderSize =%d, ph.dwObj = %d, ph.dwHow= %d\n",
863 ph->dwSize, ph->dwHeaderSize, ph->dwObj, ph->dwHow);
864
865 if (!HIWORD(rguid)) {
866 switch (LOWORD(rguid)) {
867 case (DWORD_PTR)DIPROP_RANGE: {
868 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
869
870 if (ph->dwHow == DIPH_DEVICE) {
871 DWORD i;
872 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
873 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
874 /* Scale dead-zone */
875 This->props[i].lDeadZone = MulDiv(This->props[i].lDeadZone, pr->lMax - pr->lMin,
876 This->props[i].lMax - This->props[i].lMin);
877 This->props[i].lMin = pr->lMin;
878 This->props[i].lMax = pr->lMax;
879 }
880 } else {
881 int obj = find_property(&This->base.data_format, ph);
882
883 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
884 if (obj >= 0) {
885 /* Scale dead-zone */
886 This->props[obj].lDeadZone = MulDiv(This->props[obj].lDeadZone, pr->lMax - pr->lMin,
887 This->props[obj].lMax - This->props[obj].lMin);
888 This->props[obj].lMin = pr->lMin;
889 This->props[obj].lMax = pr->lMax;
890 }
891 }
892 fake_current_js_state(This);
893 break;
894 }
895 case (DWORD_PTR)DIPROP_DEADZONE: {
896 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
897 if (ph->dwHow == DIPH_DEVICE) {
898 DWORD i;
899 TRACE("deadzone(%d) all\n", pd->dwData);
900 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
901 This->props[i].lDeadZone = pd->dwData;
902 }
903 } else {
904 int obj = find_property(&This->base.data_format, ph);
905
906 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
907 if (obj >= 0) {
908 This->props[obj].lDeadZone = pd->dwData;
909 }
910 }
911 fake_current_js_state(This);
912 break;
913 }
914 case (DWORD_PTR)DIPROP_CALIBRATIONMODE: {
915 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
916 FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd->dwData);
917 break;
918 }
919 case (DWORD_PTR)DIPROP_AUTOCENTER: {
920 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
921
922 FIXME("DIPROP_AUTOCENTER(%d)\n", pd->dwData);
923 break;
924 }
925 case (DWORD_PTR)DIPROP_SATURATION: {
926 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
927
928 if (ph->dwHow == DIPH_DEVICE) {
929 DWORD i;
930
931 TRACE("saturation(%d) all\n", pd->dwData);
932 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
933 This->props[i].lSaturation = pd->dwData;
934 } else {
935 int obj = find_property(&This->base.data_format, ph);
936
937 if (obj < 0) return DIERR_OBJECTNOTFOUND;
938
939 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
940 This->props[obj].lSaturation = pd->dwData;
941 }
942 fake_current_js_state(This);
943 break;
944 }
945 default:
946 return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
947 }
948 }
949 return DI_OK;
950 }
951
952 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
953 LPDIRECTINPUTDEVICE8A iface,
954 LPDIDEVCAPS lpDIDevCaps)
955 {
956 JoystickImpl *This = (JoystickImpl *)iface;
957
958 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
959
960 if (!lpDIDevCaps) {
961 WARN("invalid pointer\n");
962 return E_POINTER;
963 }
964
965 if (lpDIDevCaps->dwSize != sizeof(DIDEVCAPS)) {
966 WARN("invalid argument\n");
967 return DIERR_INVALIDPARAM;
968 }
969
970 lpDIDevCaps->dwFlags = DIDC_ATTACHED;
971 if (This->base.dinput->dwVersion >= 0x0800)
972 lpDIDevCaps->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
973 else
974 lpDIDevCaps->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
975
976 if (This->joydev->has_ff)
977 lpDIDevCaps->dwFlags |= DIDC_FORCEFEEDBACK;
978
979 lpDIDevCaps->dwAxes = This->numAxes;
980 lpDIDevCaps->dwButtons = This->numButtons;
981 lpDIDevCaps->dwPOVs = This->numPOVs;
982
983 return DI_OK;
984 }
985
986 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
987 {
988 JoystickImpl *This = (JoystickImpl *)iface;
989
990 TRACE("(%p)\n",This);
991
992 if (!This->base.acquired)
993 return DIERR_NOTACQUIRED;
994
995 joy_polldev(This);
996 return DI_OK;
997 }
998
999 /******************************************************************************
1000 * GetProperty : get input device properties
1001 */
1002 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
1003 REFGUID rguid,
1004 LPDIPROPHEADER pdiph)
1005 {
1006 JoystickImpl *This = (JoystickImpl *)iface;
1007
1008 TRACE("(this=%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
1009 _dump_DIPROPHEADER(pdiph);
1010
1011 if (HIWORD(rguid)) return DI_OK;
1012
1013 switch (LOWORD(rguid)) {
1014 case (DWORD_PTR) DIPROP_RANGE:
1015 {
1016 LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
1017 int obj = find_property(&This->base.data_format, pdiph);
1018
1019 if (obj < 0) return DIERR_OBJECTNOTFOUND;
1020
1021 pr->lMin = This->props[obj].lMin;
1022 pr->lMax = This->props[obj].lMax;
1023 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
1024 break;
1025 }
1026 case (DWORD_PTR) DIPROP_DEADZONE:
1027 {
1028 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1029 int obj = find_property(&This->base.data_format, pdiph);
1030
1031 if (obj < 0) return DIERR_OBJECTNOTFOUND;
1032
1033 pd->dwData = This->props[obj].lDeadZone;
1034 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
1035 break;
1036 }
1037 case (DWORD_PTR) DIPROP_SATURATION:
1038 {
1039 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
1040 int obj = find_property(&This->base.data_format, pdiph);
1041
1042 if (obj < 0) return DIERR_OBJECTNOTFOUND;
1043
1044 pd->dwData = This->props[obj].lSaturation;
1045 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
1046 break;
1047 }
1048
1049 default:
1050 return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
1051 }
1052
1053 return DI_OK;
1054 }
1055
1056 /******************************************************************************
1057 * GetObjectInfo : get information about a device object such as a button
1058 * or axis
1059 */
1060 static HRESULT WINAPI JoystickWImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
1061 LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
1062 {
1063 static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
1064 static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
1065 static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
1066 HRESULT res;
1067
1068 res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
1069 if (res != DI_OK) return res;
1070
1071 if (pdidoi->dwType & DIDFT_AXIS)
1072 sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
1073 else if (pdidoi->dwType & DIDFT_POV)
1074 sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
1075 else if (pdidoi->dwType & DIDFT_BUTTON)
1076 sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
1077
1078 _dump_OBJECTINSTANCEW(pdidoi);
1079 return res;
1080 }
1081
1082 static HRESULT WINAPI JoystickAImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
1083 LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
1084 {
1085 HRESULT res;
1086 DIDEVICEOBJECTINSTANCEW didoiW;
1087 DWORD dwSize = pdidoi->dwSize;
1088
1089 didoiW.dwSize = sizeof(didoiW);
1090 res = JoystickWImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W)iface, &didoiW, dwObj, dwHow);
1091 if (res != DI_OK) return res;
1092
1093 memset(pdidoi, 0, pdidoi->dwSize);
1094 memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
1095 pdidoi->dwSize = dwSize;
1096 WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
1097 sizeof(pdidoi->tszName), NULL, NULL);
1098
1099 return res;
1100 }
1101
1102 /******************************************************************************
1103 * CreateEffect - Create a new FF effect with the specified params
1104 */
1105 static HRESULT WINAPI JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface,
1106 REFGUID rguid,
1107 LPCDIEFFECT lpeff,
1108 LPDIRECTINPUTEFFECT *ppdef,
1109 LPUNKNOWN pUnkOuter)
1110 {
1111 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1112 effect_list_item* new_effect = NULL;
1113 HRESULT retval = DI_OK;
1114 #endif
1115
1116 JoystickImpl* This = (JoystickImpl*)iface;
1117 TRACE("(this=%p,%p,%p,%p,%p)\n", This, rguid, lpeff, ppdef, pUnkOuter);
1118
1119 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
1120 TRACE("not available (compiled w/o ff support)\n");
1121 *ppdef = NULL;
1122 return DI_OK;
1123 #else
1124
1125 if (!(new_effect = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_effect))))
1126 return DIERR_OUTOFMEMORY;
1127
1128 retval = linuxinput_create_effect(&This->joyfd, rguid, &new_effect->entry, &new_effect->ref);
1129 if (retval != DI_OK)
1130 {
1131 HeapFree(GetProcessHeap(), 0, new_effect);
1132 return retval;
1133 }
1134
1135 if (lpeff != NULL)
1136 {
1137 retval = IDirectInputEffect_SetParameters(new_effect->ref, lpeff, 0);
1138
1139 if (retval != DI_OK && retval != DI_DOWNLOADSKIPPED)
1140 {
1141 HeapFree(GetProcessHeap(), 0, new_effect);
1142 return retval;
1143 }
1144 }
1145
1146 list_add_tail(&This->ff_effects, &new_effect->entry);
1147 *ppdef = new_effect->ref;
1148
1149 if (pUnkOuter != NULL)
1150 FIXME("Interface aggregation not implemented.\n");
1151
1152 return DI_OK;
1153
1154 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1155 }
1156
1157 /*******************************************************************************
1158 * EnumEffects - Enumerate available FF effects
1159 */
1160 static HRESULT WINAPI JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface,
1161 LPDIENUMEFFECTSCALLBACKA lpCallback,
1162 LPVOID pvRef,
1163 DWORD dwEffType)
1164 {
1165 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1166 DIEFFECTINFOA dei; /* feif */
1167 DWORD type = DIEFT_GETTYPE(dwEffType);
1168 JoystickImpl* This = (JoystickImpl*)iface;
1169
1170 TRACE("(this=%p,%p,%d) type=%d\n", This, pvRef, dwEffType, type);
1171
1172 dei.dwSize = sizeof(DIEFFECTINFOA);
1173
1174 if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1175 && test_bit(This->joydev->ffbits, FF_CONSTANT)) {
1176 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1177 (*lpCallback)(&dei, pvRef);
1178 }
1179
1180 if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1181 && test_bit(This->joydev->ffbits, FF_PERIODIC)) {
1182 if (test_bit(This->joydev->ffbits, FF_SQUARE)) {
1183 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Square);
1184 (*lpCallback)(&dei, pvRef);
1185 }
1186 if (test_bit(This->joydev->ffbits, FF_SINE)) {
1187 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Sine);
1188 (*lpCallback)(&dei, pvRef);
1189 }
1190 if (test_bit(This->joydev->ffbits, FF_TRIANGLE)) {
1191 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Triangle);
1192 (*lpCallback)(&dei, pvRef);
1193 }
1194 if (test_bit(This->joydev->ffbits, FF_SAW_UP)) {
1195 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1196 (*lpCallback)(&dei, pvRef);
1197 }
1198 if (test_bit(This->joydev->ffbits, FF_SAW_DOWN)) {
1199 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1200 (*lpCallback)(&dei, pvRef);
1201 }
1202 }
1203
1204 if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1205 && test_bit(This->joydev->ffbits, FF_RAMP)) {
1206 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_RampForce);
1207 (*lpCallback)(&dei, pvRef);
1208 }
1209
1210 if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1211 if (test_bit(This->joydev->ffbits, FF_SPRING)) {
1212 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Spring);
1213 (*lpCallback)(&dei, pvRef);
1214 }
1215 if (test_bit(This->joydev->ffbits, FF_DAMPER)) {
1216 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Damper);
1217 (*lpCallback)(&dei, pvRef);
1218 }
1219 if (test_bit(This->joydev->ffbits, FF_INERTIA)) {
1220 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Inertia);
1221 (*lpCallback)(&dei, pvRef);
1222 }
1223 if (test_bit(This->joydev->ffbits, FF_FRICTION)) {
1224 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Friction);
1225 (*lpCallback)(&dei, pvRef);
1226 }
1227 }
1228
1229 #endif
1230
1231 return DI_OK;
1232 }
1233
1234 static HRESULT WINAPI JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface,
1235 LPDIENUMEFFECTSCALLBACKW lpCallback,
1236 LPVOID pvRef,
1237 DWORD dwEffType)
1238 {
1239 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1240 /* seems silly to duplicate all this code but all the structures and functions
1241 * are actually different (A/W) */
1242 DIEFFECTINFOW dei; /* feif */
1243 DWORD type = DIEFT_GETTYPE(dwEffType);
1244 JoystickImpl* This = (JoystickImpl*)iface;
1245 int xfd = This->joyfd;
1246
1247 TRACE("(this=%p,%p,%d) type=%d fd=%d\n", This, pvRef, dwEffType, type, xfd);
1248
1249 dei.dwSize = sizeof(DIEFFECTINFOW);
1250
1251 if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1252 && test_bit(This->joydev->ffbits, FF_CONSTANT)) {
1253 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1254 (*lpCallback)(&dei, pvRef);
1255 }
1256
1257 if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1258 && test_bit(This->joydev->ffbits, FF_PERIODIC)) {
1259 if (test_bit(This->joydev->ffbits, FF_SQUARE)) {
1260 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Square);
1261 (*lpCallback)(&dei, pvRef);
1262 }
1263 if (test_bit(This->joydev->ffbits, FF_SINE)) {
1264 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Sine);
1265 (*lpCallback)(&dei, pvRef);
1266 }
1267 if (test_bit(This->joydev->ffbits, FF_TRIANGLE)) {
1268 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Triangle);
1269 (*lpCallback)(&dei, pvRef);
1270 }
1271 if (test_bit(This->joydev->ffbits, FF_SAW_UP)) {
1272 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1273 (*lpCallback)(&dei, pvRef);
1274 }
1275 if (test_bit(This->joydev->ffbits, FF_SAW_DOWN)) {
1276 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1277 (*lpCallback)(&dei, pvRef);
1278 }
1279 }
1280
1281 if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1282 && test_bit(This->joydev->ffbits, FF_RAMP)) {
1283 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_RampForce);
1284 (*lpCallback)(&dei, pvRef);
1285 }
1286
1287 if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1288 if (test_bit(This->joydev->ffbits, FF_SPRING)) {
1289 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Spring);
1290 (*lpCallback)(&dei, pvRef);
1291 }
1292 if (test_bit(This->joydev->ffbits, FF_DAMPER)) {
1293 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Damper);
1294 (*lpCallback)(&dei, pvRef);
1295 }
1296 if (test_bit(This->joydev->ffbits, FF_INERTIA)) {
1297 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Inertia);
1298 (*lpCallback)(&dei, pvRef);
1299 }
1300 if (test_bit(This->joydev->ffbits, FF_FRICTION)) {
1301 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Friction);
1302 (*lpCallback)(&dei, pvRef);
1303 }
1304 }
1305
1306 /* return to unacquired state if that's where it was */
1307 if (xfd == -1)
1308 IDirectInputDevice8_Unacquire(iface);
1309 #endif
1310
1311 return DI_OK;
1312 }
1313
1314 /*******************************************************************************
1315 * GetEffectInfo - Get information about a particular effect
1316 */
1317 static HRESULT WINAPI JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface,
1318 LPDIEFFECTINFOA pdei,
1319 REFGUID guid)
1320 {
1321 JoystickImpl* This = (JoystickImpl*)iface;
1322
1323 TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1324
1325 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1326 return linuxinput_get_info_A(This->joyfd, guid, pdei);
1327 #else
1328 return DI_OK;
1329 #endif
1330 }
1331
1332 static HRESULT WINAPI JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface,
1333 LPDIEFFECTINFOW pdei,
1334 REFGUID guid)
1335 {
1336 JoystickImpl* This = (JoystickImpl*)iface;
1337
1338 TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1339
1340 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1341 return linuxinput_get_info_W(This->joyfd, guid, pdei);
1342 #else
1343 return DI_OK;
1344 #endif
1345 }
1346
1347 /*******************************************************************************
1348 * GetForceFeedbackState - Get information about the device's FF state
1349 */
1350 static HRESULT WINAPI JoystickAImpl_GetForceFeedbackState(
1351 LPDIRECTINPUTDEVICE8A iface,
1352 LPDWORD pdwOut)
1353 {
1354 JoystickImpl* This = (JoystickImpl*)iface;
1355
1356 TRACE("(this=%p,%p)\n", This, pdwOut);
1357
1358 (*pdwOut) = 0;
1359
1360 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1361 /* DIGFFS_STOPPED is the only mandatory flag to report */
1362 if (This->ff_state == FF_STATUS_STOPPED)
1363 (*pdwOut) |= DIGFFS_STOPPED;
1364 #endif
1365
1366 return DI_OK;
1367 }
1368
1369 /*******************************************************************************
1370 * SendForceFeedbackCommand - Send a command to the device's FF system
1371 */
1372 static HRESULT WINAPI JoystickAImpl_SendForceFeedbackCommand(
1373 LPDIRECTINPUTDEVICE8A iface,
1374 DWORD dwFlags)
1375 {
1376 JoystickImpl* This = (JoystickImpl*)iface;
1377 TRACE("(this=%p,%d)\n", This, dwFlags);
1378
1379 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1380 switch (dwFlags)
1381 {
1382 case DISFFC_STOPALL:
1383 {
1384 /* Stop all effects */
1385 effect_list_item *itr;
1386
1387 LIST_FOR_EACH_ENTRY(itr, &This->ff_effects, effect_list_item, entry)
1388 IDirectInputEffect_Stop(itr->ref);
1389 break;
1390 }
1391
1392 case DISFFC_RESET:
1393 {
1394 effect_list_item *itr, *ptr;
1395
1396 /* Stop, unload, release and free all effects */
1397 /* This returns the device to its "bare" state */
1398 LIST_FOR_EACH_ENTRY_SAFE(itr, ptr, &This->ff_effects, effect_list_item, entry)
1399 IDirectInputEffect_Release(itr->ref);
1400 break;
1401 }
1402 case DISFFC_PAUSE:
1403 case DISFFC_CONTINUE:
1404 FIXME("No support for Pause or Continue in linux\n");
1405 break;
1406
1407 case DISFFC_SETACTUATORSOFF:
1408 case DISFFC_SETACTUATORSON:
1409 FIXME("No direct actuator control in linux\n");
1410 break;
1411
1412 default:
1413 FIXME("Unknown Force Feedback Command!\n");
1414 return DIERR_INVALIDPARAM;
1415 }
1416 return DI_OK;
1417 #else
1418 return DIERR_UNSUPPORTED;
1419 #endif
1420 }
1421
1422 /*******************************************************************************
1423 * EnumCreatedEffectObjects - Enumerate all the effects that have been
1424 * created for this device.
1425 */
1426 static HRESULT WINAPI JoystickAImpl_EnumCreatedEffectObjects(
1427 LPDIRECTINPUTDEVICE8A iface,
1428 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
1429 LPVOID pvRef,
1430 DWORD dwFlags)
1431 {
1432 /* this function is safe to call on non-ff-enabled builds */
1433 JoystickImpl* This = (JoystickImpl*)iface;
1434 effect_list_item *itr, *ptr;
1435
1436 TRACE("(this=%p,%p,%p,%d)\n", This, lpCallback, pvRef, dwFlags);
1437
1438 if (!lpCallback)
1439 return DIERR_INVALIDPARAM;
1440
1441 if (dwFlags != 0)
1442 FIXME("Flags specified, but no flags exist yet (DX9)!\n");
1443
1444 LIST_FOR_EACH_ENTRY_SAFE(itr, ptr, &This->ff_effects, effect_list_item, entry)
1445 (*lpCallback)(itr->ref, pvRef);
1446
1447 return DI_OK;
1448 }
1449
1450 /******************************************************************************
1451 * GetDeviceInfo : get information about a device's identity
1452 */
1453 static HRESULT WINAPI JoystickAImpl_GetDeviceInfo(LPDIRECTINPUTDEVICE8A iface,
1454 LPDIDEVICEINSTANCEA pdidi)
1455 {
1456 JoystickImpl *This = (JoystickImpl *)iface;
1457
1458 TRACE("(%p) %p\n", This, pdidi);
1459
1460 if (pdidi == NULL) return E_POINTER;
1461 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
1462 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA)))
1463 return DIERR_INVALIDPARAM;
1464
1465 fill_joystick_dideviceinstanceA(pdidi, This->base.dinput->dwVersion,
1466 get_joystick_index(&This->base.guid));
1467 return DI_OK;
1468 }
1469
1470 static HRESULT WINAPI JoystickWImpl_GetDeviceInfo(LPDIRECTINPUTDEVICE8W iface,
1471 LPDIDEVICEINSTANCEW pdidi)
1472 {
1473 JoystickImpl *This = (JoystickImpl *)iface;
1474
1475 TRACE("(%p) %p\n", This, pdidi);
1476
1477 if (pdidi == NULL) return E_POINTER;
1478 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
1479 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW)))
1480 return DIERR_INVALIDPARAM;
1481
1482 fill_joystick_dideviceinstanceW(pdidi, This->base.dinput->dwVersion,
1483 get_joystick_index(&This->base.guid));
1484 return DI_OK;
1485 }
1486
1487 static const IDirectInputDevice8AVtbl JoystickAvt =
1488 {
1489 IDirectInputDevice2AImpl_QueryInterface,
1490 IDirectInputDevice2AImpl_AddRef,
1491 IDirectInputDevice2AImpl_Release,
1492 JoystickAImpl_GetCapabilities,
1493 IDirectInputDevice2AImpl_EnumObjects,
1494 JoystickAImpl_GetProperty,
1495 JoystickAImpl_SetProperty,
1496 JoystickAImpl_Acquire,
1497 JoystickAImpl_Unacquire,
1498 JoystickAImpl_GetDeviceState,
1499 IDirectInputDevice2AImpl_GetDeviceData,
1500 IDirectInputDevice2AImpl_SetDataFormat,
1501 IDirectInputDevice2AImpl_SetEventNotification,
1502 IDirectInputDevice2AImpl_SetCooperativeLevel,
1503 JoystickAImpl_GetObjectInfo,
1504 JoystickAImpl_GetDeviceInfo,
1505 IDirectInputDevice2AImpl_RunControlPanel,
1506 IDirectInputDevice2AImpl_Initialize,
1507 JoystickAImpl_CreateEffect,
1508 JoystickAImpl_EnumEffects,
1509 JoystickAImpl_GetEffectInfo,
1510 JoystickAImpl_GetForceFeedbackState,
1511 JoystickAImpl_SendForceFeedbackCommand,
1512 JoystickAImpl_EnumCreatedEffectObjects,
1513 IDirectInputDevice2AImpl_Escape,
1514 JoystickAImpl_Poll,
1515 IDirectInputDevice2AImpl_SendDeviceData,
1516 IDirectInputDevice7AImpl_EnumEffectsInFile,
1517 IDirectInputDevice7AImpl_WriteEffectToFile,
1518 IDirectInputDevice8AImpl_BuildActionMap,
1519 IDirectInputDevice8AImpl_SetActionMap,
1520 IDirectInputDevice8AImpl_GetImageInfo
1521 };
1522
1523 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1524 # define XCAST(fun) (typeof(JoystickWvt.fun))
1525 #else
1526 # define XCAST(fun) (void*)
1527 #endif
1528
1529 static const IDirectInputDevice8WVtbl JoystickWvt =
1530 {
1531 IDirectInputDevice2WImpl_QueryInterface,
1532 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1533 XCAST(Release)IDirectInputDevice2AImpl_Release,
1534 XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1535 IDirectInputDevice2WImpl_EnumObjects,
1536 XCAST(GetProperty)JoystickAImpl_GetProperty,
1537 XCAST(SetProperty)JoystickAImpl_SetProperty,
1538 XCAST(Acquire)JoystickAImpl_Acquire,
1539 XCAST(Unacquire)JoystickAImpl_Unacquire,
1540 XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1541 XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
1542 XCAST(SetDataFormat)IDirectInputDevice2AImpl_SetDataFormat,
1543 XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
1544 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1545 JoystickWImpl_GetObjectInfo,
1546 JoystickWImpl_GetDeviceInfo,
1547 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1548 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1549 XCAST(CreateEffect)JoystickAImpl_CreateEffect,
1550 JoystickWImpl_EnumEffects,
1551 JoystickWImpl_GetEffectInfo,
1552 XCAST(GetForceFeedbackState)JoystickAImpl_GetForceFeedbackState,
1553 XCAST(SendForceFeedbackCommand)JoystickAImpl_SendForceFeedbackCommand,
1554 XCAST(EnumCreatedEffectObjects)JoystickAImpl_EnumCreatedEffectObjects,
1555 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1556 XCAST(Poll)JoystickAImpl_Poll,
1557 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1558 IDirectInputDevice7WImpl_EnumEffectsInFile,
1559 IDirectInputDevice7WImpl_WriteEffectToFile,
1560 IDirectInputDevice8WImpl_BuildActionMap,
1561 IDirectInputDevice8WImpl_SetActionMap,
1562 IDirectInputDevice8WImpl_GetImageInfo
1563 };
1564 #undef XCAST
1565
1566 #else /* HAVE_CORRECT_LINUXINPUT_H */
1567
1568 const struct dinput_device joystick_linuxinput_device = {
1569 "Wine Linux-input joystick driver",
1570 NULL,
1571 NULL,
1572 NULL,
1573 NULL
1574 };
1575
1576 #endif /* HAVE_CORRECT_LINUXINPUT_H */
Windows API implementation