1 /* DirectInput Joystick device
3 * Copyright 1998,2000 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2005 Daniel Remenak
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.
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.
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
24 #include "wine/port.h"
34 #ifdef HAVE_SYS_TIME_H
35 # include <sys/time.h>
37 #include <sys/fcntl.h>
38 #ifdef HAVE_SYS_IOCTL_H
39 # include <sys/ioctl.h>
42 #ifdef HAVE_SYS_ERRNO_H
43 # include <sys/errno.h>
45 #ifdef HAVE_LINUX_INPUT_H
46 # include <linux/input.h>
48 # if defined(EVIOCGBIT) && defined(EV_ABS) && defined(BTN_PINKIE)
49 # define HAVE_CORRECT_LINUXINPUT_H
52 #ifdef HAVE_SYS_POLL_H
53 # include <sys/poll.h>
56 #include "wine/debug.h"
57 #include "wine/unicode.h"
63 #include "dinput_private.h"
64 #include "device_private.h"
66 WINE_DEFAULT_DEBUG_CHANNEL(dinput
);
70 * Maps POV x & y event values to a DX "clock" position:
77 DWORD
joystick_map_pov(POINTL
*p
)
80 return p
->y
< 0 ? 4500 : !p
->y
? 9000 : 13500;
82 return p
->y
< 0 ? 31500 : !p
->y
? 27000 : 22500;
84 return p
->y
< 0 ? 0 : !p
->y
? -1 : 18000;
88 * This maps the read value (from the input event) to a value in the
91 LONG
joystick_map_axis(ObjProps
*props
, int val
)
94 LONG center
= (props
->lMax
- props
->lMin
) / 2;
96 /* map the value from the hmin-hmax range into the wmin-wmax range */
97 ret
= MulDiv( val
- props
->lDevMin
, props
->lMax
- props
->lMin
,
98 props
->lDevMax
- props
->lDevMin
);
100 if (abs( ret
- center
) <= props
->lDeadZone
/ 2 )
105 TRACE( "(%d %d) -> (%d <%d> %d): val=%d ret=%d\n",
106 props
->lDevMin
, props
->lDevMax
,
107 props
->lMin
, props
->lDeadZone
, props
->lMax
,
113 #ifdef HAVE_CORRECT_LINUXINPUT_H
115 #define EVDEVPREFIX "/dev/input/event"
117 /* Wine joystick driver object instances */
118 #define WINE_JOYSTICK_MAX_AXES 8
119 #define WINE_JOYSTICK_MAX_POVS 4
120 #define WINE_JOYSTICK_MAX_BUTTONS 128
122 struct wine_input_absinfo
{
130 typedef struct EffectListItem EffectListItem
;
131 struct EffectListItem
133 LPDIRECTINPUTEFFECT ref
;
134 struct EffectListItem
* next
;
137 /* implemented in effect_linuxinput.c */
138 HRESULT
linuxinput_create_effect(int* fd
, REFGUID rguid
, LPDIRECTINPUTEFFECT
* peff
);
139 HRESULT
linuxinput_get_info_A(int fd
, REFGUID rguid
, LPDIEFFECTINFOA info
);
140 HRESULT
linuxinput_get_info_W(int fd
, REFGUID rguid
, LPDIEFFECTINFOW info
);
142 typedef struct JoystickImpl JoystickImpl
;
143 static const IDirectInputDevice8AVtbl JoystickAvt
;
144 static const IDirectInputDevice8WVtbl JoystickWvt
;
154 /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
155 BYTE evbits
[(EV_MAX
+7)/8];
156 BYTE absbits
[(ABS_MAX
+7)/8];
157 BYTE keybits
[(KEY_MAX
+7)/8];
158 BYTE ffbits
[(FF_MAX
+7)/8];
160 /* data returned by the EVIOCGABS() ioctl */
161 struct wine_input_absinfo axes
[ABS_MAX
];
166 struct IDirectInputDevice2AImpl base
;
168 struct JoyDev
*joydev
;
170 /* joystick private */
175 ObjProps props
[ABS_MAX
];
180 /* LUT for KEY_ to offset in rgbButtons */
181 BYTE buttons
[KEY_MAX
];
187 /* Force feedback variables */
188 EffectListItem
* top_effect
;
192 static void fake_current_js_state(JoystickImpl
*ji
);
193 static void find_joydevs(void);
195 /* This GUID is slightly different from the linux joystick one. Take note. */
196 static const GUID DInput_Wine_Joystick_Base_GUID
= { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
200 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
203 #define test_bit(arr,bit) (((BYTE*)(arr))[(bit)>>3]&(1<<((bit)&7)))
205 #define MAX_JOYDEV 64
207 static int have_joydevs
= -1;
208 static struct JoyDev
*joydevs
= NULL
;
210 static void find_joydevs(void)
214 if (have_joydevs
!=-1) {
220 for (i
=0;i
<MAX_JOYDEV
;i
++) {
222 struct JoyDev joydev
= {0};
227 snprintf(buf
,MAX_PATH
,EVDEVPREFIX
"%d",i
);
230 if ((fd
=open(buf
, O_RDWR
))==-1) {
231 fd
= open(buf
, O_RDONLY
);
237 if ((-1==ioctl(fd
,EVIOCGBIT(0,sizeof(joydev
.evbits
)),joydev
.evbits
))) {
238 perror("EVIOCGBIT 0");
242 if (-1==ioctl(fd
,EVIOCGBIT(EV_ABS
,sizeof(joydev
.absbits
)),joydev
.absbits
)) {
243 perror("EVIOCGBIT EV_ABS");
247 if (-1==ioctl(fd
,EVIOCGBIT(EV_KEY
,sizeof(joydev
.keybits
)),joydev
.keybits
)) {
248 perror("EVIOCGBIT EV_KEY");
252 /* A true joystick has at least axis X and Y, and at least 1
253 * button. copied from linux/drivers/input/joydev.c */
254 if (test_bit(joydev
.absbits
,ABS_X
) && test_bit(joydev
.absbits
,ABS_Y
) &&
255 ( test_bit(joydev
.keybits
,BTN_TRIGGER
) ||
256 test_bit(joydev
.keybits
,BTN_A
) ||
257 test_bit(joydev
.keybits
,BTN_1
)
261 joydev
.device
= strdup(buf
);
263 if (-1!=ioctl(fd
, EVIOCGNAME(MAX_PATH
-1), buf
)) {
265 joydev
.name
= strdup(buf
);
267 joydev
.name
= joydev
.device
;
270 joydev
.guid
= DInput_Wine_Joystick_Base_GUID
;
271 joydev
.guid
.Data3
+= have_joydevs
;
273 TRACE("Found a joystick on %s: %s (%s)\n",
274 joydev
.device
, joydev
.name
,
275 debugstr_guid(&joydev
.guid
)
278 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
280 test_bit(joydev
.evbits
, EV_FF
) &&
281 ioctl(fd
, EVIOCGBIT(EV_FF
, sizeof(joydev
.ffbits
)), joydev
.ffbits
) != -1 &&
282 ioctl(fd
, EVIOCGEFFECTS
, &joydev
.num_effects
) != -1 &&
283 joydev
.num_effects
> 0)
285 TRACE(" ... with force feedback\n");
290 for (j
=0;j
<ABS_MAX
;j
++) {
291 if (test_bit(joydev
.absbits
,j
)) {
292 if (-1!=ioctl(fd
,EVIOCGABS(j
),&(joydev
.axes
[j
]))) {
293 TRACE(" ... with axis %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
295 joydev
.axes
[j
].value
,
296 joydev
.axes
[j
].minimum
,
297 joydev
.axes
[j
].maximum
,
305 if (have_joydevs
==0) {
306 joydevs
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev
));
308 HeapReAlloc(GetProcessHeap(), 0, joydevs
, (1+have_joydevs
) * sizeof(struct JoyDev
));
310 memcpy(joydevs
+have_joydevs
, &joydev
, sizeof(struct JoyDev
));
319 static BOOL
joydev_enum_deviceA(DWORD dwDevType
, DWORD dwFlags
, LPDIDEVICEINSTANCEA lpddi
, DWORD version
, int id
)
323 if (id
>= have_joydevs
) {
327 if (!((dwDevType
== 0) ||
328 ((dwDevType
== DIDEVTYPE_JOYSTICK
) && (version
< 0x0800)) ||
329 (((dwDevType
== DI8DEVCLASS_GAMECTRL
) || (dwDevType
== DI8DEVTYPE_JOYSTICK
)) && (version
>= 0x0800))))
332 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
333 if (dwFlags
& DIEDFL_FORCEFEEDBACK
)
337 if (!(dwFlags
& DIEDFL_FORCEFEEDBACK
) || joydevs
[id
].has_ff
) {
338 lpddi
->guidInstance
= joydevs
[id
].guid
;
339 lpddi
->guidProduct
= DInput_Wine_Joystick_Base_GUID
;
341 lpddi
->guidFFDriver
= GUID_NULL
;
342 if (version
>= 0x0800)
343 lpddi
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
345 lpddi
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
347 strcpy(lpddi
->tszInstanceName
, joydevs
[id
].name
);
348 strcpy(lpddi
->tszProductName
, joydevs
[id
].device
);
354 static BOOL
joydev_enum_deviceW(DWORD dwDevType
, DWORD dwFlags
, LPDIDEVICEINSTANCEW lpddi
, DWORD version
, int id
)
358 if (id
>= have_joydevs
) {
362 if (!((dwDevType
== 0) ||
363 ((dwDevType
== DIDEVTYPE_JOYSTICK
) && (version
< 0x0800)) ||
364 (((dwDevType
== DI8DEVCLASS_GAMECTRL
) || (dwDevType
== DI8DEVTYPE_JOYSTICK
)) && (version
>= 0x0800))))
367 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
368 if (dwFlags
& DIEDFL_FORCEFEEDBACK
)
372 if (!(dwFlags
& DIEDFL_FORCEFEEDBACK
) || joydevs
[id
].has_ff
) {
373 lpddi
->guidInstance
= joydevs
[id
].guid
;
374 lpddi
->guidProduct
= DInput_Wine_Joystick_Base_GUID
;
376 lpddi
->guidFFDriver
= GUID_NULL
;
377 if (version
>= 0x0800)
378 lpddi
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
380 lpddi
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
382 MultiByteToWideChar(CP_ACP
, 0, joydevs
[id
].name
, -1, lpddi
->tszInstanceName
, MAX_PATH
);
383 MultiByteToWideChar(CP_ACP
, 0, joydevs
[id
].device
, -1, lpddi
->tszProductName
, MAX_PATH
);
389 static JoystickImpl
*alloc_device(REFGUID rguid
, const void *jvt
, IDirectInputImpl
*dinput
, unsigned short index
)
391 JoystickImpl
* newDevice
;
392 LPDIDATAFORMAT df
= NULL
;
395 newDevice
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(JoystickImpl
));
396 if (!newDevice
) return NULL
;
398 newDevice
->base
.lpVtbl
= jvt
;
399 newDevice
->base
.ref
= 1;
400 memcpy(&newDevice
->base
.guid
, rguid
, sizeof(*rguid
));
401 InitializeCriticalSection(&newDevice
->base
.crit
);
402 newDevice
->base
.crit
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": JoystickImpl*->base.crit");
403 newDevice
->joyfd
= -1;
404 newDevice
->base
.dinput
= dinput
;
405 newDevice
->joydev
= &joydevs
[index
];
406 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
407 newDevice
->ff_state
= FF_STATUS_STOPPED
;
410 /* Create copy of default data format */
411 if (!(df
= HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2
.dwSize
))) goto failed
;
412 memcpy(df
, &c_dfDIJoystick2
, c_dfDIJoystick2
.dwSize
);
413 if (!(df
->rgodf
= HeapAlloc(GetProcessHeap(), 0, df
->dwNumObjs
* df
->dwObjSize
))) goto failed
;
415 /* Supported Axis & POVs should map 1-to-1 */
416 for (i
= 0; i
< WINE_JOYSTICK_MAX_AXES
; i
++)
418 if (!test_bit(newDevice
->joydev
->absbits
, i
)) {
419 newDevice
->axes
[i
] = -1;
423 memcpy(&df
->rgodf
[idx
], &c_dfDIJoystick2
.rgodf
[i
], df
->dwObjSize
);
424 newDevice
->axes
[i
] = idx
;
425 newDevice
->props
[idx
].lDevMin
= newDevice
->joydev
->axes
[i
].minimum
;
426 newDevice
->props
[idx
].lDevMax
= newDevice
->joydev
->axes
[i
].maximum
;
427 newDevice
->props
[idx
].lMin
= 0;
428 newDevice
->props
[idx
].lMax
= 0xffff;
429 newDevice
->props
[idx
].lSaturation
= 0;
430 newDevice
->props
[idx
].lDeadZone
= MulDiv(newDevice
->joydev
->axes
[i
].flat
, 0xffff,
431 newDevice
->props
[idx
].lDevMax
- newDevice
->props
[idx
].lDevMin
);
433 df
->rgodf
[idx
++].dwType
= DIDFT_MAKEINSTANCE(newDevice
->numAxes
++) | DIDFT_ABSAXIS
;
436 for (i
= 0; i
< WINE_JOYSTICK_MAX_POVS
; i
++)
438 if (!test_bit(newDevice
->joydev
->absbits
, ABS_HAT0X
+ i
* 2) ||
439 !test_bit(newDevice
->joydev
->absbits
, ABS_HAT0Y
+ i
* 2)) {
440 newDevice
->axes
[ABS_HAT0X
+ i
* 2] = newDevice
->axes
[ABS_HAT0Y
+ i
* 2] = -1;
444 memcpy(&df
->rgodf
[idx
], &c_dfDIJoystick2
.rgodf
[i
+ WINE_JOYSTICK_MAX_AXES
], df
->dwObjSize
);
445 newDevice
->axes
[ABS_HAT0X
+ i
* 2] = newDevice
->axes
[ABS_HAT0Y
+ i
* 2] = i
;
446 df
->rgodf
[idx
++].dwType
= DIDFT_MAKEINSTANCE(newDevice
->numPOVs
++) | DIDFT_POV
;
449 /* Buttons can be anywhere, so check all */
450 for (i
= 0; i
< KEY_MAX
&& newDevice
->numButtons
< WINE_JOYSTICK_MAX_BUTTONS
; i
++)
452 if (!test_bit(newDevice
->joydev
->keybits
, i
)) continue;
454 memcpy(&df
->rgodf
[idx
], &c_dfDIJoystick2
.rgodf
[newDevice
->numButtons
+ WINE_JOYSTICK_MAX_AXES
+ WINE_JOYSTICK_MAX_POVS
], df
->dwObjSize
);
455 newDevice
->buttons
[i
] = 0x80 | newDevice
->numButtons
;
456 df
->rgodf
[idx
++].dwType
= DIDFT_MAKEINSTANCE(newDevice
->numButtons
++) | DIDFT_PSHBUTTON
;
460 fake_current_js_state(newDevice
);
462 newDevice
->base
.data_format
.wine_df
= df
;
463 IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A
)newDevice
->base
.dinput
);
467 if (df
) HeapFree(GetProcessHeap(), 0, df
->rgodf
);
468 HeapFree(GetProcessHeap(), 0, df
);
469 HeapFree(GetProcessHeap(), 0, newDevice
);
473 /******************************************************************************
474 * get_joystick_index : Get the joystick index from a given GUID
476 static unsigned short get_joystick_index(REFGUID guid
)
478 GUID wine_joystick
= DInput_Wine_Joystick_Base_GUID
;
479 GUID dev_guid
= *guid
;
481 wine_joystick
.Data3
= 0;
484 /* for the standard joystick GUID use index 0 */
485 if(IsEqualGUID(&GUID_Joystick
,guid
)) return 0;
487 /* for the wine joystick GUIDs use the index stored in Data3 */
488 if(IsEqualGUID(&wine_joystick
, &dev_guid
)) return guid
->Data3
- DInput_Wine_Joystick_Base_GUID
.Data3
;
493 static HRESULT
joydev_create_deviceA(IDirectInputImpl
*dinput
, REFGUID rguid
, REFIID riid
, LPDIRECTINPUTDEVICEA
* pdev
)
495 unsigned short index
;
499 if ((index
= get_joystick_index(rguid
)) < MAX_JOYDEV
&&
500 have_joydevs
&& index
< have_joydevs
)
502 if ((riid
== NULL
) ||
503 IsEqualGUID(&IID_IDirectInputDeviceA
, riid
) ||
504 IsEqualGUID(&IID_IDirectInputDevice2A
, riid
) ||
505 IsEqualGUID(&IID_IDirectInputDevice7A
, riid
) ||
506 IsEqualGUID(&IID_IDirectInputDevice8A
, riid
))
508 *pdev
= (IDirectInputDeviceA
*) alloc_device(rguid
, &JoystickAvt
, dinput
, index
);
509 TRACE("Created a Joystick device (%p)\n", *pdev
);
513 ERR("out of memory\n");
514 return DIERR_OUTOFMEMORY
;
519 WARN("no interface\n");
520 return DIERR_NOINTERFACE
;
523 WARN("invalid device GUID\n");
524 return DIERR_DEVICENOTREG
;
528 static HRESULT
joydev_create_deviceW(IDirectInputImpl
*dinput
, REFGUID rguid
, REFIID riid
, LPDIRECTINPUTDEVICEW
* pdev
)
530 unsigned short index
;
534 if ((index
= get_joystick_index(rguid
)) < MAX_JOYDEV
&&
535 have_joydevs
&& index
< have_joydevs
)
537 if ((riid
== NULL
) ||
538 IsEqualGUID(&IID_IDirectInputDeviceW
, riid
) ||
539 IsEqualGUID(&IID_IDirectInputDevice2W
, riid
) ||
540 IsEqualGUID(&IID_IDirectInputDevice7W
, riid
) ||
541 IsEqualGUID(&IID_IDirectInputDevice8W
, riid
))
543 *pdev
= (IDirectInputDeviceW
*) alloc_device(rguid
, &JoystickWvt
, dinput
, index
);
544 TRACE("Created a Joystick device (%p)\n", *pdev
);
548 ERR("out of memory\n");
549 return DIERR_OUTOFMEMORY
;
553 WARN("no interface\n");
554 return DIERR_NOINTERFACE
;
557 WARN("invalid device GUID\n");
558 return DIERR_DEVICENOTREG
;
561 const struct dinput_device joystick_linuxinput_device
= {
562 "Wine Linux-input joystick driver",
565 joydev_create_deviceA
,
566 joydev_create_deviceW
569 /******************************************************************************
570 * Acquire : gets exclusive control of the joystick
572 static HRESULT WINAPI
JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface
)
574 JoystickImpl
*This
= (JoystickImpl
*)iface
;
577 TRACE("(this=%p)\n",This
);
579 res
= IDirectInputDevice2AImpl_Acquire(iface
);
581 if (-1==(This
->joyfd
=open(This
->joydev
->device
,O_RDWR
))) {
582 if (-1==(This
->joyfd
=open(This
->joydev
->device
,O_RDONLY
))) {
583 /* Couldn't open the device at all */
584 perror(This
->joydev
->device
);
585 IDirectInputDevice2AImpl_Unacquire(iface
);
586 return DIERR_NOTFOUND
;
588 /* Couldn't open in r/w but opened in read-only. */
589 WARN("Could not open %s in read-write mode. Force feedback will be disabled.\n", This
->joydev
->device
);
597 /******************************************************************************
598 * Unacquire : frees the joystick
600 static HRESULT WINAPI
JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface
)
602 JoystickImpl
*This
= (JoystickImpl
*)iface
;
605 TRACE("(this=%p)\n",This
);
606 res
= IDirectInputDevice2AImpl_Unacquire(iface
);
607 if (res
==DI_OK
&& This
->joyfd
!=-1) {
615 * set the current state of the js device as it would be with the middle
618 #define CENTER_AXIS(a) \
619 (ji->axes[a] == -1 ? 0 : joystick_map_axis( &ji->props[ji->axes[a]], \
620 ji->joydev->axes[a].value ))
621 static void fake_current_js_state(JoystickImpl
*ji
)
625 /* center the axes */
626 ji
->js
.lX
= CENTER_AXIS(ABS_X
);
627 ji
->js
.lY
= CENTER_AXIS(ABS_Y
);
628 ji
->js
.lZ
= CENTER_AXIS(ABS_Z
);
629 ji
->js
.lRx
= CENTER_AXIS(ABS_RX
);
630 ji
->js
.lRy
= CENTER_AXIS(ABS_RY
);
631 ji
->js
.lRz
= CENTER_AXIS(ABS_RZ
);
632 ji
->js
.rglSlider
[0] = CENTER_AXIS(ABS_THROTTLE
);
633 ji
->js
.rglSlider
[1] = CENTER_AXIS(ABS_RUDDER
);
635 /* POV center is -1 */
636 for (i
= 0; i
< 4; i
++)
637 ji
->js
.rgdwPOV
[i
] = -1;
641 /* convert wine format offset to user format object index */
642 static void joy_polldev(JoystickImpl
*This
)
645 struct input_event ie
;
655 plfd
.fd
= This
->joyfd
;
656 plfd
.events
= POLLIN
;
658 if (poll(&plfd
,1,0) != 1)
661 /* we have one event, so we can read */
662 if (sizeof(ie
)!=read(This
->joyfd
,&ie
,sizeof(ie
)))
665 TRACE("input_event: type %d, code %d, value %d\n",ie
.type
,ie
.code
,ie
.value
);
667 case EV_KEY
: /* button */
669 int btn
= This
->buttons
[ie
.code
];
671 TRACE("(%p) %d -> %d\n", This
, ie
.code
, btn
);
675 inst_id
= DIDFT_MAKEINSTANCE(btn
) | DIDFT_PSHBUTTON
;
676 This
->js
.rgbButtons
[btn
] = value
= ie
.value
? 0x80 : 0x00;
682 int axis
= This
->axes
[ie
.code
];
686 inst_id
= DIDFT_MAKEINSTANCE(axis
) | (ie
.code
< ABS_HAT0X
? DIDFT_ABSAXIS
: DIDFT_POV
);
687 value
= joystick_map_axis(&This
->props
[id_to_object(This
->base
.data_format
.wine_df
, inst_id
)], ie
.value
);
690 case ABS_X
: This
->js
.lX
= value
; break;
691 case ABS_Y
: This
->js
.lY
= value
; break;
692 case ABS_Z
: This
->js
.lZ
= value
; break;
693 case ABS_RX
: This
->js
.lRx
= value
; break;
694 case ABS_RY
: This
->js
.lRy
= value
; break;
695 case ABS_RZ
: This
->js
.lRz
= value
; break;
696 case ABS_THROTTLE
: This
->js
.rglSlider
[0] = value
; break;
697 case ABS_RUDDER
: This
->js
.rglSlider
[1] = value
; break;
698 case ABS_HAT0X
: case ABS_HAT0Y
: case ABS_HAT1X
: case ABS_HAT1Y
:
699 case ABS_HAT2X
: case ABS_HAT2Y
: case ABS_HAT3X
: case ABS_HAT3Y
:
701 int idx
= (ie
.code
- ABS_HAT0X
) / 2;
704 This
->povs
[idx
].y
= ie
.value
;
706 This
->povs
[idx
].x
= ie
.value
;
708 This
->js
.rgdwPOV
[idx
] = value
= joystick_map_pov(&This
->povs
[idx
]);
712 FIXME("unhandled joystick axis event (code %d, value %d)\n",ie
.code
,ie
.value
);
716 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
718 This
->ff_state
= ie
.value
;
723 /* there is nothing to do */
727 FIXME("joystick cannot handle type %d event (code %d)\n",ie
.type
,ie
.code
);
731 queue_event((LPDIRECTINPUTDEVICE8A
)This
,
732 id_to_offset(&This
->base
.data_format
, inst_id
),
733 value
, ie
.time
.tv_usec
, This
->base
.dinput
->evsequence
++);
737 /******************************************************************************
738 * GetDeviceState : returns the "state" of the joystick.
741 static HRESULT WINAPI
JoystickAImpl_GetDeviceState(
742 LPDIRECTINPUTDEVICE8A iface
,DWORD len
,LPVOID ptr
744 JoystickImpl
*This
= (JoystickImpl
*)iface
;
746 TRACE("(this=%p,0x%08x,%p)\n", This
, len
, ptr
);
748 if (!This
->base
.acquired
)
750 WARN("not acquired\n");
751 return DIERR_NOTACQUIRED
;
756 /* convert and copy data to user supplied buffer */
757 fill_DataFormat(ptr
, &This
->js
, &This
->base
.data_format
);
762 /******************************************************************************
763 * SetProperty : change input device properties
765 static HRESULT WINAPI
JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface
,
769 JoystickImpl
*This
= (JoystickImpl
*)iface
;
772 WARN("invalid argument\n");
773 return DIERR_INVALIDPARAM
;
776 TRACE("(this=%p,%s,%p)\n",This
,debugstr_guid(rguid
),ph
);
777 TRACE("ph.dwSize = %d, ph.dwHeaderSize =%d, ph.dwObj = %d, ph.dwHow= %d\n",
778 ph
->dwSize
, ph
->dwHeaderSize
, ph
->dwObj
, ph
->dwHow
);
780 if (!HIWORD(rguid
)) {
781 switch (LOWORD(rguid
)) {
782 case (DWORD
)DIPROP_RANGE
: {
783 LPCDIPROPRANGE pr
= (LPCDIPROPRANGE
)ph
;
785 if (ph
->dwHow
== DIPH_DEVICE
) {
787 TRACE("proprange(%d,%d) all\n", pr
->lMin
, pr
->lMax
);
788 for (i
= 0; i
< This
->base
.data_format
.wine_df
->dwNumObjs
; i
++) {
789 /* Scale dead-zone */
790 This
->props
[i
].lDeadZone
= MulDiv(This
->props
[i
].lDeadZone
, pr
->lMax
- pr
->lMin
,
791 This
->props
[i
].lMax
- This
->props
[i
].lMin
);
792 This
->props
[i
].lMin
= pr
->lMin
;
793 This
->props
[i
].lMax
= pr
->lMax
;
796 int obj
= find_property(&This
->base
.data_format
, ph
);
798 TRACE("proprange(%d,%d) obj=%d\n", pr
->lMin
, pr
->lMax
, obj
);
800 /* Scale dead-zone */
801 This
->props
[obj
].lDeadZone
= MulDiv(This
->props
[obj
].lDeadZone
, pr
->lMax
- pr
->lMin
,
802 This
->props
[obj
].lMax
- This
->props
[obj
].lMin
);
803 This
->props
[obj
].lMin
= pr
->lMin
;
804 This
->props
[obj
].lMax
= pr
->lMax
;
807 fake_current_js_state(This
);
810 case (DWORD
)DIPROP_DEADZONE
: {
811 LPCDIPROPDWORD pd
= (LPCDIPROPDWORD
)ph
;
812 if (ph
->dwHow
== DIPH_DEVICE
) {
814 TRACE("deadzone(%d) all\n", pd
->dwData
);
815 for (i
= 0; i
< This
->base
.data_format
.wine_df
->dwNumObjs
; i
++) {
816 This
->props
[i
].lDeadZone
= pd
->dwData
;
819 int obj
= find_property(&This
->base
.data_format
, ph
);
821 TRACE("deadzone(%d) obj=%d\n", pd
->dwData
, obj
);
823 This
->props
[obj
].lDeadZone
= pd
->dwData
;
826 fake_current_js_state(This
);
829 case (DWORD
)DIPROP_CALIBRATIONMODE
: {
830 LPCDIPROPDWORD pd
= (LPCDIPROPDWORD
)ph
;
831 FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd
->dwData
);
835 return IDirectInputDevice2AImpl_SetProperty(iface
, rguid
, ph
);
841 static HRESULT WINAPI
JoystickAImpl_GetCapabilities(
842 LPDIRECTINPUTDEVICE8A iface
,
843 LPDIDEVCAPS lpDIDevCaps
)
845 JoystickImpl
*This
= (JoystickImpl
*)iface
;
847 TRACE("%p->(%p)\n",iface
,lpDIDevCaps
);
850 WARN("invalid pointer\n");
854 if (lpDIDevCaps
->dwSize
!= sizeof(DIDEVCAPS
)) {
855 WARN("invalid argument\n");
856 return DIERR_INVALIDPARAM
;
859 lpDIDevCaps
->dwFlags
= DIDC_ATTACHED
;
860 if (This
->base
.dinput
->dwVersion
>= 0x0800)
861 lpDIDevCaps
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
863 lpDIDevCaps
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
865 if (This
->joydev
->has_ff
)
866 lpDIDevCaps
->dwFlags
|= DIDC_FORCEFEEDBACK
;
868 lpDIDevCaps
->dwAxes
= This
->numAxes
;
869 lpDIDevCaps
->dwButtons
= This
->numButtons
;
870 lpDIDevCaps
->dwPOVs
= This
->numPOVs
;
875 static HRESULT WINAPI
JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface
)
877 JoystickImpl
*This
= (JoystickImpl
*)iface
;
879 TRACE("(%p)\n",This
);
881 if (!This
->base
.acquired
)
882 return DIERR_NOTACQUIRED
;
888 /******************************************************************************
889 * GetProperty : get input device properties
891 static HRESULT WINAPI
JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface
,
893 LPDIPROPHEADER pdiph
)
895 JoystickImpl
*This
= (JoystickImpl
*)iface
;
897 TRACE("(this=%p,%s,%p)\n", iface
, debugstr_guid(rguid
), pdiph
);
898 _dump_DIPROPHEADER(pdiph
);
900 if (HIWORD(rguid
)) return DI_OK
;
902 switch (LOWORD(rguid
)) {
903 case (DWORD
) DIPROP_RANGE
:
905 LPDIPROPRANGE pr
= (LPDIPROPRANGE
) pdiph
;
906 int obj
= find_property(&This
->base
.data_format
, pdiph
);
908 if (obj
< 0) return DIERR_OBJECTNOTFOUND
;
910 pr
->lMin
= This
->props
[obj
].lMin
;
911 pr
->lMax
= This
->props
[obj
].lMax
;
912 TRACE("range(%d, %d) obj=%d\n", pr
->lMin
, pr
->lMax
, obj
);
915 case (DWORD
) DIPROP_DEADZONE
:
917 LPDIPROPDWORD pd
= (LPDIPROPDWORD
)pdiph
;
918 int obj
= find_property(&This
->base
.data_format
, pdiph
);
920 if (obj
< 0) return DIERR_OBJECTNOTFOUND
;
922 pd
->dwData
= This
->props
[obj
].lDeadZone
;
923 TRACE("deadzone(%d) obj=%d\n", pd
->dwData
, obj
);
928 return IDirectInputDevice2AImpl_GetProperty(iface
, rguid
, pdiph
);
934 /******************************************************************************
935 * GetObjectInfo : get information about a device object such as a button
938 static HRESULT WINAPI
JoystickWImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface
,
939 LPDIDEVICEOBJECTINSTANCEW pdidoi
, DWORD dwObj
, DWORD dwHow
)
941 static const WCHAR axisW
[] = {'A','x','i','s',' ','%','d',0};
942 static const WCHAR povW
[] = {'P','O','V',' ','%','d',0};
943 static const WCHAR buttonW
[] = {'B','u','t','t','o','n',' ','%','d',0};
946 res
= IDirectInputDevice2WImpl_GetObjectInfo(iface
, pdidoi
, dwObj
, dwHow
);
947 if (res
!= DI_OK
) return res
;
949 if (pdidoi
->dwType
& DIDFT_AXIS
)
950 sprintfW(pdidoi
->tszName
, axisW
, DIDFT_GETINSTANCE(pdidoi
->dwType
));
951 else if (pdidoi
->dwType
& DIDFT_POV
)
952 sprintfW(pdidoi
->tszName
, povW
, DIDFT_GETINSTANCE(pdidoi
->dwType
));
953 else if (pdidoi
->dwType
& DIDFT_BUTTON
)
954 sprintfW(pdidoi
->tszName
, buttonW
, DIDFT_GETINSTANCE(pdidoi
->dwType
));
956 _dump_OBJECTINSTANCEW(pdidoi
);
960 static HRESULT WINAPI
JoystickAImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface
,
961 LPDIDEVICEOBJECTINSTANCEA pdidoi
, DWORD dwObj
, DWORD dwHow
)
964 DIDEVICEOBJECTINSTANCEW didoiW
;
965 DWORD dwSize
= pdidoi
->dwSize
;
967 didoiW
.dwSize
= sizeof(didoiW
);
968 res
= JoystickWImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W
)iface
, &didoiW
, dwObj
, dwHow
);
969 if (res
!= DI_OK
) return res
;
971 memset(pdidoi
, 0, pdidoi
->dwSize
);
972 memcpy(pdidoi
, &didoiW
, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW
, tszName
));
973 pdidoi
->dwSize
= dwSize
;
974 WideCharToMultiByte(CP_ACP
, 0, didoiW
.tszName
, -1, pdidoi
->tszName
,
975 sizeof(pdidoi
->tszName
), NULL
, NULL
);
980 /******************************************************************************
981 * CreateEffect - Create a new FF effect with the specified params
983 static HRESULT WINAPI
JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface
,
986 LPDIRECTINPUTEFFECT
*ppdef
,
989 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
990 EffectListItem
* new = NULL
;
991 HRESULT retval
= DI_OK
;
994 JoystickImpl
* This
= (JoystickImpl
*)iface
;
995 TRACE("(this=%p,%p,%p,%p,%p)\n", This
, rguid
, lpeff
, ppdef
, pUnkOuter
);
997 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
998 TRACE("not available (compiled w/o ff support)\n");
1003 new = HeapAlloc(GetProcessHeap(), 0, sizeof(EffectListItem
));
1004 new->next
= This
->top_effect
;
1005 This
->top_effect
= new;
1007 retval
= linuxinput_create_effect(&(This
->joyfd
), rguid
, &(new->ref
));
1008 if (retval
!= DI_OK
)
1012 retval
= IDirectInputEffect_SetParameters(new->ref
, lpeff
, 0);
1013 if (retval
!= DI_OK
&& retval
!= DI_DOWNLOADSKIPPED
)
1018 if (pUnkOuter
!= NULL
)
1019 FIXME("Interface aggregation not implemented.\n");
1023 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1026 /*******************************************************************************
1027 * EnumEffects - Enumerate available FF effects
1029 static HRESULT WINAPI
JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface
,
1030 LPDIENUMEFFECTSCALLBACKA lpCallback
,
1034 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1035 DIEFFECTINFOA dei
; /* feif */
1036 DWORD type
= DIEFT_GETTYPE(dwEffType
);
1037 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1039 TRACE("(this=%p,%p,%d) type=%d\n", This
, pvRef
, dwEffType
, type
);
1041 dei
.dwSize
= sizeof(DIEFFECTINFOA
);
1043 if ((type
== DIEFT_ALL
|| type
== DIEFT_CONSTANTFORCE
)
1044 && test_bit(This
->joydev
->ffbits
, FF_CONSTANT
)) {
1045 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_ConstantForce
);
1046 (*lpCallback
)(&dei
, pvRef
);
1049 if ((type
== DIEFT_ALL
|| type
== DIEFT_PERIODIC
)
1050 && test_bit(This
->joydev
->ffbits
, FF_PERIODIC
)) {
1051 if (test_bit(This
->joydev
->ffbits
, FF_SQUARE
)) {
1052 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Square
);
1053 (*lpCallback
)(&dei
, pvRef
);
1055 if (test_bit(This
->joydev
->ffbits
, FF_SINE
)) {
1056 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Sine
);
1057 (*lpCallback
)(&dei
, pvRef
);
1059 if (test_bit(This
->joydev
->ffbits
, FF_TRIANGLE
)) {
1060 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Triangle
);
1061 (*lpCallback
)(&dei
, pvRef
);
1063 if (test_bit(This
->joydev
->ffbits
, FF_SAW_UP
)) {
1064 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothUp
);
1065 (*lpCallback
)(&dei
, pvRef
);
1067 if (test_bit(This
->joydev
->ffbits
, FF_SAW_DOWN
)) {
1068 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothDown
);
1069 (*lpCallback
)(&dei
, pvRef
);
1073 if ((type
== DIEFT_ALL
|| type
== DIEFT_RAMPFORCE
)
1074 && test_bit(This
->joydev
->ffbits
, FF_RAMP
)) {
1075 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_RampForce
);
1076 (*lpCallback
)(&dei
, pvRef
);
1079 if (type
== DIEFT_ALL
|| type
== DIEFT_CONDITION
) {
1080 if (test_bit(This
->joydev
->ffbits
, FF_SPRING
)) {
1081 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Spring
);
1082 (*lpCallback
)(&dei
, pvRef
);
1084 if (test_bit(This
->joydev
->ffbits
, FF_DAMPER
)) {
1085 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Damper
);
1086 (*lpCallback
)(&dei
, pvRef
);
1088 if (test_bit(This
->joydev
->ffbits
, FF_INERTIA
)) {
1089 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Inertia
);
1090 (*lpCallback
)(&dei
, pvRef
);
1092 if (test_bit(This
->joydev
->ffbits
, FF_FRICTION
)) {
1093 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Friction
);
1094 (*lpCallback
)(&dei
, pvRef
);
1103 static HRESULT WINAPI
JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface
,
1104 LPDIENUMEFFECTSCALLBACKW lpCallback
,
1108 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1109 /* seems silly to duplicate all this code but all the structures and functions
1110 * are actually different (A/W) */
1111 DIEFFECTINFOW dei
; /* feif */
1112 DWORD type
= DIEFT_GETTYPE(dwEffType
);
1113 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1114 int xfd
= This
->joyfd
;
1116 TRACE("(this=%p,%p,%d) type=%d fd=%d\n", This
, pvRef
, dwEffType
, type
, xfd
);
1118 dei
.dwSize
= sizeof(DIEFFECTINFOW
);
1120 if ((type
== DIEFT_ALL
|| type
== DIEFT_CONSTANTFORCE
)
1121 && test_bit(This
->joydev
->ffbits
, FF_CONSTANT
)) {
1122 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_ConstantForce
);
1123 (*lpCallback
)(&dei
, pvRef
);
1126 if ((type
== DIEFT_ALL
|| type
== DIEFT_PERIODIC
)
1127 && test_bit(This
->joydev
->ffbits
, FF_PERIODIC
)) {
1128 if (test_bit(This
->joydev
->ffbits
, FF_SQUARE
)) {
1129 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Square
);
1130 (*lpCallback
)(&dei
, pvRef
);
1132 if (test_bit(This
->joydev
->ffbits
, FF_SINE
)) {
1133 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Sine
);
1134 (*lpCallback
)(&dei
, pvRef
);
1136 if (test_bit(This
->joydev
->ffbits
, FF_TRIANGLE
)) {
1137 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Triangle
);
1138 (*lpCallback
)(&dei
, pvRef
);
1140 if (test_bit(This
->joydev
->ffbits
, FF_SAW_UP
)) {
1141 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothUp
);
1142 (*lpCallback
)(&dei
, pvRef
);
1144 if (test_bit(This
->joydev
->ffbits
, FF_SAW_DOWN
)) {
1145 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothDown
);
1146 (*lpCallback
)(&dei
, pvRef
);
1150 if ((type
== DIEFT_ALL
|| type
== DIEFT_RAMPFORCE
)
1151 && test_bit(This
->joydev
->ffbits
, FF_RAMP
)) {
1152 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_RampForce
);
1153 (*lpCallback
)(&dei
, pvRef
);
1156 if (type
== DIEFT_ALL
|| type
== DIEFT_CONDITION
) {
1157 if (test_bit(This
->joydev
->ffbits
, FF_SPRING
)) {
1158 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Spring
);
1159 (*lpCallback
)(&dei
, pvRef
);
1161 if (test_bit(This
->joydev
->ffbits
, FF_DAMPER
)) {
1162 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Damper
);
1163 (*lpCallback
)(&dei
, pvRef
);
1165 if (test_bit(This
->joydev
->ffbits
, FF_INERTIA
)) {
1166 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Inertia
);
1167 (*lpCallback
)(&dei
, pvRef
);
1169 if (test_bit(This
->joydev
->ffbits
, FF_FRICTION
)) {
1170 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Friction
);
1171 (*lpCallback
)(&dei
, pvRef
);
1175 /* return to unacquired state if that's where it was */
1177 IDirectInputDevice8_Unacquire(iface
);
1183 /*******************************************************************************
1184 * GetEffectInfo - Get information about a particular effect
1186 static HRESULT WINAPI
JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface
,
1187 LPDIEFFECTINFOA pdei
,
1190 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1192 TRACE("(this=%p,%p,%s)\n", This
, pdei
, _dump_dinput_GUID(guid
));
1194 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1195 return linuxinput_get_info_A(This
->joyfd
, guid
, pdei
);
1201 static HRESULT WINAPI
JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface
,
1202 LPDIEFFECTINFOW pdei
,
1205 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1207 TRACE("(this=%p,%p,%s)\n", This
, pdei
, _dump_dinput_GUID(guid
));
1209 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1210 return linuxinput_get_info_W(This
->joyfd
, guid
, pdei
);
1216 /*******************************************************************************
1217 * GetForceFeedbackState - Get information about the device's FF state
1219 static HRESULT WINAPI
JoystickAImpl_GetForceFeedbackState(
1220 LPDIRECTINPUTDEVICE8A iface
,
1223 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1225 TRACE("(this=%p,%p)\n", This
, pdwOut
);
1229 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1230 /* DIGFFS_STOPPED is the only mandatory flag to report */
1231 if (This
->ff_state
== FF_STATUS_STOPPED
)
1232 (*pdwOut
) |= DIGFFS_STOPPED
;
1238 /*******************************************************************************
1239 * SendForceFeedbackCommand - Send a command to the device's FF system
1241 static HRESULT WINAPI
JoystickAImpl_SendForceFeedbackCommand(
1242 LPDIRECTINPUTDEVICE8A iface
,
1245 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1246 TRACE("(this=%p,%d)\n", This
, dwFlags
);
1248 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1249 if (dwFlags
== DISFFC_STOPALL
) {
1250 /* Stop all effects */
1251 EffectListItem
* itr
= This
->top_effect
;
1253 IDirectInputEffect_Stop(itr
->ref
);
1256 } else if (dwFlags
== DISFFC_RESET
) {
1257 /* Stop, unload, release and free all effects */
1258 /* This returns the device to its "bare" state */
1259 while (This
->top_effect
) {
1260 EffectListItem
* temp
= This
->top_effect
;
1261 IDirectInputEffect_Stop(temp
->ref
);
1262 IDirectInputEffect_Unload(temp
->ref
);
1263 IDirectInputEffect_Release(temp
->ref
);
1264 This
->top_effect
= temp
->next
;
1265 HeapFree(GetProcessHeap(), 0, temp
);
1267 } else if (dwFlags
== DISFFC_PAUSE
|| dwFlags
== DISFFC_CONTINUE
) {
1268 FIXME("No support for Pause or Continue in linux\n");
1269 } else if (dwFlags
== DISFFC_SETACTUATORSOFF
1270 || dwFlags
== DISFFC_SETACTUATORSON
) {
1271 FIXME("No direct actuator control in linux\n");
1273 FIXME("Unknown Force Feedback Command!\n");
1274 return DIERR_INVALIDPARAM
;
1278 return DIERR_UNSUPPORTED
;
1282 /*******************************************************************************
1283 * EnumCreatedEffectObjects - Enumerate all the effects that have been
1284 * created for this device.
1286 static HRESULT WINAPI
JoystickAImpl_EnumCreatedEffectObjects(
1287 LPDIRECTINPUTDEVICE8A iface
,
1288 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback
,
1292 /* this function is safe to call on non-ff-enabled builds */
1294 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1295 EffectListItem
* itr
= This
->top_effect
;
1296 TRACE("(this=%p,%p,%p,%d)\n", This
, lpCallback
, pvRef
, dwFlags
);
1299 return DIERR_INVALIDPARAM
;
1302 FIXME("Flags specified, but no flags exist yet (DX9)!\n");
1305 (*lpCallback
)(itr
->ref
, pvRef
);
1312 static const IDirectInputDevice8AVtbl JoystickAvt
=
1314 IDirectInputDevice2AImpl_QueryInterface
,
1315 IDirectInputDevice2AImpl_AddRef
,
1316 IDirectInputDevice2AImpl_Release
,
1317 JoystickAImpl_GetCapabilities
,
1318 IDirectInputDevice2AImpl_EnumObjects
,
1319 JoystickAImpl_GetProperty
,
1320 JoystickAImpl_SetProperty
,
1321 JoystickAImpl_Acquire
,
1322 JoystickAImpl_Unacquire
,
1323 JoystickAImpl_GetDeviceState
,
1324 IDirectInputDevice2AImpl_GetDeviceData
,
1325 IDirectInputDevice2AImpl_SetDataFormat
,
1326 IDirectInputDevice2AImpl_SetEventNotification
,
1327 IDirectInputDevice2AImpl_SetCooperativeLevel
,
1328 JoystickAImpl_GetObjectInfo
,
1329 IDirectInputDevice2AImpl_GetDeviceInfo
,
1330 IDirectInputDevice2AImpl_RunControlPanel
,
1331 IDirectInputDevice2AImpl_Initialize
,
1332 JoystickAImpl_CreateEffect
,
1333 JoystickAImpl_EnumEffects
,
1334 JoystickAImpl_GetEffectInfo
,
1335 JoystickAImpl_GetForceFeedbackState
,
1336 JoystickAImpl_SendForceFeedbackCommand
,
1337 JoystickAImpl_EnumCreatedEffectObjects
,
1338 IDirectInputDevice2AImpl_Escape
,
1340 IDirectInputDevice2AImpl_SendDeviceData
,
1341 IDirectInputDevice7AImpl_EnumEffectsInFile
,
1342 IDirectInputDevice7AImpl_WriteEffectToFile
,
1343 IDirectInputDevice8AImpl_BuildActionMap
,
1344 IDirectInputDevice8AImpl_SetActionMap
,
1345 IDirectInputDevice8AImpl_GetImageInfo
1348 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1349 # define XCAST(fun) (typeof(JoystickWvt.fun))
1351 # define XCAST(fun) (void*)
1354 static const IDirectInputDevice8WVtbl JoystickWvt
=
1356 IDirectInputDevice2WImpl_QueryInterface
,
1357 XCAST(AddRef
)IDirectInputDevice2AImpl_AddRef
,
1358 XCAST(Release
)IDirectInputDevice2AImpl_Release
,
1359 XCAST(GetCapabilities
)JoystickAImpl_GetCapabilities
,
1360 IDirectInputDevice2WImpl_EnumObjects
,
1361 XCAST(GetProperty
)JoystickAImpl_GetProperty
,
1362 XCAST(SetProperty
)JoystickAImpl_SetProperty
,
1363 XCAST(Acquire
)JoystickAImpl_Acquire
,
1364 XCAST(Unacquire
)JoystickAImpl_Unacquire
,
1365 XCAST(GetDeviceState
)JoystickAImpl_GetDeviceState
,
1366 XCAST(GetDeviceData
)IDirectInputDevice2AImpl_GetDeviceData
,
1367 XCAST(SetDataFormat
)IDirectInputDevice2AImpl_SetDataFormat
,
1368 XCAST(SetEventNotification
)IDirectInputDevice2AImpl_SetEventNotification
,
1369 XCAST(SetCooperativeLevel
)IDirectInputDevice2AImpl_SetCooperativeLevel
,
1370 JoystickWImpl_GetObjectInfo
,
1371 IDirectInputDevice2WImpl_GetDeviceInfo
,
1372 XCAST(RunControlPanel
)IDirectInputDevice2AImpl_RunControlPanel
,
1373 XCAST(Initialize
)IDirectInputDevice2AImpl_Initialize
,
1374 XCAST(CreateEffect
)JoystickAImpl_CreateEffect
,
1375 JoystickWImpl_EnumEffects
,
1376 JoystickWImpl_GetEffectInfo
,
1377 XCAST(GetForceFeedbackState
)JoystickAImpl_GetForceFeedbackState
,
1378 XCAST(SendForceFeedbackCommand
)JoystickAImpl_SendForceFeedbackCommand
,
1379 XCAST(EnumCreatedEffectObjects
)JoystickAImpl_EnumCreatedEffectObjects
,
1380 XCAST(Escape
)IDirectInputDevice2AImpl_Escape
,
1381 XCAST(Poll
)JoystickAImpl_Poll
,
1382 XCAST(SendDeviceData
)IDirectInputDevice2AImpl_SendDeviceData
,
1383 IDirectInputDevice7WImpl_EnumEffectsInFile
,
1384 IDirectInputDevice7WImpl_WriteEffectToFile
,
1385 IDirectInputDevice8WImpl_BuildActionMap
,
1386 IDirectInputDevice8WImpl_SetActionMap
,
1387 IDirectInputDevice8WImpl_GetImageInfo
1391 #else /* HAVE_CORRECT_LINUXINPUT_H */
1393 const struct dinput_device joystick_linuxinput_device
= {
1394 "Wine Linux-input joystick driver",
1401 #endif /* HAVE_CORRECT_LINUXINPUT_H */