?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 4764fdcba48f6a6df3263056e605233f2bb574ff
[wine/hacks.git] / dlls / dinput / joystick_linuxinput.c
blob5ef0ea74e55181be4b31e058410b86d6dd183c98
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 <sys/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 "windef.h"
59 #include "winbase.h"
60 #include "winerror.h"
61 #include "dinput.h"
62
63 #include "dinput_private.h"
64 #include "device_private.h"
65
66 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
67
68
69 /*
70 * Maps POV x & y event values to a DX "clock" position:
71 * 0
72 * 31500 4500
73 * 27000 -1 9000
74 * 22500 13500
75 * 18000
76 */
77 DWORD joystick_map_pov(POINTL *p)
78 {
79 if (p->x > 0)
80 return p->y < 0 ? 4500 : !p->y ? 9000 : 13500;
81 else if (p->x < 0)
82 return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
83 else
84 return p->y < 0 ? 0 : !p->y ? -1 : 18000;
85 }
86
87 /*
88 * This maps the read value (from the input event) to a value in the
89 * 'wanted' range.
90 */
91 LONG joystick_map_axis(ObjProps *props, int val)
92 {
93 LONG ret;
94
95 /* map the value from the hmin-hmax range into the wmin-wmax range */
96 ret = MulDiv( val - props->lDevMin, props->lMax - props->lMin,
97 props->lDevMax - props->lDevMin ) + props->lMin;
98
99 if ((ret >= -props->lDeadZone / 2 ) && (ret <= props->lDeadZone / 2))
100 ret = (props->lMax - props->lMin) / 2 + props->lMin;
101
102 TRACE( "(%d %d) -> (%d <%d> %d): val=%d ret=%d\n",
103 props->lDevMin, props->lDevMax,
104 props->lMin, props->lDeadZone, props->lDevMax,
105 val, ret );
106
107 return ret;
108 }
109
110 #ifdef HAVE_CORRECT_LINUXINPUT_H
111
112 #define EVDEVPREFIX "/dev/input/event"
113
114 /* Wine joystick driver object instances */
115 #define WINE_JOYSTICK_MAX_AXES 8
116 #define WINE_JOYSTICK_MAX_POVS 4
117 #define WINE_JOYSTICK_MAX_BUTTONS 128
118
119 typedef struct EffectListItem EffectListItem;
120 struct EffectListItem
121 {
122 LPDIRECTINPUTEFFECT ref;
123 struct EffectListItem* next;
124 };
125
126 /* implemented in effect_linuxinput.c */
127 HRESULT linuxinput_create_effect(int* fd, REFGUID rguid, LPDIRECTINPUTEFFECT* peff);
128 HRESULT linuxinput_get_info_A(int fd, REFGUID rguid, LPDIEFFECTINFOA info);
129 HRESULT linuxinput_get_info_W(int fd, REFGUID rguid, LPDIEFFECTINFOW info);
130
131 typedef struct JoystickImpl JoystickImpl;
132 static const IDirectInputDevice8AVtbl JoystickAvt;
133 static const IDirectInputDevice8WVtbl JoystickWvt;
134
135 struct JoyDev {
136 char *device;
137 char *name;
138 GUID guid;
139
140 int has_ff;
141 int num_effects;
142
143 /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
144 BYTE evbits[(EV_MAX+7)/8];
145 BYTE absbits[(ABS_MAX+7)/8];
146 BYTE keybits[(KEY_MAX+7)/8];
147 BYTE ffbits[(FF_MAX+7)/8];
148
149 #define AXIS_ABS 0
150 #define AXIS_ABSMIN 1
151 #define AXIS_ABSMAX 2
152 #define AXIS_ABSFUZZ 3
153 #define AXIS_ABSFLAT 4
154
155 /* data returned by the EVIOCGABS() ioctl */
156 int axes[ABS_MAX][5];
157 };
158
159 struct ObjProps
160 {
161 /* what we have */
162 LONG havemax;
163 LONG havemin;
164 /* what range and deadzone the game wants */
165 LONG wantmin;
166 LONG wantmax;
167 LONG deadzone;
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 EffectListItem* top_effect;
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 (have_joydevs!=-1) {
221 return;
222 }
223
224 have_joydevs = 0;
225
226 for (i=0;i<MAX_JOYDEV;i++) {
227 char buf[MAX_PATH];
228 struct JoyDev joydev = {0};
229 int fd;
230 int no_ff_check = 0;
231 int j;
232
233 snprintf(buf,MAX_PATH,EVDEVPREFIX"%d",i);
234 buf[MAX_PATH-1] = 0;
235
236 if ((fd=open(buf, O_RDWR))==-1) {
237 fd = open(buf, O_RDONLY);
238 no_ff_check = 1;
239 }
240
241 if (fd!=-1) {
242 if ((-1==ioctl(fd,EVIOCGBIT(0,sizeof(joydev.evbits)),joydev.evbits))) {
243 perror("EVIOCGBIT 0");
244 close(fd);
245 continue;
246 }
247 if (-1==ioctl(fd,EVIOCGBIT(EV_ABS,sizeof(joydev.absbits)),joydev.absbits)) {
248 perror("EVIOCGBIT EV_ABS");
249 close(fd);
250 continue;
251 }
252 if (-1==ioctl(fd,EVIOCGBIT(EV_KEY,sizeof(joydev.keybits)),joydev.keybits)) {
253 perror("EVIOCGBIT EV_KEY");
254 close(fd);
255 continue;
256 }
257 /* A true joystick has at least axis X and Y, and at least 1
258 * button. copied from linux/drivers/input/joydev.c */
259 if (test_bit(joydev.absbits,ABS_X) && test_bit(joydev.absbits,ABS_Y) &&
260 ( test_bit(joydev.keybits,BTN_TRIGGER) ||
261 test_bit(joydev.keybits,BTN_A) ||
262 test_bit(joydev.keybits,BTN_1)
263 )
264 ) {
265
266 joydev.device = strdup(buf);
267
268 if (-1!=ioctl(fd, EVIOCGNAME(MAX_PATH-1), buf)) {
269 buf[MAX_PATH-1] = 0;
270 joydev.name = strdup(buf);
271 } else {
272 joydev.name = joydev.device;
273 }
274
275 joydev.guid = DInput_Wine_Joystick_Base_GUID;
276 joydev.guid.Data3 += have_joydevs;
277
278 TRACE("Found a joystick on %s: %s (%s)\n",
279 joydev.device, joydev.name,
280 debugstr_guid(&joydev.guid)
281 );
282
283 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
284 if (!no_ff_check &&
285 test_bit(joydev.evbits, EV_FF) &&
286 ioctl(fd, EVIOCGBIT(EV_FF, sizeof(joydev.ffbits)), joydev.ffbits) != -1 &&
287 ioctl(fd, EVIOCGEFFECTS, &joydev.num_effects) != -1 &&
288 joydev.num_effects > 0)
289 {
290 TRACE(" ... with force feedback\n");
291 joydev.has_ff = 1;
292 }
293 #endif
294
295 for (j=0;j<ABS_MAX;j++) {
296 if (test_bit(joydev.absbits,j)) {
297 if (-1!=ioctl(fd,EVIOCGABS(j),&(joydev.axes[j]))) {
298 TRACE(" ... with axis %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
299 j,
300 joydev.axes[j][AXIS_ABS],
301 joydev.axes[j][AXIS_ABSMIN],
302 joydev.axes[j][AXIS_ABSMAX],
303 joydev.axes[j][AXIS_ABSFUZZ],
304 joydev.axes[j][AXIS_ABSFLAT]
305 );
306 }
307 }
308 }
309
310 if (have_joydevs==0) {
311 joydevs = HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev));
312 } else {
313 HeapReAlloc(GetProcessHeap(), 0, joydevs, (1+have_joydevs) * sizeof(struct JoyDev));
314 }
315 memcpy(joydevs+have_joydevs, &joydev, sizeof(struct JoyDev));
316 have_joydevs++;
317 }
318
319 close(fd);
320 }
321 }
322 }
323
324 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
325 {
326 find_joydevs();
327
328 if (id >= have_joydevs) {
329 return FALSE;
330 }
331
332 if (!((dwDevType == 0) ||
333 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 0x0800)) ||
334 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
335 return FALSE;
336
337 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
338 if (dwFlags & DIEDFL_FORCEFEEDBACK)
339 return FALSE;
340 #endif
341
342 if (!(dwFlags & DIEDFL_FORCEFEEDBACK) || joydevs[id].has_ff) {
343 lpddi->guidInstance = joydevs[id].guid;
344 lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
345
346 lpddi->guidFFDriver = GUID_NULL;
347 if (version >= 0x0800)
348 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
349 else
350 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
351
352 strcpy(lpddi->tszInstanceName, joydevs[id].name);
353 strcpy(lpddi->tszProductName, joydevs[id].device);
354 return TRUE;
355 }
356 return FALSE;
357 }
358
359 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
360 {
361 find_joydevs();
362
363 if (id >= have_joydevs) {
364 return FALSE;
365 }
366
367 if (!((dwDevType == 0) ||
368 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version < 0x0800)) ||
369 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))))
370 return FALSE;
371
372 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
373 if (dwFlags & DIEDFL_FORCEFEEDBACK)
374 return FALSE;
375 #endif
376
377 if (!(dwFlags & DIEDFL_FORCEFEEDBACK) || joydevs[id].has_ff) {
378 lpddi->guidInstance = joydevs[id].guid;
379 lpddi->guidProduct = DInput_Wine_Joystick_Base_GUID;
380
381 lpddi->guidFFDriver = GUID_NULL;
382 if (version >= 0x0800)
383 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
384 else
385 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
386
387 MultiByteToWideChar(CP_ACP, 0, joydevs[id].name, -1, lpddi->tszInstanceName, MAX_PATH);
388 MultiByteToWideChar(CP_ACP, 0, joydevs[id].device, -1, lpddi->tszProductName, MAX_PATH);
389 return TRUE;
390 }
391 return FALSE;
392 }
393
394 static JoystickImpl *alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput, struct JoyDev *joydev)
395 {
396 JoystickImpl* newDevice;
397 LPDIDATAFORMAT df = NULL;
398 int i, idx = 0;
399
400 newDevice = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(JoystickImpl));
401 if (!newDevice) return NULL;
402
403 newDevice->base.lpVtbl = jvt;
404 newDevice->base.ref = 1;
405 memcpy(&newDevice->base.guid, rguid, sizeof(*rguid));
406 InitializeCriticalSection(&newDevice->base.crit);
407 newDevice->base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->base.crit");
408 newDevice->joyfd = -1;
409 newDevice->base.dinput = dinput;
410 newDevice->joydev = joydev;
411 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
412 newDevice->ff_state = FF_STATUS_STOPPED;
413 #endif
414
415 /* Create copy of default data format */
416 if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto failed;
417 memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
418 if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto failed;
419
420 /* Supported Axis & POVs should map 1-to-1 */
421 for (i = 0; i < WINE_JOYSTICK_MAX_AXES; i++)
422 {
423 if (!test_bit(newDevice->joydev->absbits, i)) {
424 newDevice->axes[i] = -1;
425 continue;
426 }
427
428 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i], df->dwObjSize);
429 newDevice->axes[i] = idx;
430 newDevice->props[idx].lDevMin = newDevice->joydev->axes[i][AXIS_ABSMIN];
431 newDevice->props[idx].lDevMax = newDevice->joydev->axes[i][AXIS_ABSMAX];
432 newDevice->props[idx].lMin = 0;
433 newDevice->props[idx].lMax = 0xffff;
434 newDevice->props[idx].lSaturation = 0;
435 newDevice->props[idx].lDeadZone = MulDiv(newDevice->joydev->axes[i][AXIS_ABSFLAT], 0xffff,
436 newDevice->props[idx].lDevMax - newDevice->props[idx].lDevMin);
437
438 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numAxes++) | DIDFT_ABSAXIS;
439 }
440
441 for (i = 0; i < WINE_JOYSTICK_MAX_POVS; i++)
442 {
443 if (!test_bit(newDevice->joydev->absbits, ABS_HAT0X + i * 2) ||
444 !test_bit(newDevice->joydev->absbits, ABS_HAT0Y + i * 2)) {
445 newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = -1;
446 continue;
447 }
448
449 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + WINE_JOYSTICK_MAX_AXES], df->dwObjSize);
450 newDevice->axes[ABS_HAT0X + i * 2] = newDevice->axes[ABS_HAT0Y + i * 2] = i;
451 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numPOVs++) | DIDFT_POV;
452 }
453
454 /* Buttons can be anywhere, so check all */
455 for (i = 0; i < KEY_MAX && newDevice->numButtons < WINE_JOYSTICK_MAX_BUTTONS; i++)
456 {
457 if (!test_bit(newDevice->joydev->keybits, i)) continue;
458
459 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[newDevice->numButtons + WINE_JOYSTICK_MAX_AXES + WINE_JOYSTICK_MAX_POVS], df->dwObjSize);
460 newDevice->buttons[i] = 0x80 | newDevice->numButtons;
461 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(newDevice->numButtons++) | DIDFT_PSHBUTTON;
462 }
463 df->dwNumObjs = idx;
464
465 fake_current_js_state(newDevice);
466
467 newDevice->base.data_format.wine_df = df;
468 IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->base.dinput);
469 return newDevice;
470
471 failed:
472 if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
473 HeapFree(GetProcessHeap(), 0, df);
474 HeapFree(GetProcessHeap(), 0, newDevice);
475 return NULL;
476 }
477
478 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
479 {
480 int i;
481
482 find_joydevs();
483
484 for (i=0; i<have_joydevs; i++) {
485 if (IsEqualGUID(&GUID_Joystick,rguid) ||
486 IsEqualGUID(&joydevs[i].guid,rguid)
487 ) {
488 if ((riid == NULL) ||
489 IsEqualGUID(&IID_IDirectInputDeviceA,riid) ||
490 IsEqualGUID(&IID_IDirectInputDevice2A,riid) ||
491 IsEqualGUID(&IID_IDirectInputDevice7A,riid) ||
492 IsEqualGUID(&IID_IDirectInputDevice8A,riid)) {
493 *pdev = (IDirectInputDeviceA*) alloc_device(rguid, &JoystickAvt, dinput, &joydevs[i]);
494 TRACE("Creating a Joystick device (%p)\n", *pdev);
495 if (*pdev==0) {
496 ERR("out of memory\n");
497 return DIERR_OUTOFMEMORY;
498 }
499 return DI_OK;
500 } else {
501 return DIERR_NOINTERFACE;
502 }
503 }
504 }
505
506 return DIERR_DEVICENOTREG;
507 }
508
509
510 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
511 {
512 int i;
513
514 find_joydevs();
515
516 for (i=0; i<have_joydevs; i++) {
517 if (IsEqualGUID(&GUID_Joystick,rguid) ||
518 IsEqualGUID(&joydevs[i].guid,rguid)
519 ) {
520 if ((riid == NULL) ||
521 IsEqualGUID(&IID_IDirectInputDeviceW,riid) ||
522 IsEqualGUID(&IID_IDirectInputDevice2W,riid) ||
523 IsEqualGUID(&IID_IDirectInputDevice7W,riid) ||
524 IsEqualGUID(&IID_IDirectInputDevice8W,riid)) {
525 *pdev = (IDirectInputDeviceW*) alloc_device(rguid, &JoystickWvt, dinput, &joydevs[i]);
526 TRACE("Creating a Joystick device (%p)\n", *pdev);
527 if (*pdev==0) {
528 ERR("out of memory\n");
529 return DIERR_OUTOFMEMORY;
530 }
531 return DI_OK;
532 } else {
533 return DIERR_NOINTERFACE;
534 }
535 }
536 }
537
538 return DIERR_DEVICENOTREG;
539 }
540
541 const struct dinput_device joystick_linuxinput_device = {
542 "Wine Linux-input joystick driver",
543 joydev_enum_deviceA,
544 joydev_enum_deviceW,
545 joydev_create_deviceA,
546 joydev_create_deviceW
547 };
548
549 /******************************************************************************
550 * Acquire : gets exclusive control of the joystick
551 */
552 static HRESULT WINAPI JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface)
553 {
554 JoystickImpl *This = (JoystickImpl *)iface;
555 HRESULT res;
556
557 TRACE("(this=%p)\n",This);
558
559 res = IDirectInputDevice2AImpl_Acquire(iface);
560 if (res==DI_OK) {
561 if (-1==(This->joyfd=open(This->joydev->device,O_RDWR))) {
562 if (-1==(This->joyfd=open(This->joydev->device,O_RDONLY))) {
563 /* Couldn't open the device at all */
564 perror(This->joydev->device);
565 IDirectInputDevice2AImpl_Unacquire(iface);
566 return DIERR_NOTFOUND;
567 } else {
568 /* Couldn't open in r/w but opened in read-only. */
569 WARN("Could not open %s in read-write mode. Force feedback will be disabled.\n", This->joydev->device);
570 }
571 }
572 }
573
574 return res;
575 }
576
577 /******************************************************************************
578 * Unacquire : frees the joystick
579 */
580 static HRESULT WINAPI JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface)
581 {
582 JoystickImpl *This = (JoystickImpl *)iface;
583 HRESULT res;
584
585 TRACE("(this=%p)\n",This);
586 res = IDirectInputDevice2AImpl_Unacquire(iface);
587 if (res==DI_OK && This->joyfd!=-1) {
588 close(This->joyfd);
589 This->joyfd = -1;
590 }
591 return res;
592 }
593
594 /*
595 * set the current state of the js device as it would be with the middle
596 * values on the axes
597 */
598 #define CENTER_AXIS(a) \
599 (ji->axes[a] == -1 ? 0 : joystick_map_axis( &ji->props[ji->axes[a]], \
600 ji->joydev->axes[a][AXIS_ABS] ))
601 static void fake_current_js_state(JoystickImpl *ji)
602 {
603 int i;
604
605 /* center the axes */
606 ji->js.lX = CENTER_AXIS(ABS_X);
607 ji->js.lY = CENTER_AXIS(ABS_Y);
608 ji->js.lZ = CENTER_AXIS(ABS_Z);
609 ji->js.lRx = CENTER_AXIS(ABS_RX);
610 ji->js.lRy = CENTER_AXIS(ABS_RY);
611 ji->js.lRz = CENTER_AXIS(ABS_RZ);
612 ji->js.rglSlider[0] = CENTER_AXIS(ABS_THROTTLE);
613 ji->js.rglSlider[1] = CENTER_AXIS(ABS_RUDDER);
614
615 /* POV center is -1 */
616 for (i = 0; i < 4; i++)
617 ji->js.rgdwPOV[i] = -1;
618 }
619 #undef CENTER_AXIS
620
621 /* convert wine format offset to user format object index */
622 static void joy_polldev(JoystickImpl *This)
623 {
624 struct pollfd plfd;
625 struct input_event ie;
626
627 if (This->joyfd==-1)
628 return;
629
630 while (1)
631 {
632 LONG value = 0;
633 int inst_id = -1;
634
635 plfd.fd = This->joyfd;
636 plfd.events = POLLIN;
637
638 if (poll(&plfd,1,0) != 1)
639 return;
640
641 /* we have one event, so we can read */
642 if (sizeof(ie)!=read(This->joyfd,&ie,sizeof(ie)))
643 return;
644
645 TRACE("input_event: type %d, code %d, value %d\n",ie.type,ie.code,ie.value);
646 switch (ie.type) {
647 case EV_KEY: /* button */
648 {
649 int btn = This->buttons[ie.code];
650
651 TRACE("(%p) %d -> %d\n", This, ie.code, btn);
652 if (btn & 0x80)
653 {
654 btn &= 0x7F;
655 inst_id = DIDFT_MAKEINSTANCE(btn) | DIDFT_PSHBUTTON;
656 This->js.rgbButtons[btn] = value = ie.value ? 0x80 : 0x00;
657 }
658 break;
659 }
660 case EV_ABS:
661 {
662 int axis = This->axes[ie.code];
663 if (axis==-1) {
664 break;
665 }
666 inst_id = DIDFT_MAKEINSTANCE(axis) | (ie.code < ABS_HAT0X ? DIDFT_ABSAXIS : DIDFT_POV);
667 value = joystick_map_axis(&This->props[id_to_object(This->base.data_format.wine_df, inst_id)], ie.value);
668
669 switch (ie.code) {
670 case ABS_X: This->js.lX = value; break;
671 case ABS_Y: This->js.lY = value; break;
672 case ABS_Z: This->js.lZ = value; break;
673 case ABS_RX: This->js.lRx = value; break;
674 case ABS_RY: This->js.lRy = value; break;
675 case ABS_RZ: This->js.lRz = value; break;
676 case ABS_THROTTLE: This->js.rglSlider[0] = value; break;
677 case ABS_RUDDER: This->js.rglSlider[1] = value; break;
678 case ABS_HAT0X: case ABS_HAT0Y: case ABS_HAT1X: case ABS_HAT1Y:
679 case ABS_HAT2X: case ABS_HAT2Y: case ABS_HAT3X: case ABS_HAT3Y:
680 {
681 int idx = (ie.code - ABS_HAT0X) / 2;
682
683 if (ie.code % 2)
684 This->povs[idx].y = ie.value;
685 else
686 This->povs[idx].x = ie.value;
687
688 This->js.rgdwPOV[idx] = value = joystick_map_pov(&This->povs[idx]);
689 break;
690 }
691 default:
692 FIXME("unhandled joystick axis event (code %d, value %d)\n",ie.code,ie.value);
693 }
694 break;
695 }
696 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
697 case EV_FF_STATUS:
698 This->ff_state = ie.value;
699 break;
700 #endif
701 #ifdef EV_SYN
702 case EV_SYN:
703 /* there is nothing to do */
704 break;
705 #endif
706 default:
707 FIXME("joystick cannot handle type %d event (code %d)\n",ie.type,ie.code);
708 break;
709 }
710 if (inst_id >= 0)
711 queue_event((LPDIRECTINPUTDEVICE8A)This,
712 id_to_offset(&This->base.data_format, inst_id),
713 value, ie.time.tv_usec, This->base.dinput->evsequence++);
714 }
715 }
716
717 /******************************************************************************
718 * GetDeviceState : returns the "state" of the joystick.
719 *
720 */
721 static HRESULT WINAPI JoystickAImpl_GetDeviceState(
722 LPDIRECTINPUTDEVICE8A iface,DWORD len,LPVOID ptr
723 ) {
724 JoystickImpl *This = (JoystickImpl *)iface;
725
726 TRACE("(this=%p,0x%08x,%p)\n", This, len, ptr);
727
728 if (This->joyfd==-1) {
729 WARN("not acquired\n");
730 return DIERR_NOTACQUIRED;
731 }
732
733 joy_polldev(This);
734
735 /* convert and copy data to user supplied buffer */
736 fill_DataFormat(ptr, &This->js, &This->base.data_format);
737
738 return DI_OK;
739 }
740
741 /******************************************************************************
742 * SetProperty : change input device properties
743 */
744 static HRESULT WINAPI JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface,
745 REFGUID rguid,
746 LPCDIPROPHEADER ph)
747 {
748 JoystickImpl *This = (JoystickImpl *)iface;
749
750 if (!ph) {
751 WARN("invalid argument\n");
752 return DIERR_INVALIDPARAM;
753 }
754
755 TRACE("(this=%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
756 TRACE("ph.dwSize = %d, ph.dwHeaderSize =%d, ph.dwObj = %d, ph.dwHow= %d\n",
757 ph->dwSize, ph->dwHeaderSize, ph->dwObj, ph->dwHow);
758
759 if (!HIWORD(rguid)) {
760 switch (LOWORD(rguid)) {
761 case (DWORD)DIPROP_RANGE: {
762 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
763
764 if (ph->dwHow == DIPH_DEVICE) {
765 int i;
766 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
767 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
768 /* Scale dead-zone */
769 This->props[i].lDeadZone = MulDiv(This->props[i].lDeadZone, pr->lMax - pr->lMin,
770 This->props[i].lMax - This->props[i].lMin);
771 This->props[i].lMin = pr->lMin;
772 This->props[i].lMax = pr->lMax;
773 }
774 } else {
775 int obj = find_property(&This->base.data_format, ph);
776
777 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
778 if (obj >= 0) {
779 /* Scale dead-zone */
780 This->props[obj].lDeadZone = MulDiv(This->props[obj].lDeadZone, pr->lMax - pr->lMin,
781 This->props[obj].lMax - This->props[obj].lMin);
782 This->props[obj].lMin = pr->lMin;
783 This->props[obj].lMax = pr->lMax;
784 }
785 }
786 fake_current_js_state(This);
787 break;
788 }
789 case (DWORD)DIPROP_DEADZONE: {
790 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
791 if (ph->dwHow == DIPH_DEVICE) {
792 int i;
793 TRACE("deadzone(%d) all\n", pd->dwData);
794 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
795 This->props[i].lDeadZone = pd->dwData;
796 }
797 } else {
798 int obj = find_property(&This->base.data_format, ph);
799
800 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
801 if (obj >= 0) {
802 This->props[obj].lDeadZone = pd->dwData;
803 }
804 }
805 fake_current_js_state(This);
806 break;
807 }
808 case (DWORD)DIPROP_CALIBRATIONMODE: {
809 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
810 FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd->dwData);
811 break;
812 }
813 default:
814 return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
815 }
816 }
817 return DI_OK;
818 }
819
820 static HRESULT WINAPI JoystickAImpl_GetCapabilities(
821 LPDIRECTINPUTDEVICE8A iface,
822 LPDIDEVCAPS lpDIDevCaps)
823 {
824 JoystickImpl *This = (JoystickImpl *)iface;
825
826 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
827
828 if (!lpDIDevCaps) {
829 WARN("invalid pointer\n");
830 return E_POINTER;
831 }
832
833 if (lpDIDevCaps->dwSize != sizeof(DIDEVCAPS)) {
834 WARN("invalid argument\n");
835 return DIERR_INVALIDPARAM;
836 }
837
838 lpDIDevCaps->dwFlags = DIDC_ATTACHED;
839 if (This->base.dinput->dwVersion >= 0x0800)
840 lpDIDevCaps->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
841 else
842 lpDIDevCaps->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
843
844 if (This->joydev->has_ff)
845 lpDIDevCaps->dwFlags |= DIDC_FORCEFEEDBACK;
846
847 lpDIDevCaps->dwAxes = This->numAxes;
848 lpDIDevCaps->dwButtons = This->numButtons;
849 lpDIDevCaps->dwPOVs = This->numPOVs;
850
851 return DI_OK;
852 }
853
854 static HRESULT WINAPI JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface) {
855 JoystickImpl *This = (JoystickImpl *)iface;
856 TRACE("(%p)\n",This);
857
858 if (This->joyfd==-1) {
859 return DIERR_NOTACQUIRED;
860 }
861
862 joy_polldev(This);
863 return DI_OK;
864 }
865
866 /******************************************************************************
867 * GetProperty : get input device properties
868 */
869 static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
870 REFGUID rguid,
871 LPDIPROPHEADER pdiph)
872 {
873 JoystickImpl *This = (JoystickImpl *)iface;
874
875 TRACE("(this=%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
876 _dump_DIPROPHEADER(pdiph);
877
878 if (HIWORD(rguid)) return DI_OK;
879
880 switch (LOWORD(rguid)) {
881 case (DWORD) DIPROP_RANGE:
882 {
883 LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
884 int obj = find_property(&This->base.data_format, pdiph);
885
886 if (obj < 0) return DIERR_OBJECTNOTFOUND;
887
888 pr->lMin = This->props[obj].lMin;
889 pr->lMax = This->props[obj].lMax;
890 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
891 break;
892 }
893 case (DWORD) DIPROP_DEADZONE:
894 {
895 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
896 int obj = find_property(&This->base.data_format, pdiph);
897
898 if (obj < 0) return DIERR_OBJECTNOTFOUND;
899
900 pd->dwData = This->props[obj].lDeadZone;
901 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
902 break;
903 }
904
905 default:
906 return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
907 }
908
909 return DI_OK;
910 }
911
912 /******************************************************************************
913 * GetObjectInfo : get information about a device object such as a button
914 * or axis
915 */
916 static HRESULT WINAPI JoystickWImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
917 LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
918 {
919 static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
920 static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
921 static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
922 HRESULT res;
923
924 res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
925 if (res != DI_OK) return res;
926
927 if (pdidoi->dwType & DIDFT_AXIS)
928 sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
929 else if (pdidoi->dwType & DIDFT_POV)
930 sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
931 else if (pdidoi->dwType & DIDFT_BUTTON)
932 sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
933
934 _dump_OBJECTINSTANCEW(pdidoi);
935 return res;
936 }
937
938 static HRESULT WINAPI JoystickAImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
939 LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
940 {
941 HRESULT res;
942 DIDEVICEOBJECTINSTANCEW didoiW;
943 DWORD dwSize = pdidoi->dwSize;
944
945 didoiW.dwSize = sizeof(didoiW);
946 res = JoystickWImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W)iface, &didoiW, dwObj, dwHow);
947 if (res != DI_OK) return res;
948
949 memset(pdidoi, 0, pdidoi->dwSize);
950 memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
951 pdidoi->dwSize = dwSize;
952 WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
953 sizeof(pdidoi->tszName), NULL, NULL);
954
955 return res;
956 }
957
958 /******************************************************************************
959 * CreateEffect - Create a new FF effect with the specified params
960 */
961 static HRESULT WINAPI JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface,
962 REFGUID rguid,
963 LPCDIEFFECT lpeff,
964 LPDIRECTINPUTEFFECT *ppdef,
965 LPUNKNOWN pUnkOuter)
966 {
967 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
968 EffectListItem* new = NULL;
969 HRESULT retval = DI_OK;
970 #endif
971
972 JoystickImpl* This = (JoystickImpl*)iface;
973 TRACE("(this=%p,%p,%p,%p,%p)\n", This, rguid, lpeff, ppdef, pUnkOuter);
974
975 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
976 TRACE("not available (compiled w/o ff support)\n");
977 *ppdef = NULL;
978 return DI_OK;
979 #else
980
981 new = HeapAlloc(GetProcessHeap(), 0, sizeof(EffectListItem));
982 new->next = This->top_effect;
983 This->top_effect = new;
984
985 retval = linuxinput_create_effect(&(This->joyfd), rguid, &(new->ref));
986 if (retval != DI_OK)
987 return retval;
988
989 if (lpeff != NULL)
990 retval = IDirectInputEffect_SetParameters(new->ref, lpeff, 0);
991 if (retval != DI_OK && retval != DI_DOWNLOADSKIPPED)
992 return retval;
993
994 *ppdef = new->ref;
995
996 if (pUnkOuter != NULL)
997 FIXME("Interface aggregation not implemented.\n");
998
999 return DI_OK;
1000
1001 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1002 }
1003
1004 /*******************************************************************************
1005 * EnumEffects - Enumerate available FF effects
1006 */
1007 static HRESULT WINAPI JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface,
1008 LPDIENUMEFFECTSCALLBACKA lpCallback,
1009 LPVOID pvRef,
1010 DWORD dwEffType)
1011 {
1012 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1013 DIEFFECTINFOA dei; /* feif */
1014 DWORD type = DIEFT_GETTYPE(dwEffType);
1015 JoystickImpl* This = (JoystickImpl*)iface;
1016
1017 TRACE("(this=%p,%p,%d) type=%d\n", This, pvRef, dwEffType, type);
1018
1019 dei.dwSize = sizeof(DIEFFECTINFOA);
1020
1021 if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1022 && test_bit(This->joydev->ffbits, FF_CONSTANT)) {
1023 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1024 (*lpCallback)(&dei, pvRef);
1025 }
1026
1027 if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1028 && test_bit(This->joydev->ffbits, FF_PERIODIC)) {
1029 if (test_bit(This->joydev->ffbits, FF_SQUARE)) {
1030 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Square);
1031 (*lpCallback)(&dei, pvRef);
1032 }
1033 if (test_bit(This->joydev->ffbits, FF_SINE)) {
1034 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Sine);
1035 (*lpCallback)(&dei, pvRef);
1036 }
1037 if (test_bit(This->joydev->ffbits, FF_TRIANGLE)) {
1038 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Triangle);
1039 (*lpCallback)(&dei, pvRef);
1040 }
1041 if (test_bit(This->joydev->ffbits, FF_SAW_UP)) {
1042 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1043 (*lpCallback)(&dei, pvRef);
1044 }
1045 if (test_bit(This->joydev->ffbits, FF_SAW_DOWN)) {
1046 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1047 (*lpCallback)(&dei, pvRef);
1048 }
1049 }
1050
1051 if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1052 && test_bit(This->joydev->ffbits, FF_RAMP)) {
1053 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_RampForce);
1054 (*lpCallback)(&dei, pvRef);
1055 }
1056
1057 if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1058 if (test_bit(This->joydev->ffbits, FF_SPRING)) {
1059 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Spring);
1060 (*lpCallback)(&dei, pvRef);
1061 }
1062 if (test_bit(This->joydev->ffbits, FF_DAMPER)) {
1063 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Damper);
1064 (*lpCallback)(&dei, pvRef);
1065 }
1066 if (test_bit(This->joydev->ffbits, FF_INERTIA)) {
1067 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Inertia);
1068 (*lpCallback)(&dei, pvRef);
1069 }
1070 if (test_bit(This->joydev->ffbits, FF_FRICTION)) {
1071 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Friction);
1072 (*lpCallback)(&dei, pvRef);
1073 }
1074 }
1075
1076 #endif
1077
1078 return DI_OK;
1079 }
1080
1081 static HRESULT WINAPI JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface,
1082 LPDIENUMEFFECTSCALLBACKW lpCallback,
1083 LPVOID pvRef,
1084 DWORD dwEffType)
1085 {
1086 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1087 /* seems silly to duplicate all this code but all the structures and functions
1088 * are actually different (A/W) */
1089 DIEFFECTINFOW dei; /* feif */
1090 DWORD type = DIEFT_GETTYPE(dwEffType);
1091 JoystickImpl* This = (JoystickImpl*)iface;
1092 int xfd = This->joyfd;
1093
1094 TRACE("(this=%p,%p,%d) type=%d fd=%d\n", This, pvRef, dwEffType, type, xfd);
1095
1096 dei.dwSize = sizeof(DIEFFECTINFOW);
1097
1098 if ((type == DIEFT_ALL || type == DIEFT_CONSTANTFORCE)
1099 && test_bit(This->joydev->ffbits, FF_CONSTANT)) {
1100 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_ConstantForce);
1101 (*lpCallback)(&dei, pvRef);
1102 }
1103
1104 if ((type == DIEFT_ALL || type == DIEFT_PERIODIC)
1105 && test_bit(This->joydev->ffbits, FF_PERIODIC)) {
1106 if (test_bit(This->joydev->ffbits, FF_SQUARE)) {
1107 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Square);
1108 (*lpCallback)(&dei, pvRef);
1109 }
1110 if (test_bit(This->joydev->ffbits, FF_SINE)) {
1111 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Sine);
1112 (*lpCallback)(&dei, pvRef);
1113 }
1114 if (test_bit(This->joydev->ffbits, FF_TRIANGLE)) {
1115 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Triangle);
1116 (*lpCallback)(&dei, pvRef);
1117 }
1118 if (test_bit(This->joydev->ffbits, FF_SAW_UP)) {
1119 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothUp);
1120 (*lpCallback)(&dei, pvRef);
1121 }
1122 if (test_bit(This->joydev->ffbits, FF_SAW_DOWN)) {
1123 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_SawtoothDown);
1124 (*lpCallback)(&dei, pvRef);
1125 }
1126 }
1127
1128 if ((type == DIEFT_ALL || type == DIEFT_RAMPFORCE)
1129 && test_bit(This->joydev->ffbits, FF_RAMP)) {
1130 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_RampForce);
1131 (*lpCallback)(&dei, pvRef);
1132 }
1133
1134 if (type == DIEFT_ALL || type == DIEFT_CONDITION) {
1135 if (test_bit(This->joydev->ffbits, FF_SPRING)) {
1136 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Spring);
1137 (*lpCallback)(&dei, pvRef);
1138 }
1139 if (test_bit(This->joydev->ffbits, FF_DAMPER)) {
1140 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Damper);
1141 (*lpCallback)(&dei, pvRef);
1142 }
1143 if (test_bit(This->joydev->ffbits, FF_INERTIA)) {
1144 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Inertia);
1145 (*lpCallback)(&dei, pvRef);
1146 }
1147 if (test_bit(This->joydev->ffbits, FF_FRICTION)) {
1148 IDirectInputDevice8_GetEffectInfo(iface, &dei, &GUID_Friction);
1149 (*lpCallback)(&dei, pvRef);
1150 }
1151 }
1152
1153 /* return to unacquired state if that's where it was */
1154 if (xfd == -1)
1155 IDirectInputDevice8_Unacquire(iface);
1156 #endif
1157
1158 return DI_OK;
1159 }
1160
1161 /*******************************************************************************
1162 * GetEffectInfo - Get information about a particular effect
1163 */
1164 static HRESULT WINAPI JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface,
1165 LPDIEFFECTINFOA pdei,
1166 REFGUID guid)
1167 {
1168 JoystickImpl* This = (JoystickImpl*)iface;
1169
1170 TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1171
1172 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1173 return linuxinput_get_info_A(This->joyfd, guid, pdei);
1174 #else
1175 return DI_OK;
1176 #endif
1177 }
1178
1179 static HRESULT WINAPI JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface,
1180 LPDIEFFECTINFOW pdei,
1181 REFGUID guid)
1182 {
1183 JoystickImpl* This = (JoystickImpl*)iface;
1184
1185 TRACE("(this=%p,%p,%s)\n", This, pdei, _dump_dinput_GUID(guid));
1186
1187 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1188 return linuxinput_get_info_W(This->joyfd, guid, pdei);
1189 #else
1190 return DI_OK;
1191 #endif
1192 }
1193
1194 /*******************************************************************************
1195 * GetForceFeedbackState - Get information about the device's FF state
1196 */
1197 static HRESULT WINAPI JoystickAImpl_GetForceFeedbackState(
1198 LPDIRECTINPUTDEVICE8A iface,
1199 LPDWORD pdwOut)
1200 {
1201 JoystickImpl* This = (JoystickImpl*)iface;
1202
1203 TRACE("(this=%p,%p)\n", This, pdwOut);
1204
1205 (*pdwOut) = 0;
1206
1207 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1208 /* DIGFFS_STOPPED is the only mandatory flag to report */
1209 if (This->ff_state == FF_STATUS_STOPPED)
1210 (*pdwOut) |= DIGFFS_STOPPED;
1211 #endif
1212
1213 return DI_OK;
1214 }
1215
1216 /*******************************************************************************
1217 * SendForceFeedbackCommand - Send a command to the device's FF system
1218 */
1219 static HRESULT WINAPI JoystickAImpl_SendForceFeedbackCommand(
1220 LPDIRECTINPUTDEVICE8A iface,
1221 DWORD dwFlags)
1222 {
1223 JoystickImpl* This = (JoystickImpl*)iface;
1224 TRACE("(this=%p,%d)\n", This, dwFlags);
1225
1226 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1227 if (dwFlags == DISFFC_STOPALL) {
1228 /* Stop all effects */
1229 EffectListItem* itr = This->top_effect;
1230 while (itr) {
1231 IDirectInputEffect_Stop(itr->ref);
1232 itr = itr->next;
1233 }
1234 } else if (dwFlags == DISFFC_RESET) {
1235 /* Stop, unload, release and free all effects */
1236 /* This returns the device to its "bare" state */
1237 while (This->top_effect) {
1238 EffectListItem* temp = This->top_effect;
1239 IDirectInputEffect_Stop(temp->ref);
1240 IDirectInputEffect_Unload(temp->ref);
1241 IDirectInputEffect_Release(temp->ref);
1242 This->top_effect = temp->next;
1243 HeapFree(GetProcessHeap(), 0, temp);
1244 }
1245 } else if (dwFlags == DISFFC_PAUSE || dwFlags == DISFFC_CONTINUE) {
1246 FIXME("No support for Pause or Continue in linux\n");
1247 } else if (dwFlags == DISFFC_SETACTUATORSOFF
1248 || dwFlags == DISFFC_SETACTUATORSON) {
1249 FIXME("No direct actuator control in linux\n");
1250 } else {
1251 FIXME("Unknown Force Feedback Command!\n");
1252 return DIERR_INVALIDPARAM;
1253 }
1254 return DI_OK;
1255 #else
1256 return DIERR_UNSUPPORTED;
1257 #endif
1258 }
1259
1260 /*******************************************************************************
1261 * EnumCreatedEffectObjects - Enumerate all the effects that have been
1262 * created for this device.
1263 */
1264 static HRESULT WINAPI JoystickAImpl_EnumCreatedEffectObjects(
1265 LPDIRECTINPUTDEVICE8A iface,
1266 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback,
1267 LPVOID pvRef,
1268 DWORD dwFlags)
1269 {
1270 /* this function is safe to call on non-ff-enabled builds */
1271
1272 JoystickImpl* This = (JoystickImpl*)iface;
1273 EffectListItem* itr = This->top_effect;
1274 TRACE("(this=%p,%p,%p,%d)\n", This, lpCallback, pvRef, dwFlags);
1275
1276 if (!lpCallback)
1277 return DIERR_INVALIDPARAM;
1278
1279 if (dwFlags != 0)
1280 FIXME("Flags specified, but no flags exist yet (DX9)!\n");
1281
1282 while (itr) {
1283 (*lpCallback)(itr->ref, pvRef);
1284 itr = itr->next;
1285 }
1286
1287 return DI_OK;
1288 }
1289
1290 static const IDirectInputDevice8AVtbl JoystickAvt =
1291 {
1292 IDirectInputDevice2AImpl_QueryInterface,
1293 IDirectInputDevice2AImpl_AddRef,
1294 IDirectInputDevice2AImpl_Release,
1295 JoystickAImpl_GetCapabilities,
1296 IDirectInputDevice2AImpl_EnumObjects,
1297 JoystickAImpl_GetProperty,
1298 JoystickAImpl_SetProperty,
1299 JoystickAImpl_Acquire,
1300 JoystickAImpl_Unacquire,
1301 JoystickAImpl_GetDeviceState,
1302 IDirectInputDevice2AImpl_GetDeviceData,
1303 IDirectInputDevice2AImpl_SetDataFormat,
1304 IDirectInputDevice2AImpl_SetEventNotification,
1305 IDirectInputDevice2AImpl_SetCooperativeLevel,
1306 JoystickAImpl_GetObjectInfo,
1307 IDirectInputDevice2AImpl_GetDeviceInfo,
1308 IDirectInputDevice2AImpl_RunControlPanel,
1309 IDirectInputDevice2AImpl_Initialize,
1310 JoystickAImpl_CreateEffect,
1311 JoystickAImpl_EnumEffects,
1312 JoystickAImpl_GetEffectInfo,
1313 JoystickAImpl_GetForceFeedbackState,
1314 JoystickAImpl_SendForceFeedbackCommand,
1315 JoystickAImpl_EnumCreatedEffectObjects,
1316 IDirectInputDevice2AImpl_Escape,
1317 JoystickAImpl_Poll,
1318 IDirectInputDevice2AImpl_SendDeviceData,
1319 IDirectInputDevice7AImpl_EnumEffectsInFile,
1320 IDirectInputDevice7AImpl_WriteEffectToFile,
1321 IDirectInputDevice8AImpl_BuildActionMap,
1322 IDirectInputDevice8AImpl_SetActionMap,
1323 IDirectInputDevice8AImpl_GetImageInfo
1324 };
1325
1326 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1327 # define XCAST(fun) (typeof(JoystickWvt.fun))
1328 #else
1329 # define XCAST(fun) (void*)
1330 #endif
1331
1332 static const IDirectInputDevice8WVtbl JoystickWvt =
1333 {
1334 IDirectInputDevice2WImpl_QueryInterface,
1335 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
1336 XCAST(Release)IDirectInputDevice2AImpl_Release,
1337 XCAST(GetCapabilities)JoystickAImpl_GetCapabilities,
1338 IDirectInputDevice2WImpl_EnumObjects,
1339 XCAST(GetProperty)JoystickAImpl_GetProperty,
1340 XCAST(SetProperty)JoystickAImpl_SetProperty,
1341 XCAST(Acquire)JoystickAImpl_Acquire,
1342 XCAST(Unacquire)JoystickAImpl_Unacquire,
1343 XCAST(GetDeviceState)JoystickAImpl_GetDeviceState,
1344 XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
1345 XCAST(SetDataFormat)IDirectInputDevice2AImpl_SetDataFormat,
1346 XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
1347 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
1348 JoystickWImpl_GetObjectInfo,
1349 IDirectInputDevice2WImpl_GetDeviceInfo,
1350 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
1351 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
1352 XCAST(CreateEffect)JoystickAImpl_CreateEffect,
1353 JoystickWImpl_EnumEffects,
1354 JoystickWImpl_GetEffectInfo,
1355 XCAST(GetForceFeedbackState)JoystickAImpl_GetForceFeedbackState,
1356 XCAST(SendForceFeedbackCommand)JoystickAImpl_SendForceFeedbackCommand,
1357 XCAST(EnumCreatedEffectObjects)JoystickAImpl_EnumCreatedEffectObjects,
1358 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1359 XCAST(Poll)JoystickAImpl_Poll,
1360 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1361 IDirectInputDevice7WImpl_EnumEffectsInFile,
1362 IDirectInputDevice7WImpl_WriteEffectToFile,
1363 IDirectInputDevice8WImpl_BuildActionMap,
1364 IDirectInputDevice8WImpl_SetActionMap,
1365 IDirectInputDevice8WImpl_GetImageInfo
1366 };
1367 #undef XCAST
1368
1369 #else /* HAVE_CORRECT_LINUXINPUT_H */
1370
1371 const struct dinput_device joystick_linuxinput_device = {
1372 "Wine Linux-input joystick driver",
1373 NULL,
1374 NULL,
1375 NULL,
1376 NULL
1377 };
1378
1379 #endif /* HAVE_CORRECT_LINUXINPUT_H */
useful hacks and other patches not (yet) suitable for mainline