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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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>
47 # if defined(EVIOCGBIT) && defined(EV_ABS) && defined(BTN_PINKIE)
48 # define HAVE_CORRECT_LINUXINPUT_H
52 #include "wine/debug.h"
53 #include "wine/unicode.h"
59 #include "dinput_private.h"
60 #include "device_private.h"
62 WINE_DEFAULT_DEBUG_CHANNEL(dinput
);
64 #ifdef HAVE_CORRECT_LINUXINPUT_H
66 #define EVDEVPREFIX "/dev/input/event"
68 /* Wine joystick driver object instances */
69 #define WINE_JOYSTICK_AXIS_BASE 0
70 #define WINE_JOYSTICK_BUTTON_BASE 8
72 typedef struct EffectListItem EffectListItem
;
75 LPDIRECTINPUTEFFECT ref
;
76 struct EffectListItem
* next
;
79 /* implemented in effect_linuxinput.c */
80 HRESULT
linuxinput_create_effect(int* fd
, REFGUID rguid
, LPDIRECTINPUTEFFECT
* peff
);
81 HRESULT
linuxinput_get_info_A(int fd
, REFGUID rguid
, LPDIEFFECTINFOA info
);
82 HRESULT
linuxinput_get_info_W(int fd
, REFGUID rguid
, LPDIEFFECTINFOW info
);
84 typedef struct JoystickImpl JoystickImpl
;
85 static const IDirectInputDevice8AVtbl JoystickAvt
;
86 static const IDirectInputDevice8WVtbl JoystickWvt
;
94 /* The 'parent' DInput */
95 IDirectInputImpl
*dinput
;
97 /* joystick private */
98 /* what range and deadzone the game wants */
99 LONG wantmin
[ABS_MAX
];
100 LONG wantmax
[ABS_MAX
];
103 /* autodetecting ranges per axe by following movement */
104 LONG havemax
[ABS_MAX
];
105 LONG havemin
[ABS_MAX
];
111 LPDIDEVICEOBJECTDATA data_queue
;
112 int queue_head
, queue_tail
, queue_len
;
116 /* Force feedback variables */
119 EffectListItem
* top_effect
;
122 /* data returned by the EVIOCGABS() ioctl */
123 int axes
[ABS_MAX
][5];
124 /* LUT for KEY_ to offset in rgbButtons */
125 BYTE buttons
[KEY_MAX
];
130 #define AXE_ABSFUZZ 3
131 #define AXE_ABSFLAT 4
134 /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
135 BYTE evbits
[(EV_MAX
+7)/8];
136 BYTE absbits
[(ABS_MAX
+7)/8];
137 BYTE keybits
[(KEY_MAX
+7)/8];
138 BYTE ffbits
[(FF_MAX
+7)/8];
141 /* This GUID is slightly different from the linux joystick one. Take note. */
142 static GUID DInput_Wine_Joystick_GUID
= { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
146 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
149 static void fake_current_js_state(JoystickImpl
*ji
);
150 static int find_property_offset(JoystickImpl
*This
, LPCDIPROPHEADER ph
);
152 #define test_bit(arr,bit) (((BYTE*)arr)[bit>>3]&(1<<(bit&7)))
154 static int joydev_have(BOOL require_ff
)
156 int i
, fd
, flags
, num_effects
;
161 BYTE absbits
[(ABS_MAX
+7)/8],keybits
[(KEY_MAX
+7)/8];
162 BYTE evbits
[(EV_MAX
+7)/8],ffbits
[(FF_MAX
+7)/8];
164 sprintf(buf
,EVDEVPREFIX
"%d",i
);
171 if (-1!=(fd
=open(buf
,flags
))) {
172 if (-1==ioctl(fd
,EVIOCGBIT(EV_ABS
,sizeof(absbits
)),absbits
)) {
173 perror("EVIOCGBIT EV_ABS");
177 if (-1==ioctl(fd
,EVIOCGBIT(EV_KEY
,sizeof(keybits
)),keybits
)) {
178 perror("EVIOCGBIT EV_KEY");
183 /* test for force feedback if it's required */
185 if ((-1==ioctl(fd
,EVIOCGBIT(0,sizeof(evbits
)),evbits
))) {
186 perror("EVIOCGBIT 0");
190 if ( (!test_bit(evbits
,EV_FF
))
191 || (-1==ioctl(fd
,EVIOCGBIT(EV_FF
,sizeof(ffbits
)),ffbits
))
192 || (-1==ioctl(fd
,EVIOCGEFFECTS
,&num_effects
))
193 || (num_effects
<= 0)) {
199 /* A true joystick has at least axis X and Y, and at least 1
200 * button. copied from linux/drivers/input/joydev.c */
201 if (test_bit(absbits
,ABS_X
) && test_bit(absbits
,ABS_Y
) &&
202 ( test_bit(keybits
,BTN_TRIGGER
) ||
203 test_bit(keybits
,BTN_A
) ||
204 test_bit(keybits
,BTN_1
)
207 FIXME("found a joystick at %s!\n",buf
);
212 if (havejoy
|| (errno
==ENODEV
))
218 static BOOL
joydev_enum_deviceA(DWORD dwDevType
, DWORD dwFlags
, LPDIDEVICEINSTANCEA lpddi
, DWORD version
, int id
)
225 if (!((dwDevType
== 0) ||
226 ((dwDevType
== DIDEVTYPE_JOYSTICK
) && (version
< 0x0800)) ||
227 (((dwDevType
== DI8DEVCLASS_GAMECTRL
) || (dwDevType
== DI8DEVTYPE_JOYSTICK
)) && (version
>= 0x0800))))
230 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
231 if (dwFlags
& DIEDFL_FORCEFEEDBACK
)
235 havejoy
= joydev_have(dwFlags
& DIEDFL_FORCEFEEDBACK
);
240 TRACE("Enumerating the linuxinput Joystick device\n");
242 /* Return joystick */
243 lpddi
->guidInstance
= GUID_Joystick
;
244 lpddi
->guidProduct
= DInput_Wine_Joystick_GUID
;
246 lpddi
->guidFFDriver
= GUID_NULL
;
247 if (version
>= 0x0800)
248 lpddi
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
250 lpddi
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
252 strcpy(lpddi
->tszInstanceName
, "Joystick");
253 /* ioctl JSIOCGNAME(len) */
254 strcpy(lpddi
->tszProductName
, "Wine Joystick");
258 static BOOL
joydev_enum_deviceW(DWORD dwDevType
, DWORD dwFlags
, LPDIDEVICEINSTANCEW lpddi
, DWORD version
, int id
)
265 if (!((dwDevType
== 0) ||
266 ((dwDevType
== DIDEVTYPE_JOYSTICK
) && (version
< 0x0800)) ||
267 (((dwDevType
== DI8DEVCLASS_GAMECTRL
) || (dwDevType
== DI8DEVTYPE_JOYSTICK
)) && (version
>= 0x0800))))
270 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
271 if (dwFlags
& DIEDFL_FORCEFEEDBACK
)
275 havejoy
= joydev_have(dwFlags
& DIEDFL_FORCEFEEDBACK
);
280 TRACE("Enumerating the linuxinput Joystick device\n");
282 /* Return joystick */
283 lpddi
->guidInstance
= GUID_Joystick
;
284 lpddi
->guidProduct
= DInput_Wine_Joystick_GUID
;
286 lpddi
->guidFFDriver
= GUID_NULL
;
287 if (version
>= 0x0800)
288 lpddi
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
290 lpddi
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
292 MultiByteToWideChar(CP_ACP
, 0, "Joystick", -1, lpddi
->tszInstanceName
, MAX_PATH
);
293 /* ioctl JSIOCGNAME(len) */
294 MultiByteToWideChar(CP_ACP
, 0, "Wine Joystick", -1, lpddi
->tszProductName
, MAX_PATH
);
298 static JoystickImpl
*alloc_device(REFGUID rguid
, const void *jvt
, IDirectInputImpl
*dinput
)
300 JoystickImpl
* newDevice
;
303 newDevice
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(JoystickImpl
));
304 newDevice
->lpVtbl
= jvt
;
306 newDevice
->joyfd
= -1;
307 newDevice
->dinput
= dinput
;
308 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
309 newDevice
->ff_state
= FF_STATUS_STOPPED
;
311 memcpy(&(newDevice
->guid
),rguid
,sizeof(*rguid
));
312 for (i
=0;i
<ABS_MAX
;i
++) {
313 newDevice
->wantmin
[i
] = -32768;
314 newDevice
->wantmax
[i
] = 32767;
316 * direct input defines a default for the deadzone somewhere; but as long
317 * as in map_axis the code for the dead zone is commented out its no
320 newDevice
->deadz
[i
] = 0;
322 fake_current_js_state(newDevice
);
326 static HRESULT
joydev_create_deviceA(IDirectInputImpl
*dinput
, REFGUID rguid
, REFIID riid
, LPDIRECTINPUTDEVICEA
* pdev
)
330 havejoy
= joydev_have(FALSE
);
333 return DIERR_DEVICENOTREG
;
335 if ((IsEqualGUID(&GUID_Joystick
,rguid
)) ||
336 (IsEqualGUID(&DInput_Wine_Joystick_GUID
,rguid
))) {
337 if ((riid
== NULL
) ||
338 IsEqualGUID(&IID_IDirectInputDeviceA
,riid
) ||
339 IsEqualGUID(&IID_IDirectInputDevice2A
,riid
) ||
340 IsEqualGUID(&IID_IDirectInputDevice7A
,riid
) ||
341 IsEqualGUID(&IID_IDirectInputDevice8A
,riid
)) {
342 *pdev
= (IDirectInputDeviceA
*) alloc_device(rguid
, &JoystickAvt
, dinput
);
343 TRACE("Creating a Joystick device (%p)\n", *pdev
);
346 return DIERR_NOINTERFACE
;
349 return DIERR_DEVICENOTREG
;
353 static HRESULT
joydev_create_deviceW(IDirectInputImpl
*dinput
, REFGUID rguid
, REFIID riid
, LPDIRECTINPUTDEVICEW
* pdev
)
357 havejoy
= joydev_have(FALSE
);
360 return DIERR_DEVICENOTREG
;
362 if ((IsEqualGUID(&GUID_Joystick
,rguid
)) ||
363 (IsEqualGUID(&DInput_Wine_Joystick_GUID
,rguid
))) {
364 if ((riid
== NULL
) ||
365 IsEqualGUID(&IID_IDirectInputDeviceW
,riid
) ||
366 IsEqualGUID(&IID_IDirectInputDevice2W
,riid
) ||
367 IsEqualGUID(&IID_IDirectInputDevice7W
,riid
) ||
368 IsEqualGUID(&IID_IDirectInputDevice8W
,riid
)) {
369 *pdev
= (IDirectInputDeviceW
*) alloc_device(rguid
, &JoystickWvt
, dinput
);
370 TRACE("Creating a Joystick device (%p)\n", *pdev
);
373 return DIERR_NOINTERFACE
;
376 return DIERR_DEVICENOTREG
;
379 const struct dinput_device joystick_linuxinput_device
= {
380 "Wine Linux-input joystick driver",
383 joydev_create_deviceA
,
384 joydev_create_deviceW
387 /******************************************************************************
390 static ULONG WINAPI
JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface
)
392 JoystickImpl
*This
= (JoystickImpl
*)iface
;
395 ref
= InterlockedDecrement(&(This
->ref
));
399 /* Reset the FF state, free all effects, etc */
400 IDirectInputDevice8_SendForceFeedbackCommand(iface
, DISFFC_RESET
);
402 /* Free the data queue */
403 HeapFree(GetProcessHeap(),0,This
->data_queue
);
405 /* Free the DataFormat */
406 HeapFree(GetProcessHeap(), 0, This
->df
);
408 HeapFree(GetProcessHeap(),0,This
);
412 /******************************************************************************
413 * SetDataFormat : the application can choose the format of the data
414 * the device driver sends back with GetDeviceState.
416 static HRESULT WINAPI
JoystickAImpl_SetDataFormat(
417 LPDIRECTINPUTDEVICE8A iface
,LPCDIDATAFORMAT df
420 JoystickImpl
*This
= (JoystickImpl
*)iface
;
422 TRACE("(this=%p,%p)\n",This
,df
);
425 WARN("invalid pointer\n");
429 if (df
->dwSize
!= sizeof(*df
)) {
430 WARN("invalid argument\n");
431 return DIERR_INVALIDPARAM
;
434 _dump_DIDATAFORMAT(df
);
436 if (This
->joyfd
!=-1) {
438 return DIERR_ACQUIRED
;
441 /* Store the new data format */
442 This
->df
= HeapAlloc(GetProcessHeap(),0,df
->dwSize
);
443 if (This
->df
==NULL
) {
444 return DIERR_OUTOFMEMORY
;
446 memcpy(This
->df
, df
, df
->dwSize
);
447 This
->df
->rgodf
= HeapAlloc(GetProcessHeap(),0,df
->dwNumObjs
*df
->dwObjSize
);
448 if (This
->df
->rgodf
==NULL
) {
449 HeapFree(GetProcessHeap(), 0, This
->df
);
450 return DIERR_OUTOFMEMORY
;
452 memcpy(This
->df
->rgodf
,df
->rgodf
,df
->dwNumObjs
*df
->dwObjSize
);
457 /******************************************************************************
458 * Acquire : gets exclusive control of the joystick
460 static HRESULT WINAPI
JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface
)
463 JoystickImpl
*This
= (JoystickImpl
*)iface
;
465 BOOL readonly
= TRUE
;
467 TRACE("(this=%p)\n",This
);
471 sprintf(buf
,EVDEVPREFIX
"%d",i
);
472 if (-1==(This
->joyfd
=open(buf
,O_RDWR
))) {
473 if (-1==(This
->joyfd
=open(buf
,O_RDONLY
))) {
474 /* Couldn't open the device at all */
476 return DIERR_NOTFOUND
;
481 /* Couldn't open in r/w but opened in read-only. */
482 WARN("Could not open %s in read-write mode. Force feedback will be disabled.\n",buf
);
486 /* Opened device in read-write */
489 if ((-1!=ioctl(This
->joyfd
,EVIOCGBIT(0,sizeof(This
->evbits
)),This
->evbits
)) &&
490 (-1!=ioctl(This
->joyfd
,EVIOCGBIT(EV_ABS
,sizeof(This
->absbits
)),This
->absbits
)) &&
491 (-1!=ioctl(This
->joyfd
,EVIOCGBIT(EV_KEY
,sizeof(This
->keybits
)),This
->keybits
)) &&
492 (test_bit(This
->absbits
,ABS_X
) && test_bit(This
->absbits
,ABS_Y
) &&
493 (test_bit(This
->keybits
,BTN_TRIGGER
)||
494 test_bit(This
->keybits
,BTN_A
) ||
495 test_bit(This
->keybits
,BTN_1
)
504 return DIERR_NOTFOUND
;
506 This
->has_ff
= FALSE
;
507 This
->num_effects
= 0;
509 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
510 if (!readonly
&& test_bit(This
->evbits
, EV_FF
)) {
511 if (-1!=ioctl(This
->joyfd
,EVIOCGBIT(EV_FF
,sizeof(This
->ffbits
)),This
->ffbits
)) {
512 if (-1!=ioctl(This
->joyfd
,EVIOCGEFFECTS
,&This
->num_effects
)
513 && This
->num_effects
> 0) {
515 TRACE("Joystick seems to be capable of force feedback.\n");
518 TRACE("Joystick does not support any effects, disabling force feedback.\n");
522 TRACE("Could not get EV_FF bits; disabling force feedback.\n");
526 TRACE("Force feedback disabled (device is readonly or joystick incapable).\n");
530 for (i
=0;i
<ABS_MAX
;i
++) {
531 if (test_bit(This
->absbits
,i
)) {
532 if (-1==ioctl(This
->joyfd
,EVIOCGABS(i
),&(This
->axes
[i
])))
534 TRACE("axe %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
536 This
->axes
[i
][AXE_ABS
],
537 This
->axes
[i
][AXE_ABSMIN
],
538 This
->axes
[i
][AXE_ABSMAX
],
539 This
->axes
[i
][AXE_ABSFUZZ
],
540 This
->axes
[i
][AXE_ABSFLAT
]
542 This
->havemin
[i
] = This
->axes
[i
][AXE_ABSMIN
];
543 This
->havemax
[i
] = This
->axes
[i
][AXE_ABSMAX
];
547 for (i
=0;i
<KEY_MAX
;i
++) {
548 if (test_bit(This
->keybits
,i
)) {
549 TRACE("button %d: %d\n", i
, buttons
);
550 This
->buttons
[i
] = 0x80 | buttons
;
555 fake_current_js_state(This
);
560 /******************************************************************************
561 * Unacquire : frees the joystick
563 static HRESULT WINAPI
JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface
)
565 JoystickImpl
*This
= (JoystickImpl
*)iface
;
567 TRACE("(this=%p)\n",This
);
568 if (This
->joyfd
!=-1) {
578 * This maps the read value (from the input event) to a value in the
579 * 'wanted' range. It also autodetects the possible range of the axe and
580 * adapts values accordingly.
583 map_axis(JoystickImpl
* This
, int axis
, int val
) {
584 int xmin
= This
->axes
[axis
][AXE_ABSMIN
];
585 int xmax
= This
->axes
[axis
][AXE_ABSMAX
];
586 int hmax
= This
->havemax
[axis
];
587 int hmin
= This
->havemin
[axis
];
588 int wmin
= This
->wantmin
[axis
];
589 int wmax
= This
->wantmax
[axis
];
592 if (val
> hmax
) This
->havemax
[axis
] = hmax
= val
;
593 if (val
< hmin
) This
->havemin
[axis
] = hmin
= val
;
595 if (xmin
== xmax
) return val
;
597 /* map the value from the hmin-hmax range into the wmin-wmax range */
598 ret
= ((val
-hmin
) * (wmax
-wmin
)) / (hmax
-hmin
) + wmin
;
600 TRACE("xmin=%d xmax=%d hmin=%d hmax=%d wmin=%d wmax=%d val=%d ret=%d\n", xmin
, xmax
, hmin
, hmax
, wmin
, wmax
, val
, ret
);
603 /* deadzone doesn't work comfortably enough right now. needs more testing*/
604 if ((ret
> -deadz
/2 ) && (ret
< deadz
/2)) {
605 FIXME("%d in deadzone, return mid.\n",val
);
606 return (wmax
-wmin
)/2+wmin
;
613 * set the current state of the js device as it would be with the middle
616 static void fake_current_js_state(JoystickImpl
*ji
)
618 ji
->js
.lX
= map_axis(ji
, ABS_X
, ji
->axes
[ABS_X
][AXE_ABS
]);
619 ji
->js
.lY
= map_axis(ji
, ABS_Y
, ji
->axes
[ABS_Y
][AXE_ABS
]);
620 ji
->js
.lZ
= map_axis(ji
, ABS_Z
, ji
->axes
[ABS_Z
][AXE_ABS
]);
621 ji
->js
.lRx
= map_axis(ji
, ABS_RX
, ji
->axes
[ABS_RX
][AXE_ABS
]);
622 ji
->js
.lRy
= map_axis(ji
, ABS_RY
, ji
->axes
[ABS_RY
][AXE_ABS
]);
623 ji
->js
.lRz
= map_axis(ji
, ABS_RZ
, ji
->axes
[ABS_RZ
][AXE_ABS
]);
624 ji
->js
.rglSlider
[0] = map_axis(ji
, ABS_THROTTLE
, ji
->axes
[ABS_THROTTLE
][AXE_ABS
]);
625 ji
->js
.rglSlider
[1] = map_axis(ji
, ABS_RUDDER
, ji
->axes
[ABS_RUDDER
][AXE_ABS
]);
628 static int find_property_offset(JoystickImpl
*This
, LPCDIPROPHEADER ph
)
633 for (i
=0; i
<This
->df
->dwNumObjs
; i
++) {
634 if (This
->df
->rgodf
[i
].dwOfs
== ph
->dwObj
) {
640 /* XXX: this is a hack - see below */
641 c
= DIDFT_GETINSTANCE(ph
->dwObj
)>>WINE_JOYSTICK_AXIS_BASE
;
642 for (i
=0; (c
&1)==0 && i
<0x0F; i
++) {
649 /* XXX - the following part won't work with LiveForSpeed
650 * - the game sets the dwTypes to something else then
651 * the ddoi.dwType set in EnumObjects
654 for (i
=0; i
<This
->df
->dwNumObjs
; i
++) {
655 TRACE("dwType='%08x'\n", This
->df
->rgodf
[i
].dwType
);
656 if ((This
->df
->rgodf
[i
].dwType
& 0x00ffffff) == (ph
->dwObj
& 0x00ffffff)) {
663 FIXME("Unhandled ph->dwHow=='%04X'\n", (unsigned int)ph
->dwHow
);
669 static void joy_polldev(JoystickImpl
*This
) {
672 struct input_event ie
;
679 memset(&tv
,0,sizeof(tv
));
681 FD_SET(This
->joyfd
,&readfds
);
683 if (1>select(This
->joyfd
+1,&readfds
,NULL
,NULL
,&tv
))
686 /* we have one event, so we can read */
687 if (sizeof(ie
)!=read(This
->joyfd
,&ie
,sizeof(ie
)))
690 TRACE("input_event: type %d, code %d, value %d\n",ie
.type
,ie
.code
,ie
.value
);
692 case EV_KEY
: /* button */
693 btn
= This
->buttons
[ie
.code
];
694 TRACE("(%p) %d -> %d\n", This
, ie
.code
, btn
);
697 This
->js
.rgbButtons
[btn
] = ie
.value
?0x80:0x00;
698 GEN_EVENT(DIJOFS_BUTTON(btn
),ie
.value
?0x80:0x0,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
704 This
->js
.lX
= map_axis(This
,ABS_X
,ie
.value
);
705 GEN_EVENT(DIJOFS_X
,This
->js
.lX
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
708 This
->js
.lY
= map_axis(This
,ABS_Y
,ie
.value
);
709 GEN_EVENT(DIJOFS_Y
,This
->js
.lY
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
712 This
->js
.lZ
= map_axis(This
,ABS_Z
,ie
.value
);
713 GEN_EVENT(DIJOFS_Z
,This
->js
.lZ
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
716 This
->js
.lRx
= map_axis(This
,ABS_RX
,ie
.value
);
717 GEN_EVENT(DIJOFS_RX
,This
->js
.lRx
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
720 This
->js
.lRy
= map_axis(This
,ABS_RY
,ie
.value
);
721 GEN_EVENT(DIJOFS_RY
,This
->js
.lRy
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
724 This
->js
.lRz
= map_axis(This
,ABS_RZ
,ie
.value
);
725 GEN_EVENT(DIJOFS_RZ
,This
->js
.lRz
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
728 This
->js
.rglSlider
[0] = map_axis(This
,ABS_THROTTLE
,ie
.value
);
729 GEN_EVENT(DIJOFS_SLIDER(0),This
->js
.rglSlider
[0],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
732 This
->js
.rglSlider
[1] = map_axis(This
,ABS_RUDDER
,ie
.value
);
733 GEN_EVENT(DIJOFS_SLIDER(1),This
->js
.rglSlider
[1],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
736 FIXME("unhandled joystick axe event (code %d, value %d)\n",ie
.code
,ie
.value
);
740 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
742 This
->ff_state
= ie
.value
;
747 /* there is nothing to do */
751 FIXME("joystick cannot handle type %d event (code %d)\n",ie
.type
,ie
.code
);
757 /******************************************************************************
758 * GetDeviceState : returns the "state" of the joystick.
761 static HRESULT WINAPI
JoystickAImpl_GetDeviceState(
762 LPDIRECTINPUTDEVICE8A iface
,DWORD len
,LPVOID ptr
764 JoystickImpl
*This
= (JoystickImpl
*)iface
;
768 TRACE("(this=%p,0x%08lx,%p)\n",This
,len
,ptr
);
769 if ((len
!= sizeof(DIJOYSTATE
)) && (len
!= sizeof(DIJOYSTATE2
))) {
770 FIXME("len %ld is not sizeof(DIJOYSTATE) or DIJOYSTATE2, unsupported format.\n",len
);
773 memcpy(ptr
,&(This
->js
),len
);
774 This
->queue_head
= 0;
775 This
->queue_tail
= 0;
779 /******************************************************************************
780 * GetDeviceData : gets buffered input data.
782 static HRESULT WINAPI
JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE8A iface
,
784 LPDIDEVICEOBJECTDATA dod
,
788 JoystickImpl
*This
= (JoystickImpl
*)iface
;
793 TRACE("(%p)->(dods=%ld,entries=%ld,fl=0x%08lx)\n",This
,dodsize
,*entries
,flags
);
795 if (This
->joyfd
==-!1) {
796 WARN("not acquired\n");
797 return DIERR_NOTACQUIRED
;
801 if (flags
& DIGDD_PEEK
)
802 FIXME("DIGDD_PEEK\n");
804 len
= ((This
->queue_head
< This
->queue_tail
) ? This
->queue_len
: 0)
805 + (This
->queue_head
- This
->queue_tail
);
811 TRACE("Application discarding %ld event(s).\n", len
);
814 nqtail
= This
->queue_tail
+ len
;
815 while (nqtail
>= This
->queue_len
)
816 nqtail
-= This
->queue_len
;
818 if (dodsize
< sizeof(DIDEVICEOBJECTDATA_DX3
)) {
819 ERR("Wrong structure size !\n");
820 return DIERR_INVALIDPARAM
;
824 TRACE("Application retrieving %ld event(s).\n", len
);
827 nqtail
= This
->queue_tail
;
829 /* Copy the buffered data into the application queue */
830 memcpy((char *)dod
+ *entries
* dodsize
, This
->data_queue
+ nqtail
, dodsize
);
831 /* Advance position */
833 if (nqtail
>= This
->queue_len
)
834 nqtail
-= This
->queue_len
;
840 if (This
->overflow
) {
841 hr
= DI_BUFFEROVERFLOW
;
842 if (!(flags
& DIGDD_PEEK
)) {
843 This
->overflow
= FALSE
;
847 if (!(flags
& DIGDD_PEEK
))
848 This
->queue_tail
= nqtail
;
853 /******************************************************************************
854 * SetProperty : change input device properties
856 static HRESULT WINAPI
JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface
,
860 JoystickImpl
*This
= (JoystickImpl
*)iface
;
863 WARN("invalid argument\n");
864 return DIERR_INVALIDPARAM
;
867 TRACE("(this=%p,%s,%p)\n",This
,debugstr_guid(rguid
),ph
);
868 TRACE("ph.dwSize = %ld, ph.dwHeaderSize =%ld, ph.dwObj = %ld, ph.dwHow= %ld\n",ph
->dwSize
, ph
->dwHeaderSize
,ph
->dwObj
,ph
->dwHow
);
870 if (!HIWORD(rguid
)) {
871 switch (LOWORD(rguid
)) {
872 case (DWORD
) DIPROP_BUFFERSIZE
: {
873 LPCDIPROPDWORD pd
= (LPCDIPROPDWORD
)ph
;
875 TRACE("buffersize = %ld\n",pd
->dwData
);
876 if (This
->data_queue
) {
877 This
->data_queue
= HeapReAlloc(GetProcessHeap(),0, This
->data_queue
, pd
->dwData
* sizeof(DIDEVICEOBJECTDATA
));
879 This
->data_queue
= HeapAlloc(GetProcessHeap(),0, pd
->dwData
* sizeof(DIDEVICEOBJECTDATA
));
881 This
->queue_head
= 0;
882 This
->queue_tail
= 0;
883 This
->queue_len
= pd
->dwData
;
886 case (DWORD
)DIPROP_RANGE
: {
887 LPCDIPROPRANGE pr
= (LPCDIPROPRANGE
)ph
;
889 if (ph
->dwHow
== DIPH_DEVICE
) {
891 TRACE("proprange(%ld,%ld) all\n",pr
->lMin
,pr
->lMax
);
892 for (i
= 0; i
< This
->df
->dwNumObjs
; i
++) {
893 This
->wantmin
[i
] = pr
->lMin
;
894 This
->wantmax
[i
] = pr
->lMax
;
897 int obj
= find_property_offset(This
, ph
);
898 TRACE("proprange(%ld,%ld) obj=%d\n",pr
->lMin
,pr
->lMax
,obj
);
900 This
->wantmin
[obj
] = pr
->lMin
;
901 This
->wantmax
[obj
] = pr
->lMax
;
906 case (DWORD
)DIPROP_DEADZONE
: {
907 LPCDIPROPDWORD pd
= (LPCDIPROPDWORD
)ph
;
908 if (ph
->dwHow
== DIPH_DEVICE
) {
910 TRACE("deadzone(%ld) all\n",pd
->dwData
);
911 for (i
= 0; i
< This
->df
->dwNumObjs
; i
++) {
912 This
->deadz
[i
] = pd
->dwData
;
915 int obj
= find_property_offset(This
, ph
);
916 TRACE("deadzone(%ld) obj=%d\n",pd
->dwData
,obj
);
918 This
->deadz
[obj
] = pd
->dwData
;
924 FIXME("Unknown type %p (%s)\n",rguid
,debugstr_guid(rguid
));
928 fake_current_js_state(This
);
932 /******************************************************************************
933 * SetEventNotification : specifies event to be sent on state change
935 static HRESULT WINAPI
JoystickAImpl_SetEventNotification(
936 LPDIRECTINPUTDEVICE8A iface
, HANDLE hnd
938 JoystickImpl
*This
= (JoystickImpl
*)iface
;
940 TRACE("(this=%p,%p)\n",This
,hnd
);
945 static HRESULT WINAPI
JoystickAImpl_GetCapabilities(
946 LPDIRECTINPUTDEVICE8A iface
,
947 LPDIDEVCAPS lpDIDevCaps
)
949 JoystickImpl
*This
= (JoystickImpl
*)iface
;
950 int xfd
= This
->joyfd
;
953 TRACE("%p->(%p)\n",iface
,lpDIDevCaps
);
956 WARN("invalid pointer\n");
960 if (lpDIDevCaps
->dwSize
!= sizeof(DIDEVCAPS
)) {
961 WARN("invalid argument\n");
962 return DIERR_INVALIDPARAM
;
966 /* yes, games assume we return something, even if unacquired */
967 JoystickAImpl_Acquire(iface
);
970 lpDIDevCaps
->dwFlags
= DIDC_ATTACHED
;
971 if (This
->dinput
->dwVersion
>= 0x0800)
972 lpDIDevCaps
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
974 lpDIDevCaps
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
977 for (i
=0;i
<ABS_MAX
;i
++) if (test_bit(This
->absbits
,i
)) axes
++;
979 for (i
=0;i
<KEY_MAX
;i
++) if (test_bit(This
->keybits
,i
)) buttons
++;
982 lpDIDevCaps
->dwFlags
|= DIDC_FORCEFEEDBACK
;
984 lpDIDevCaps
->dwAxes
= axes
;
985 lpDIDevCaps
->dwButtons
= buttons
;
988 JoystickAImpl_Unacquire(iface
);
994 static HRESULT WINAPI
JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface
) {
995 JoystickImpl
*This
= (JoystickImpl
*)iface
;
996 TRACE("(%p)\n",This
);
998 if (This
->joyfd
==-1) {
999 return DIERR_NOTACQUIRED
;
1006 /******************************************************************************
1007 * EnumObjects : enumerate the different buttons and axis...
1009 static HRESULT WINAPI
JoystickAImpl_EnumObjects(
1010 LPDIRECTINPUTDEVICE8A iface
,
1011 LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback
,
1015 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1016 DIDEVICEOBJECTINSTANCEA ddoi
;
1017 int xfd
= This
->joyfd
;
1019 TRACE("(this=%p,%p,%p,%08lx)\n", This
, lpCallback
, lpvRef
, dwFlags
);
1020 if (TRACE_ON(dinput
)) {
1021 TRACE(" - flags = ");
1022 _dump_EnumObjects_flags(dwFlags
);
1026 /* We need to work even if we're not yet acquired */
1028 IDirectInputDevice8_Acquire(iface
);
1030 /* Only the fields till dwFFMaxForce are relevant */
1031 ddoi
.dwSize
= FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA
, dwFFMaxForce
);
1033 /* For the joystick, do as is done in the GetCapabilities function */
1034 /* FIXME: needs more items */
1035 if ((dwFlags
== DIDFT_ALL
) ||
1036 (dwFlags
& DIDFT_AXIS
)) {
1039 for (i
= 0; i
< ABS_MAX
; i
++) {
1040 if (!test_bit(This
->absbits
,i
)) continue;
1044 ddoi
.guidType
= GUID_XAxis
;
1045 ddoi
.dwOfs
= DIJOFS_X
;
1048 ddoi
.guidType
= GUID_YAxis
;
1049 ddoi
.dwOfs
= DIJOFS_Y
;
1052 ddoi
.guidType
= GUID_ZAxis
;
1053 ddoi
.dwOfs
= DIJOFS_Z
;
1056 ddoi
.guidType
= GUID_RxAxis
;
1057 ddoi
.dwOfs
= DIJOFS_RX
;
1060 ddoi
.guidType
= GUID_RyAxis
;
1061 ddoi
.dwOfs
= DIJOFS_RY
;
1064 ddoi
.guidType
= GUID_RzAxis
;
1065 ddoi
.dwOfs
= DIJOFS_RZ
;
1068 ddoi
.guidType
= GUID_Slider
;
1069 ddoi
.dwOfs
= DIJOFS_SLIDER(0);
1072 ddoi
.guidType
= GUID_Slider
;
1073 ddoi
.dwOfs
= DIJOFS_SLIDER(1);
1076 FIXME("unhandled abs axis %d, ignoring!\n",i
);
1078 ddoi
.dwType
= DIDFT_MAKEINSTANCE((1<<i
) << WINE_JOYSTICK_AXIS_BASE
) | DIDFT_ABSAXIS
;
1079 /* Linux event force feedback supports only (and always) x and y axes */
1080 if (i
== ABS_X
|| i
== ABS_Y
) {
1082 ddoi
.dwFlags
|= DIDOI_FFACTUATOR
;
1084 sprintf(ddoi
.tszName
, "%d-Axis", i
);
1085 _dump_OBJECTINSTANCEA(&ddoi
);
1086 if (lpCallback(&ddoi
, lpvRef
) != DIENUM_CONTINUE
) {
1087 /* return to unaquired state if that's where we were */
1089 IDirectInputDevice8_Unacquire(iface
);
1095 if ((dwFlags
== DIDFT_ALL
) ||
1096 (dwFlags
& DIDFT_BUTTON
)) {
1099 /*The DInput SDK says that GUID_Button is only for mouse buttons but well*/
1101 ddoi
.guidType
= GUID_Button
;
1103 for (i
= 0; i
< KEY_MAX
; i
++) {
1104 if (!test_bit(This
->keybits
,i
)) continue;
1105 ddoi
.dwOfs
= DIJOFS_BUTTON(btncount
);
1106 ddoi
.dwType
= DIDFT_MAKEINSTANCE(btncount
<< WINE_JOYSTICK_BUTTON_BASE
) | DIDFT_PSHBUTTON
;
1107 sprintf(ddoi
.tszName
, "%d-Button", btncount
);
1109 _dump_OBJECTINSTANCEA(&ddoi
);
1110 if (lpCallback(&ddoi
, lpvRef
) != DIENUM_CONTINUE
) {
1111 /* return to unaquired state if that's where we were */
1113 IDirectInputDevice8_Unacquire(iface
);
1119 /* return to unaquired state if that's where we were */
1121 IDirectInputDevice8_Unacquire(iface
);
1126 static HRESULT WINAPI
JoystickWImpl_EnumObjects(LPDIRECTINPUTDEVICE8W iface
,
1127 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback
,
1131 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1133 device_enumobjects_AtoWcb_data data
;
1135 data
.lpCallBack
= lpCallback
;
1136 data
.lpvRef
= lpvRef
;
1138 return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A
) This
, (LPDIENUMDEVICEOBJECTSCALLBACKA
) DIEnumDevicesCallbackAtoW
, (LPVOID
) &data
, dwFlags
);
1141 /******************************************************************************
1142 * GetProperty : get input device properties
1144 static HRESULT WINAPI
JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface
,
1146 LPDIPROPHEADER pdiph
)
1148 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1150 TRACE("(this=%p,%s,%p)\n",
1151 iface
, debugstr_guid(rguid
), pdiph
);
1153 if (TRACE_ON(dinput
))
1154 _dump_DIPROPHEADER(pdiph
);
1156 if (!HIWORD(rguid
)) {
1157 switch (LOWORD(rguid
)) {
1158 case (DWORD
) DIPROP_BUFFERSIZE
: {
1159 LPDIPROPDWORD pd
= (LPDIPROPDWORD
)pdiph
;
1161 TRACE(" return buffersize = %d\n",This
->queue_len
);
1162 pd
->dwData
= This
->queue_len
;
1166 case (DWORD
) DIPROP_RANGE
: {
1167 /* LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph; */
1168 if ((pdiph
->dwHow
== DIPH_BYID
) &&
1169 (pdiph
->dwObj
& DIDFT_ABSAXIS
)) {
1170 /* The app is querying the current range of the axis : return the lMin and lMax values */
1171 FIXME("unimplemented axis range query.\n");
1178 FIXME("Unknown type %p (%s)\n",rguid
,debugstr_guid(rguid
));
1187 /******************************************************************************
1188 * CreateEffect - Create a new FF effect with the specified params
1190 static HRESULT WINAPI
JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface
,
1193 LPDIRECTINPUTEFFECT
*ppdef
,
1194 LPUNKNOWN pUnkOuter
)
1196 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1197 EffectListItem
* new = NULL
;
1198 HRESULT retval
= DI_OK
;
1201 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1202 TRACE("(this=%p,%p,%p,%p,%p)\n", This
, rguid
, lpeff
, ppdef
, pUnkOuter
);
1204 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
1205 TRACE("not available (compiled w/o ff support)\n");
1210 new = malloc(sizeof(EffectListItem
));
1211 new->next
= This
->top_effect
;
1212 This
->top_effect
= new;
1214 retval
= linuxinput_create_effect(&(This
->joyfd
), rguid
, &(new->ref
));
1215 if (retval
!= DI_OK
)
1219 retval
= IDirectInputEffect_SetParameters(new->ref
, lpeff
, 0);
1220 if (retval
!= DI_OK
&& retval
!= DI_DOWNLOADSKIPPED
)
1225 if (pUnkOuter
!= NULL
)
1226 FIXME("Interface aggregation not implemented.\n");
1230 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1233 /*******************************************************************************
1234 * EnumEffects - Enumerate available FF effects
1236 static HRESULT WINAPI
JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface
,
1237 LPDIENUMEFFECTSCALLBACKA lpCallback
,
1241 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1242 DIEFFECTINFOA dei
; /* feif */
1243 DWORD type
= DIEFT_GETTYPE(dwEffType
);
1244 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1245 int xfd
= This
->joyfd
;
1247 TRACE("(this=%p,%p,%ld) type=%ld fd=%d\n", This
, pvRef
, dwEffType
, type
, xfd
);
1249 dei
.dwSize
= sizeof(DIEFFECTINFOA
);
1251 /* We need to return something even if we're not yet acquired */
1253 IDirectInputDevice8_Acquire(iface
);
1255 if ((type
== DIEFT_ALL
|| type
== DIEFT_CONSTANTFORCE
)
1256 && test_bit(This
->ffbits
, FF_CONSTANT
)) {
1257 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_ConstantForce
);
1258 (*lpCallback
)(&dei
, pvRef
);
1261 if ((type
== DIEFT_ALL
|| type
== DIEFT_PERIODIC
)
1262 && test_bit(This
->ffbits
, FF_PERIODIC
)) {
1263 if (test_bit(This
->ffbits
, FF_SQUARE
)) {
1264 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Square
);
1265 (*lpCallback
)(&dei
, pvRef
);
1267 if (test_bit(This
->ffbits
, FF_SINE
)) {
1268 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Sine
);
1269 (*lpCallback
)(&dei
, pvRef
);
1271 if (test_bit(This
->ffbits
, FF_TRIANGLE
)) {
1272 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Triangle
);
1273 (*lpCallback
)(&dei
, pvRef
);
1275 if (test_bit(This
->ffbits
, FF_SAW_UP
)) {
1276 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothUp
);
1277 (*lpCallback
)(&dei
, pvRef
);
1279 if (test_bit(This
->ffbits
, FF_SAW_DOWN
)) {
1280 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothDown
);
1281 (*lpCallback
)(&dei
, pvRef
);
1285 if ((type
== DIEFT_ALL
|| type
== DIEFT_RAMPFORCE
)
1286 && test_bit(This
->ffbits
, FF_RAMP
)) {
1287 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_RampForce
);
1288 (*lpCallback
)(&dei
, pvRef
);
1291 if (type
== DIEFT_ALL
|| type
== DIEFT_CONDITION
) {
1292 if (test_bit(This
->ffbits
, FF_SPRING
)) {
1293 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Spring
);
1294 (*lpCallback
)(&dei
, pvRef
);
1296 if (test_bit(This
->ffbits
, FF_DAMPER
)) {
1297 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Damper
);
1298 (*lpCallback
)(&dei
, pvRef
);
1300 if (test_bit(This
->ffbits
, FF_INERTIA
)) {
1301 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Inertia
);
1302 (*lpCallback
)(&dei
, pvRef
);
1304 if (test_bit(This
->ffbits
, FF_FRICTION
)) {
1305 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Friction
);
1306 (*lpCallback
)(&dei
, pvRef
);
1310 /* return to unaquired state if that's where it was */
1312 IDirectInputDevice8_Unacquire(iface
);
1318 static HRESULT WINAPI
JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface
,
1319 LPDIENUMEFFECTSCALLBACKW lpCallback
,
1323 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1324 /* seems silly to duplicate all this code but all the structures and functions
1325 * are actually different (A/W) */
1326 DIEFFECTINFOW dei
; /* feif */
1327 DWORD type
= DIEFT_GETTYPE(dwEffType
);
1328 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1329 int xfd
= This
->joyfd
;
1331 TRACE("(this=%p,%p,%ld) type=%ld fd=%d\n", This
, pvRef
, dwEffType
, type
, xfd
);
1333 dei
.dwSize
= sizeof(DIEFFECTINFOW
);
1335 /* We need to return something even if we're not yet acquired */
1337 IDirectInputDevice8_Acquire(iface
);
1339 if ((type
== DIEFT_ALL
|| type
== DIEFT_CONSTANTFORCE
)
1340 && test_bit(This
->ffbits
, FF_CONSTANT
)) {
1341 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_ConstantForce
);
1342 (*lpCallback
)(&dei
, pvRef
);
1345 if ((type
== DIEFT_ALL
|| type
== DIEFT_PERIODIC
)
1346 && test_bit(This
->ffbits
, FF_PERIODIC
)) {
1347 if (test_bit(This
->ffbits
, FF_SQUARE
)) {
1348 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Square
);
1349 (*lpCallback
)(&dei
, pvRef
);
1351 if (test_bit(This
->ffbits
, FF_SINE
)) {
1352 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Sine
);
1353 (*lpCallback
)(&dei
, pvRef
);
1355 if (test_bit(This
->ffbits
, FF_TRIANGLE
)) {
1356 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Triangle
);
1357 (*lpCallback
)(&dei
, pvRef
);
1359 if (test_bit(This
->ffbits
, FF_SAW_UP
)) {
1360 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothUp
);
1361 (*lpCallback
)(&dei
, pvRef
);
1363 if (test_bit(This
->ffbits
, FF_SAW_DOWN
)) {
1364 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothDown
);
1365 (*lpCallback
)(&dei
, pvRef
);
1369 if ((type
== DIEFT_ALL
|| type
== DIEFT_RAMPFORCE
)
1370 && test_bit(This
->ffbits
, FF_RAMP
)) {
1371 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_RampForce
);
1372 (*lpCallback
)(&dei
, pvRef
);
1375 if (type
== DIEFT_ALL
|| type
== DIEFT_CONDITION
) {
1376 if (test_bit(This
->ffbits
, FF_SPRING
)) {
1377 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Spring
);
1378 (*lpCallback
)(&dei
, pvRef
);
1380 if (test_bit(This
->ffbits
, FF_DAMPER
)) {
1381 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Damper
);
1382 (*lpCallback
)(&dei
, pvRef
);
1384 if (test_bit(This
->ffbits
, FF_INERTIA
)) {
1385 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Inertia
);
1386 (*lpCallback
)(&dei
, pvRef
);
1388 if (test_bit(This
->ffbits
, FF_FRICTION
)) {
1389 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Friction
);
1390 (*lpCallback
)(&dei
, pvRef
);
1394 /* return to unaquired state if that's where it was */
1396 IDirectInputDevice8_Unacquire(iface
);
1402 /*******************************************************************************
1403 * GetEffectInfo - Get information about a particular effect
1405 static HRESULT WINAPI
JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface
,
1406 LPDIEFFECTINFOA pdei
,
1409 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1411 TRACE("(this=%p,%p,%s)\n", This
, pdei
, _dump_dinput_GUID(guid
));
1413 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1414 return linuxinput_get_info_A(This
->joyfd
, guid
, pdei
);
1420 static HRESULT WINAPI
JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface
,
1421 LPDIEFFECTINFOW pdei
,
1424 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1426 TRACE("(this=%p,%p,%s)\n", This
, pdei
, _dump_dinput_GUID(guid
));
1428 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1429 return linuxinput_get_info_W(This
->joyfd
, guid
, pdei
);
1435 /*******************************************************************************
1436 * GetForceFeedbackState - Get information about the device's FF state
1438 static HRESULT WINAPI
JoystickAImpl_GetForceFeedbackState(
1439 LPDIRECTINPUTDEVICE8A iface
,
1442 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1444 TRACE("(this=%p,%p)\n", This
, pdwOut
);
1448 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1449 /* DIGFFS_STOPPED is the only mandatory flag to report */
1450 if (This
->ff_state
== FF_STATUS_STOPPED
)
1451 (*pdwOut
) |= DIGFFS_STOPPED
;
1457 /*******************************************************************************
1458 * SendForceFeedbackCommand - Send a command to the device's FF system
1460 static HRESULT WINAPI
JoystickAImpl_SendForceFeedbackCommand(
1461 LPDIRECTINPUTDEVICE8A iface
,
1464 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1465 TRACE("(this=%p,%ld)\n", This
, dwFlags
);
1467 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1468 if (dwFlags
== DISFFC_STOPALL
) {
1469 /* Stop all effects */
1470 EffectListItem
* itr
= This
->top_effect
;
1472 IDirectInputEffect_Stop(itr
->ref
);
1475 } else if (dwFlags
== DISFFC_RESET
) {
1476 /* Stop, unload, release and free all effects */
1477 /* This returns the device to its "bare" state */
1478 while (This
->top_effect
) {
1479 EffectListItem
* temp
= This
->top_effect
;
1480 IDirectInputEffect_Stop(temp
->ref
);
1481 IDirectInputEffect_Unload(temp
->ref
);
1482 IDirectInputEffect_Release(temp
->ref
);
1483 This
->top_effect
= temp
->next
;
1486 } else if (dwFlags
== DISFFC_PAUSE
|| dwFlags
== DISFFC_CONTINUE
) {
1487 FIXME("No support for Pause or Continue in linux\n");
1488 } else if (dwFlags
== DISFFC_SETACTUATORSOFF
1489 || dwFlags
== DISFFC_SETACTUATORSON
) {
1490 FIXME("No direct actuator control in linux\n");
1492 FIXME("Unknown Force Feedback Command!\n");
1493 return DIERR_INVALIDPARAM
;
1497 return DIERR_UNSUPPORTED
;
1501 /*******************************************************************************
1502 * EnumCreatedEffectObjects - Enumerate all the effects that have been
1503 * created for this device.
1505 static HRESULT WINAPI
JoystickAImpl_EnumCreatedEffectObjects(
1506 LPDIRECTINPUTDEVICE8A iface
,
1507 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback
,
1511 /* this function is safe to call on non-ff-enabled builds */
1513 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1514 EffectListItem
* itr
= This
->top_effect
;
1515 TRACE("(this=%p,%p,%p,%ld)\n", This
, lpCallback
, pvRef
, dwFlags
);
1518 return DIERR_INVALIDPARAM
;
1521 FIXME("Flags specified, but no flags exist yet (DX9)!");
1524 (*lpCallback
)(itr
->ref
, pvRef
);
1531 static const IDirectInputDevice8AVtbl JoystickAvt
=
1533 IDirectInputDevice2AImpl_QueryInterface
,
1534 IDirectInputDevice2AImpl_AddRef
,
1535 JoystickAImpl_Release
,
1536 JoystickAImpl_GetCapabilities
,
1537 JoystickAImpl_EnumObjects
,
1538 JoystickAImpl_GetProperty
,
1539 JoystickAImpl_SetProperty
,
1540 JoystickAImpl_Acquire
,
1541 JoystickAImpl_Unacquire
,
1542 JoystickAImpl_GetDeviceState
,
1543 JoystickAImpl_GetDeviceData
,
1544 JoystickAImpl_SetDataFormat
,
1545 JoystickAImpl_SetEventNotification
,
1546 IDirectInputDevice2AImpl_SetCooperativeLevel
,
1547 IDirectInputDevice2AImpl_GetObjectInfo
,
1548 IDirectInputDevice2AImpl_GetDeviceInfo
,
1549 IDirectInputDevice2AImpl_RunControlPanel
,
1550 IDirectInputDevice2AImpl_Initialize
,
1551 JoystickAImpl_CreateEffect
,
1552 JoystickAImpl_EnumEffects
,
1553 JoystickAImpl_GetEffectInfo
,
1554 JoystickAImpl_GetForceFeedbackState
,
1555 JoystickAImpl_SendForceFeedbackCommand
,
1556 JoystickAImpl_EnumCreatedEffectObjects
,
1557 IDirectInputDevice2AImpl_Escape
,
1559 IDirectInputDevice2AImpl_SendDeviceData
,
1560 IDirectInputDevice7AImpl_EnumEffectsInFile
,
1561 IDirectInputDevice7AImpl_WriteEffectToFile
,
1562 IDirectInputDevice8AImpl_BuildActionMap
,
1563 IDirectInputDevice8AImpl_SetActionMap
,
1564 IDirectInputDevice8AImpl_GetImageInfo
1567 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1568 # define XCAST(fun) (typeof(JoystickWvt.fun))
1570 # define XCAST(fun) (void*)
1573 static const IDirectInputDevice8WVtbl JoystickWvt
=
1575 IDirectInputDevice2WImpl_QueryInterface
,
1576 XCAST(AddRef
)IDirectInputDevice2AImpl_AddRef
,
1577 XCAST(Release
)JoystickAImpl_Release
,
1578 XCAST(GetCapabilities
)JoystickAImpl_GetCapabilities
,
1579 JoystickWImpl_EnumObjects
,
1580 XCAST(GetProperty
)JoystickAImpl_GetProperty
,
1581 XCAST(SetProperty
)JoystickAImpl_SetProperty
,
1582 XCAST(Acquire
)JoystickAImpl_Acquire
,
1583 XCAST(Unacquire
)JoystickAImpl_Unacquire
,
1584 XCAST(GetDeviceState
)JoystickAImpl_GetDeviceState
,
1585 XCAST(GetDeviceData
)JoystickAImpl_GetDeviceData
,
1586 XCAST(SetDataFormat
)JoystickAImpl_SetDataFormat
,
1587 XCAST(SetEventNotification
)JoystickAImpl_SetEventNotification
,
1588 XCAST(SetCooperativeLevel
)IDirectInputDevice2AImpl_SetCooperativeLevel
,
1589 IDirectInputDevice2WImpl_GetObjectInfo
,
1590 IDirectInputDevice2WImpl_GetDeviceInfo
,
1591 XCAST(RunControlPanel
)IDirectInputDevice2AImpl_RunControlPanel
,
1592 XCAST(Initialize
)IDirectInputDevice2AImpl_Initialize
,
1593 XCAST(CreateEffect
)JoystickAImpl_CreateEffect
,
1594 JoystickWImpl_EnumEffects
,
1595 JoystickWImpl_GetEffectInfo
,
1596 XCAST(GetForceFeedbackState
)JoystickAImpl_GetForceFeedbackState
,
1597 XCAST(SendForceFeedbackCommand
)JoystickAImpl_SendForceFeedbackCommand
,
1598 XCAST(EnumCreatedEffectObjects
)JoystickAImpl_EnumCreatedEffectObjects
,
1599 XCAST(Escape
)IDirectInputDevice2AImpl_Escape
,
1600 XCAST(Poll
)JoystickAImpl_Poll
,
1601 XCAST(SendDeviceData
)IDirectInputDevice2AImpl_SendDeviceData
,
1602 IDirectInputDevice7WImpl_EnumEffectsInFile
,
1603 IDirectInputDevice7WImpl_WriteEffectToFile
,
1604 IDirectInputDevice8WImpl_BuildActionMap
,
1605 IDirectInputDevice8WImpl_SetActionMap
,
1606 IDirectInputDevice8WImpl_GetImageInfo
1610 #else /* HAVE_CORRECT_LINUXINPUT_H */
1612 const struct dinput_device joystick_linuxinput_device
= {
1613 "Wine Linux-input joystick driver",
1620 #endif /* HAVE_CORRECT_LINUXINPUT_H */