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