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>
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_POV_BASE 6
71 #define WINE_JOYSTICK_BUTTON_BASE 8
73 typedef struct EffectListItem EffectListItem
;
76 LPDIRECTINPUTEFFECT ref
;
77 struct EffectListItem
* next
;
80 /* implemented in effect_linuxinput.c */
81 HRESULT
linuxinput_create_effect(int* fd
, REFGUID rguid
, LPDIRECTINPUTEFFECT
* peff
);
82 HRESULT
linuxinput_get_info_A(int fd
, REFGUID rguid
, LPDIEFFECTINFOA info
);
83 HRESULT
linuxinput_get_info_W(int fd
, REFGUID rguid
, LPDIEFFECTINFOW info
);
85 typedef struct JoystickImpl JoystickImpl
;
86 static const IDirectInputDevice8AVtbl JoystickAvt
;
87 static const IDirectInputDevice8WVtbl JoystickWvt
;
97 /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */
98 BYTE evbits
[(EV_MAX
+7)/8];
99 BYTE absbits
[(ABS_MAX
+7)/8];
100 BYTE keybits
[(KEY_MAX
+7)/8];
101 BYTE ffbits
[(FF_MAX
+7)/8];
106 #define AXE_ABSFUZZ 3
107 #define AXE_ABSFLAT 4
109 /* data returned by the EVIOCGABS() ioctl */
110 int axes
[ABS_MAX
][5];
111 /* LUT for KEY_ to offset in rgbButtons */
112 BYTE buttons
[KEY_MAX
];
114 /* autodetecting ranges per axe by following movement */
115 LONG havemax
[ABS_MAX
];
116 LONG havemin
[ABS_MAX
];
124 struct JoyDev
*joydev
;
126 /* The 'parent' DInput */
127 IDirectInputImpl
*dinput
;
129 /* joystick private */
130 /* what range and deadzone the game wants */
131 LONG wantmin
[ABS_MAX
];
132 LONG wantmax
[ABS_MAX
];
137 LPDIDATAFORMAT internal_df
;
139 DataFormat
*transform
; /* wine to user format converter */
140 int *offsets
; /* object offsets */
142 LPDIDEVICEOBJECTDATA data_queue
;
143 int queue_head
, queue_tail
, queue_len
;
147 /* Force feedback variables */
148 EffectListItem
* top_effect
;
152 static void fake_current_js_state(JoystickImpl
*ji
);
153 static int find_property_offset(JoystickImpl
*This
, LPCDIPROPHEADER ph
);
154 static DWORD
map_pov(int event_value
, int is_x
);
155 static void find_joydevs(void);
156 static int lxinput_to_djoy2_offset(int ie_type
, int ie_code
);
157 static int offset_to_object(JoystickImpl
*This
, int offset
);
158 static void calculate_ids(LPDIDATAFORMAT df
);
160 /* This GUID is slightly different from the linux joystick one. Take note. */
161 static const GUID DInput_Wine_Joystick_Base_GUID
= { /* 9e573eda-7734-11d2-8d4a-23903fb6bdf7 */
165 {0x8d, 0x4a, 0x23, 0x90, 0x3f, 0xb6, 0xbd, 0xf7}
168 #define test_bit(arr,bit) (((BYTE*)(arr))[(bit)>>3]&(1<<((bit)&7)))
170 #define MAX_JOYDEV 64
172 static int have_joydevs
= -1;
173 static struct JoyDev
*joydevs
= NULL
;
175 static void find_joydevs(void)
179 if (have_joydevs
!=-1) {
185 for (i
=0;i
<MAX_JOYDEV
;i
++) {
187 struct JoyDev joydev
= {0};
192 snprintf(buf
,MAX_PATH
,EVDEVPREFIX
"%d",i
);
195 if ((fd
=open(buf
, O_RDWR
))==-1) {
196 fd
= open(buf
, O_RDONLY
);
201 if ((-1==ioctl(fd
,EVIOCGBIT(0,sizeof(joydev
.evbits
)),joydev
.evbits
))) {
202 perror("EVIOCGBIT 0");
206 if (-1==ioctl(fd
,EVIOCGBIT(EV_ABS
,sizeof(joydev
.absbits
)),joydev
.absbits
)) {
207 perror("EVIOCGBIT EV_ABS");
211 if (-1==ioctl(fd
,EVIOCGBIT(EV_KEY
,sizeof(joydev
.keybits
)),joydev
.keybits
)) {
212 perror("EVIOCGBIT EV_KEY");
216 /* A true joystick has at least axis X and Y, and at least 1
217 * button. copied from linux/drivers/input/joydev.c */
218 if (test_bit(joydev
.absbits
,ABS_X
) && test_bit(joydev
.absbits
,ABS_Y
) &&
219 ( test_bit(joydev
.keybits
,BTN_TRIGGER
) ||
220 test_bit(joydev
.keybits
,BTN_A
) ||
221 test_bit(joydev
.keybits
,BTN_1
)
225 joydev
.device
= strdup(buf
);
227 if (-1!=ioctl(fd
, EVIOCGNAME(MAX_PATH
-1), buf
)) {
229 joydev
.name
= strdup(buf
);
231 joydev
.name
= joydev
.device
;
234 joydev
.guid
= DInput_Wine_Joystick_Base_GUID
;
235 joydev
.guid
.Data3
+= have_joydevs
;
237 TRACE("Found a joystick on %s: %s (%s)\n",
238 joydev
.device
, joydev
.name
,
239 debugstr_guid(&joydev
.guid
)
242 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
244 if ((!test_bit(joydev
.evbits
,EV_FF
))
245 || (-1==ioctl(fd
,EVIOCGBIT(EV_FF
,sizeof(joydev
.ffbits
)),joydev
.ffbits
))
246 || (-1==ioctl(fd
,EVIOCGEFFECTS
,&joydev
.num_effects
))
247 || (joydev
.num_effects
<= 0)) {
250 TRACE(" ... with force feedback\n");
256 for (j
=0;j
<ABS_MAX
;j
++) {
257 if (test_bit(joydev
.absbits
,j
)) {
258 if (-1!=ioctl(fd
,EVIOCGABS(j
),&(joydev
.axes
[j
]))) {
259 TRACE(" ... with axe %d: cur=%d, min=%d, max=%d, fuzz=%d, flat=%d\n",
261 joydev
.axes
[j
][AXE_ABS
],
262 joydev
.axes
[j
][AXE_ABSMIN
],
263 joydev
.axes
[j
][AXE_ABSMAX
],
264 joydev
.axes
[j
][AXE_ABSFUZZ
],
265 joydev
.axes
[j
][AXE_ABSFLAT
]
267 joydev
.havemin
[j
] = joydev
.axes
[j
][AXE_ABSMIN
];
268 joydev
.havemax
[j
] = joydev
.axes
[j
][AXE_ABSMAX
];
274 for (j
=0;j
<KEY_MAX
;j
++) {
275 if (test_bit(joydev
.keybits
,j
)) {
276 TRACE(" ... with button %d: %d\n", j
, buttons
);
277 joydev
.buttons
[j
] = 0x80 | buttons
;
282 if (have_joydevs
==0) {
283 joydevs
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev
));
285 HeapReAlloc(GetProcessHeap(), 0, joydevs
, (1+have_joydevs
) * sizeof(struct JoyDev
));
287 memcpy(joydevs
+have_joydevs
, &joydev
, sizeof(struct JoyDev
));
296 static BOOL
joydev_enum_deviceA(DWORD dwDevType
, DWORD dwFlags
, LPDIDEVICEINSTANCEA lpddi
, DWORD version
, int id
)
300 if (id
>= have_joydevs
) {
304 if (!((dwDevType
== 0) ||
305 ((dwDevType
== DIDEVTYPE_JOYSTICK
) && (version
< 0x0800)) ||
306 (((dwDevType
== DI8DEVCLASS_GAMECTRL
) || (dwDevType
== DI8DEVTYPE_JOYSTICK
)) && (version
>= 0x0800))))
309 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
310 if (dwFlags
& DIEDFL_FORCEFEEDBACK
)
314 if (!(dwFlags
& DIEDFL_FORCEFEEDBACK
) || joydevs
[id
].has_ff
) {
315 lpddi
->guidInstance
= joydevs
[id
].guid
;
316 lpddi
->guidProduct
= DInput_Wine_Joystick_Base_GUID
;
318 lpddi
->guidFFDriver
= GUID_NULL
;
319 if (version
>= 0x0800)
320 lpddi
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
322 lpddi
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
324 strcpy(lpddi
->tszInstanceName
, joydevs
[id
].name
);
325 strcpy(lpddi
->tszProductName
, joydevs
[id
].device
);
331 static BOOL
joydev_enum_deviceW(DWORD dwDevType
, DWORD dwFlags
, LPDIDEVICEINSTANCEW lpddi
, DWORD version
, int id
)
335 if (id
>= have_joydevs
) {
339 if (!((dwDevType
== 0) ||
340 ((dwDevType
== DIDEVTYPE_JOYSTICK
) && (version
< 0x0800)) ||
341 (((dwDevType
== DI8DEVCLASS_GAMECTRL
) || (dwDevType
== DI8DEVTYPE_JOYSTICK
)) && (version
>= 0x0800))))
344 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
345 if (dwFlags
& DIEDFL_FORCEFEEDBACK
)
349 if (!(dwFlags
& DIEDFL_FORCEFEEDBACK
) || joydevs
[id
].has_ff
) {
350 lpddi
->guidInstance
= joydevs
[id
].guid
;
351 lpddi
->guidProduct
= DInput_Wine_Joystick_Base_GUID
;
353 lpddi
->guidFFDriver
= GUID_NULL
;
354 if (version
>= 0x0800)
355 lpddi
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
357 lpddi
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
359 MultiByteToWideChar(CP_ACP
, 0, joydevs
[id
].name
, -1, lpddi
->tszInstanceName
, MAX_PATH
);
360 MultiByteToWideChar(CP_ACP
, 0, joydevs
[id
].device
, -1, lpddi
->tszProductName
, MAX_PATH
);
366 static JoystickImpl
*alloc_device(REFGUID rguid
, const void *jvt
, IDirectInputImpl
*dinput
, struct JoyDev
*joydev
)
368 JoystickImpl
* newDevice
;
371 newDevice
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(JoystickImpl
));
372 if (newDevice
==NULL
) {
376 newDevice
->lpVtbl
= jvt
;
378 newDevice
->joyfd
= -1;
379 newDevice
->dinput
= dinput
;
380 newDevice
->joydev
= joydev
;
381 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
382 newDevice
->ff_state
= FF_STATUS_STOPPED
;
384 memcpy(&(newDevice
->guid
),rguid
,sizeof(*rguid
));
385 for (i
=0;i
<ABS_MAX
;i
++) {
386 /* apps expect the range to be the same they would get from the
387 * GetProperty/range method */
388 newDevice
->wantmin
[i
] = newDevice
->joydev
->havemin
[i
];
389 newDevice
->wantmax
[i
] = newDevice
->joydev
->havemax
[i
];
391 * direct input defines a default for the deadzone somewhere; but as long
392 * as in map_axis the code for the dead zone is commented out its no
395 newDevice
->deadz
[i
] = 0;
397 fake_current_js_state(newDevice
);
399 /* wine uses DIJOYSTATE2 as it's internal format so copy
400 * the already defined format c_dfDIJoystick2 */
401 newDevice
->df
= HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2
.dwSize
);
402 if (newDevice
->df
== 0)
404 CopyMemory(newDevice
->df
, &c_dfDIJoystick2
, c_dfDIJoystick2
.dwSize
);
406 /* copy default objects */
407 newDevice
->df
->rgodf
= HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2
.dwNumObjs
*c_dfDIJoystick2
.dwObjSize
);
408 if (newDevice
->df
->rgodf
== 0)
410 CopyMemory(newDevice
->df
->rgodf
,c_dfDIJoystick2
.rgodf
,c_dfDIJoystick2
.dwNumObjs
*c_dfDIJoystick2
.dwObjSize
);
412 /* no do the same for the internal df */
413 newDevice
->internal_df
= HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2
.dwSize
);
414 if (newDevice
->internal_df
== 0)
416 CopyMemory(newDevice
->internal_df
, &c_dfDIJoystick2
, c_dfDIJoystick2
.dwSize
);
418 /* copy default objects */
419 newDevice
->internal_df
->rgodf
= HeapAlloc(GetProcessHeap(),0,c_dfDIJoystick2
.dwNumObjs
*c_dfDIJoystick2
.dwObjSize
);
420 if (newDevice
->internal_df
->rgodf
== 0)
422 CopyMemory(newDevice
->internal_df
->rgodf
,c_dfDIJoystick2
.rgodf
,c_dfDIJoystick2
.dwNumObjs
*c_dfDIJoystick2
.dwObjSize
);
424 /* create an offsets array */
425 newDevice
->offsets
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,c_dfDIJoystick2
.dwNumObjs
*sizeof(int));
426 if (newDevice
->offsets
== 0)
429 calculate_ids(newDevice
->internal_df
);
431 /* create the default transform filter */
432 newDevice
->transform
= create_DataFormat(newDevice
->internal_df
, newDevice
->df
, newDevice
->offsets
);
433 calculate_ids(newDevice
->df
);
438 HeapFree(GetProcessHeap(),0,newDevice
->df
->rgodf
);
439 HeapFree(GetProcessHeap(),0,newDevice
->df
);
440 HeapFree(GetProcessHeap(),0,newDevice
->internal_df
->rgodf
);
441 HeapFree(GetProcessHeap(),0,newDevice
->internal_df
);
442 HeapFree(GetProcessHeap(),0,newDevice
);
446 static HRESULT
joydev_create_deviceA(IDirectInputImpl
*dinput
, REFGUID rguid
, REFIID riid
, LPDIRECTINPUTDEVICEA
* pdev
)
452 for (i
=0; i
<have_joydevs
; i
++) {
453 if (IsEqualGUID(&GUID_Joystick
,rguid
) ||
454 IsEqualGUID(&joydevs
[i
].guid
,rguid
)
456 if ((riid
== NULL
) ||
457 IsEqualGUID(&IID_IDirectInputDeviceA
,riid
) ||
458 IsEqualGUID(&IID_IDirectInputDevice2A
,riid
) ||
459 IsEqualGUID(&IID_IDirectInputDevice7A
,riid
) ||
460 IsEqualGUID(&IID_IDirectInputDevice8A
,riid
)) {
461 *pdev
= (IDirectInputDeviceA
*) alloc_device(rguid
, &JoystickAvt
, dinput
, &joydevs
[i
]);
462 TRACE("Creating a Joystick device (%p)\n", *pdev
);
464 ERR("out of memory\n");
465 return DIERR_OUTOFMEMORY
;
469 return DIERR_NOINTERFACE
;
474 return DIERR_DEVICENOTREG
;
478 static HRESULT
joydev_create_deviceW(IDirectInputImpl
*dinput
, REFGUID rguid
, REFIID riid
, LPDIRECTINPUTDEVICEW
* pdev
)
484 for (i
=0; i
<have_joydevs
; i
++) {
485 if (IsEqualGUID(&GUID_Joystick
,rguid
) ||
486 IsEqualGUID(&joydevs
[i
].guid
,rguid
)
488 if ((riid
== NULL
) ||
489 IsEqualGUID(&IID_IDirectInputDeviceW
,riid
) ||
490 IsEqualGUID(&IID_IDirectInputDevice2W
,riid
) ||
491 IsEqualGUID(&IID_IDirectInputDevice7W
,riid
) ||
492 IsEqualGUID(&IID_IDirectInputDevice8W
,riid
)) {
493 *pdev
= (IDirectInputDeviceW
*) alloc_device(rguid
, &JoystickWvt
, dinput
, &joydevs
[i
]);
494 TRACE("Creating a Joystick device (%p)\n", *pdev
);
496 ERR("out of memory\n");
497 return DIERR_OUTOFMEMORY
;
501 return DIERR_NOINTERFACE
;
506 return DIERR_DEVICENOTREG
;
509 const struct dinput_device joystick_linuxinput_device
= {
510 "Wine Linux-input joystick driver",
513 joydev_create_deviceA
,
514 joydev_create_deviceW
517 /******************************************************************************
520 static ULONG WINAPI
JoystickAImpl_Release(LPDIRECTINPUTDEVICE8A iface
)
522 JoystickImpl
*This
= (JoystickImpl
*)iface
;
525 ref
= InterlockedDecrement(&(This
->ref
));
529 /* Reset the FF state, free all effects, etc */
530 IDirectInputDevice8_SendForceFeedbackCommand(iface
, DISFFC_RESET
);
532 /* Free the data queue */
533 HeapFree(GetProcessHeap(),0,This
->data_queue
);
535 /* Free the DataFormat */
536 HeapFree(GetProcessHeap(), 0, This
->df
->rgodf
);
537 HeapFree(GetProcessHeap(), 0, This
->df
);
539 /* Free the offsets array */
540 HeapFree(GetProcessHeap(),0,This
->offsets
);
542 /* release the data transform filter */
543 release_DataFormat(This
->transform
);
545 HeapFree(GetProcessHeap(),0,This
);
549 /******************************************************************************
550 * SetDataFormat : the application can choose the format of the data
551 * the device driver sends back with GetDeviceState.
553 static HRESULT WINAPI
JoystickAImpl_SetDataFormat(
554 LPDIRECTINPUTDEVICE8A iface
,LPCDIDATAFORMAT df
557 JoystickImpl
*This
= (JoystickImpl
*)iface
;
559 TRACE("(this=%p,%p)\n",This
,df
);
562 WARN("invalid pointer\n");
566 if (df
->dwSize
!= sizeof(*df
)) {
567 WARN("invalid argument\n");
568 return DIERR_INVALIDPARAM
;
571 _dump_DIDATAFORMAT(df
);
573 if (This
->joyfd
!=-1) {
575 return DIERR_ACQUIRED
;
578 HeapFree(GetProcessHeap(),0,This
->df
->rgodf
);
579 HeapFree(GetProcessHeap(),0,This
->df
);
580 release_DataFormat(This
->transform
);
582 /* Store the new data format */
583 This
->df
= HeapAlloc(GetProcessHeap(),0,df
->dwSize
);
584 if (This
->df
==NULL
) {
585 return DIERR_OUTOFMEMORY
;
587 memcpy(This
->df
, df
, df
->dwSize
);
588 This
->df
->rgodf
= HeapAlloc(GetProcessHeap(),0,df
->dwNumObjs
*df
->dwObjSize
);
589 if (This
->df
->rgodf
==NULL
) {
590 HeapFree(GetProcessHeap(), 0, This
->df
);
591 return DIERR_OUTOFMEMORY
;
593 memcpy(This
->df
->rgodf
,df
->rgodf
,df
->dwNumObjs
*df
->dwObjSize
);
595 This
->transform
= create_DataFormat(This
->internal_df
, This
->df
, This
->offsets
);
596 calculate_ids(This
->df
);
601 /******************************************************************************
602 * Acquire : gets exclusive control of the joystick
604 static HRESULT WINAPI
JoystickAImpl_Acquire(LPDIRECTINPUTDEVICE8A iface
)
606 JoystickImpl
*This
= (JoystickImpl
*)iface
;
608 TRACE("(this=%p)\n",This
);
611 if (This
->df
==NULL
) {
612 return DIERR_INVALIDPARAM
;
615 if (-1==(This
->joyfd
=open(This
->joydev
->device
,O_RDWR
))) {
616 if (-1==(This
->joyfd
=open(This
->joydev
->device
,O_RDONLY
))) {
617 /* Couldn't open the device at all */
618 perror(This
->joydev
->device
);
619 return DIERR_NOTFOUND
;
621 /* Couldn't open in r/w but opened in read-only. */
622 WARN("Could not open %s in read-write mode. Force feedback will be disabled.\n", This
->joydev
->device
);
629 /******************************************************************************
630 * Unacquire : frees the joystick
632 static HRESULT WINAPI
JoystickAImpl_Unacquire(LPDIRECTINPUTDEVICE8A iface
)
634 JoystickImpl
*This
= (JoystickImpl
*)iface
;
636 TRACE("(this=%p)\n",This
);
637 if (This
->joyfd
!=-1) {
647 * This maps the read value (from the input event) to a value in the
648 * 'wanted' range. It also autodetects the possible range of the axe and
649 * adapts values accordingly.
652 map_axis(JoystickImpl
* This
, int axis
, int val
) {
653 int xmin
= This
->joydev
->axes
[axis
][AXE_ABSMIN
];
654 int xmax
= This
->joydev
->axes
[axis
][AXE_ABSMAX
];
655 int hmax
= This
->joydev
->havemax
[axis
];
656 int hmin
= This
->joydev
->havemin
[axis
];
657 int wmin
= This
->wantmin
[axis
];
658 int wmax
= This
->wantmax
[axis
];
661 if (val
> hmax
) This
->joydev
->havemax
[axis
] = hmax
= val
;
662 if (val
< hmin
) This
->joydev
->havemin
[axis
] = hmin
= val
;
664 if (xmin
== xmax
) return val
;
666 /* map the value from the hmin-hmax range into the wmin-wmax range */
667 ret
= MulDiv( val
- hmin
, wmax
- wmin
, hmax
- hmin
) + wmin
;
669 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
);
672 /* deadzone doesn't work comfortably enough right now. needs more testing*/
673 if ((ret
> -deadz
/2 ) && (ret
< deadz
/2)) {
674 FIXME("%d in deadzone, return mid.\n",val
);
675 return (wmax
-wmin
)/2+wmin
;
682 * set the current state of the js device as it would be with the middle
685 static void fake_current_js_state(JoystickImpl
*ji
)
688 /* center the axes */
689 ji
->js
.lX
= test_bit(ji
->joydev
->absbits
, ABS_X
) ? map_axis(ji
, ABS_X
, ji
->joydev
->axes
[ABS_X
][AXE_ABS
]) : 0;
690 ji
->js
.lY
= test_bit(ji
->joydev
->absbits
, ABS_Y
) ? map_axis(ji
, ABS_Y
, ji
->joydev
->axes
[ABS_Y
][AXE_ABS
]) : 0;
691 ji
->js
.lZ
= test_bit(ji
->joydev
->absbits
, ABS_Z
) ? map_axis(ji
, ABS_Z
, ji
->joydev
->axes
[ABS_Z
][AXE_ABS
]) : 0;
692 ji
->js
.lRx
= test_bit(ji
->joydev
->absbits
, ABS_RX
) ? map_axis(ji
, ABS_RX
, ji
->joydev
->axes
[ABS_RX
][AXE_ABS
]) : 0;
693 ji
->js
.lRy
= test_bit(ji
->joydev
->absbits
, ABS_RY
) ? map_axis(ji
, ABS_RY
, ji
->joydev
->axes
[ABS_RY
][AXE_ABS
]) : 0;
694 ji
->js
.lRz
= test_bit(ji
->joydev
->absbits
, ABS_RZ
) ? map_axis(ji
, ABS_RZ
, ji
->joydev
->axes
[ABS_RZ
][AXE_ABS
]) : 0;
695 ji
->js
.rglSlider
[0] = test_bit(ji
->joydev
->absbits
, ABS_THROTTLE
) ? map_axis(ji
, ABS_THROTTLE
, ji
->joydev
->axes
[ABS_THROTTLE
][AXE_ABS
]) : 0;
696 ji
->js
.rglSlider
[1] = test_bit(ji
->joydev
->absbits
, ABS_RUDDER
) ? map_axis(ji
, ABS_RUDDER
, ji
->joydev
->axes
[ABS_RUDDER
][AXE_ABS
]) : 0;
697 /* POV center is -1 */
698 for (i
=0; i
<4; i
++) {
699 ji
->js
.rgdwPOV
[i
] = -1;
704 * Maps an event value to a DX "clock" position:
709 static DWORD
map_pov(int event_value
, int is_x
)
715 } else if (event_value
>0) {
721 } else if (event_value
>0) {
728 static int find_property_offset(JoystickImpl
*This
, LPCDIPROPHEADER ph
)
733 for (i
=0; i
<This
->df
->dwNumObjs
; i
++) {
734 if (This
->offsets
[i
]==ph
->dwObj
) {
740 for (i
=0; i
<This
->df
->dwNumObjs
; i
++) {
741 if ((This
->df
->rgodf
[i
].dwType
& 0x00ffffff) == (ph
->dwObj
& 0x00ffffff)) {
742 ofs
= This
->df
->rgodf
[i
].dwOfs
;
747 for (i
=0; i
<This
->df
->dwNumObjs
; i
++) {
748 if (This
->offsets
[i
]==ofs
) {
755 FIXME("Unhandled ph->dwHow=='%04X'\n", (unsigned int)ph
->dwHow
);
761 /* defines how the linux input system offset mappings into c_dfDIJoystick2 */
763 lxinput_to_djoy2_offset( int ie_type
, int ie_code
)
768 case ABS_X
: return 0;
769 case ABS_Y
: return 1;
770 case ABS_Z
: return 2;
771 case ABS_RX
: return 3;
772 case ABS_RY
: return 4;
773 case ABS_RZ
: return 5;
774 case ABS_THROTTLE
: return 6;
775 case ABS_RUDDER
: return 7;
777 case ABS_HAT0Y
: return 8;
779 case ABS_HAT1Y
: return 9;
781 case ABS_HAT2Y
: return 10;
783 case ABS_HAT3Y
: return 11;
785 FIXME("Unhandled EV_ABS(0x%02X)\n", ie_code
);
792 WARN("DX8 does not support more than 128 buttons\n");
796 FIXME("Unhandled type(0x%02X)\n", ie_type
);
800 /* convert wine format offset to user format object index */
801 static int offset_to_object(JoystickImpl
*This
, int offset
)
805 for (i
= 0; i
< This
->df
->dwNumObjs
; i
++) {
806 if (This
->df
->rgodf
[i
].dwOfs
== offset
)
813 static void calculate_ids(LPDIDATAFORMAT df
)
823 /* Make two passes over the format. The first counts the number
824 * for each type and the second sets the id */
825 for (i
= 0; i
< df
->dwNumObjs
; i
++) {
826 if (DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) & DIDFT_AXIS
)
828 else if (DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) & DIDFT_POV
)
830 else if (DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) & DIDFT_BUTTON
)
836 button_base
= axis
+ pov
;
842 for (i
= 0; i
< df
->dwNumObjs
; i
++) {
844 if (DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) & DIDFT_AXIS
) {
846 type
= DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) |
847 DIDFT_MAKEINSTANCE(axis
+ axis_base
);
848 TRACE("axis type = 0x%08x\n", type
);
849 } else if (DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) & DIDFT_POV
) {
851 type
= DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) |
852 DIDFT_MAKEINSTANCE(pov
+ pov_base
);
853 TRACE("POV type = 0x%08x\n", type
);
854 } else if (DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) & DIDFT_BUTTON
) {
856 type
= DIDFT_GETTYPE(df
->rgodf
[i
].dwType
) |
857 DIDFT_MAKEINSTANCE(button
+ button_base
);
858 TRACE("button type = 0x%08x\n", type
);
860 df
->rgodf
[i
].dwType
= type
;
864 static void joy_polldev(JoystickImpl
*This
) {
867 struct input_event ie
;
874 memset(&tv
,0,sizeof(tv
));
876 FD_SET(This
->joyfd
,&readfds
);
878 if (1>select(This
->joyfd
+1,&readfds
,NULL
,NULL
,&tv
))
881 /* we have one event, so we can read */
882 if (sizeof(ie
)!=read(This
->joyfd
,&ie
,sizeof(ie
)))
885 TRACE("input_event: type %d, code %d, value %d\n",ie
.type
,ie
.code
,ie
.value
);
887 case EV_KEY
: /* button */
888 btn
= This
->joydev
->buttons
[ie
.code
];
889 TRACE("(%p) %d -> %d\n", This
, ie
.code
, btn
);
892 /* see if there is a mapping */
893 offset
= lxinput_to_djoy2_offset(ie
.type
, btn
);
897 /* and see if there is an offset in the df */
898 offset
= This
->offsets
[offset
];
902 This
->js
.rgbButtons
[btn
] = ie
.value
?0x80:0x00;
903 GEN_EVENT(offset
,This
->js
.rgbButtons
[btn
],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
907 /* see if there is a mapping */
908 offset
= lxinput_to_djoy2_offset(ie
.type
, ie
.code
);
912 /* and see if there is an offset in the df */
913 offset
= This
->offsets
[offset
];
919 This
->js
.lX
= map_axis(This
,ABS_X
,ie
.value
);
920 GEN_EVENT(offset
,This
->js
.lX
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
923 This
->js
.lY
= map_axis(This
,ABS_Y
,ie
.value
);
924 GEN_EVENT(offset
,This
->js
.lY
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
927 This
->js
.lZ
= map_axis(This
,ABS_Z
,ie
.value
);
928 GEN_EVENT(offset
,This
->js
.lZ
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
931 This
->js
.lRx
= map_axis(This
,ABS_RX
,ie
.value
);
932 GEN_EVENT(offset
,This
->js
.lRx
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
935 This
->js
.lRy
= map_axis(This
,ABS_RY
,ie
.value
);
936 GEN_EVENT(offset
,This
->js
.lRy
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
939 This
->js
.lRz
= map_axis(This
,ABS_RZ
,ie
.value
);
940 GEN_EVENT(offset
,This
->js
.lRz
,ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
943 This
->js
.rglSlider
[0] = map_axis(This
,ABS_THROTTLE
,ie
.value
);
944 GEN_EVENT(offset
,This
->js
.rglSlider
[0],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
947 This
->js
.rglSlider
[1] = map_axis(This
,ABS_RUDDER
,ie
.value
);
948 GEN_EVENT(offset
,This
->js
.rglSlider
[1],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
952 This
->js
.rgdwPOV
[0] = map_pov(ie
.value
,ie
.code
==ABS_HAT0X
);
953 GEN_EVENT(offset
,This
->js
.rgdwPOV
[0],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
957 This
->js
.rgdwPOV
[1] = map_pov(ie
.value
,ie
.code
==ABS_HAT1X
);
958 GEN_EVENT(offset
,This
->js
.rgdwPOV
[1],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
962 This
->js
.rgdwPOV
[2] = map_pov(ie
.value
,ie
.code
==ABS_HAT2X
);
963 GEN_EVENT(offset
,This
->js
.rgdwPOV
[2],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
967 This
->js
.rgdwPOV
[3] = map_pov(ie
.value
,ie
.code
==ABS_HAT3X
);
968 GEN_EVENT(offset
,This
->js
.rgdwPOV
[3],ie
.time
.tv_usec
,(This
->dinput
->evsequence
)++);
971 FIXME("unhandled joystick axe event (code %d, value %d)\n",ie
.code
,ie
.value
);
975 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
977 This
->ff_state
= ie
.value
;
982 /* there is nothing to do */
986 FIXME("joystick cannot handle type %d event (code %d)\n",ie
.type
,ie
.code
);
992 /******************************************************************************
993 * GetDeviceState : returns the "state" of the joystick.
996 static HRESULT WINAPI
JoystickAImpl_GetDeviceState(
997 LPDIRECTINPUTDEVICE8A iface
,DWORD len
,LPVOID ptr
999 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1001 TRACE("(this=%p,0x%08x,%p)\n", This
, len
, ptr
);
1003 if (This
->joyfd
==-1) {
1004 WARN("not acquired\n");
1005 return DIERR_NOTACQUIRED
;
1010 /* convert and copy data to user supplied buffer */
1011 fill_DataFormat(ptr
, &This
->js
, This
->transform
);
1016 /******************************************************************************
1017 * GetDeviceData : gets buffered input data.
1019 static HRESULT WINAPI
JoystickAImpl_GetDeviceData(LPDIRECTINPUTDEVICE8A iface
,
1021 LPDIDEVICEOBJECTDATA dod
,
1025 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1030 TRACE("(%p)->(dods=%d,entries=%d,fl=0x%08x)\n", This
, dodsize
, *entries
, flags
);
1032 if (This
->joyfd
==-!1) {
1033 WARN("not acquired\n");
1034 return DIERR_NOTACQUIRED
;
1038 if (flags
& DIGDD_PEEK
)
1039 FIXME("DIGDD_PEEK\n");
1041 len
= ((This
->queue_head
< This
->queue_tail
) ? This
->queue_len
: 0)
1042 + (This
->queue_head
- This
->queue_tail
);
1048 TRACE("Application discarding %d event(s).\n", len
);
1051 nqtail
= This
->queue_tail
+ len
;
1052 while (nqtail
>= This
->queue_len
)
1053 nqtail
-= This
->queue_len
;
1055 if (dodsize
< sizeof(DIDEVICEOBJECTDATA_DX3
)) {
1056 ERR("Wrong structure size !\n");
1057 return DIERR_INVALIDPARAM
;
1061 TRACE("Application retrieving %d event(s).\n", len
);
1064 nqtail
= This
->queue_tail
;
1066 /* Copy the buffered data into the application queue */
1067 memcpy((char *)dod
+ *entries
* dodsize
, This
->data_queue
+ nqtail
, dodsize
);
1068 /* Advance position */
1070 if (nqtail
>= This
->queue_len
)
1071 nqtail
-= This
->queue_len
;
1077 if (This
->overflow
) {
1078 hr
= DI_BUFFEROVERFLOW
;
1079 if (!(flags
& DIGDD_PEEK
)) {
1080 This
->overflow
= FALSE
;
1084 if (!(flags
& DIGDD_PEEK
))
1085 This
->queue_tail
= nqtail
;
1090 /******************************************************************************
1091 * SetProperty : change input device properties
1093 static HRESULT WINAPI
JoystickAImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface
,
1097 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1100 WARN("invalid argument\n");
1101 return DIERR_INVALIDPARAM
;
1104 TRACE("(this=%p,%s,%p)\n",This
,debugstr_guid(rguid
),ph
);
1105 TRACE("ph.dwSize = %d, ph.dwHeaderSize =%d, ph.dwObj = %d, ph.dwHow= %d\n",
1106 ph
->dwSize
, ph
->dwHeaderSize
, ph
->dwObj
, ph
->dwHow
);
1108 if (!HIWORD(rguid
)) {
1109 switch (LOWORD(rguid
)) {
1110 case (DWORD
) DIPROP_BUFFERSIZE
: {
1111 LPCDIPROPDWORD pd
= (LPCDIPROPDWORD
)ph
;
1113 TRACE("buffersize = %d\n", pd
->dwData
);
1114 if (This
->data_queue
) {
1115 This
->data_queue
= HeapReAlloc(GetProcessHeap(),0, This
->data_queue
, pd
->dwData
* sizeof(DIDEVICEOBJECTDATA
));
1117 This
->data_queue
= HeapAlloc(GetProcessHeap(),0, pd
->dwData
* sizeof(DIDEVICEOBJECTDATA
));
1119 This
->queue_head
= 0;
1120 This
->queue_tail
= 0;
1121 This
->queue_len
= pd
->dwData
;
1124 case (DWORD
)DIPROP_RANGE
: {
1125 LPCDIPROPRANGE pr
= (LPCDIPROPRANGE
)ph
;
1127 if (ph
->dwHow
== DIPH_DEVICE
) {
1129 TRACE("proprange(%d,%d) all\n", pr
->lMin
, pr
->lMax
);
1130 for (i
= 0; i
< This
->df
->dwNumObjs
; i
++) {
1131 This
->wantmin
[i
] = pr
->lMin
;
1132 This
->wantmax
[i
] = pr
->lMax
;
1135 int obj
= find_property_offset(This
, ph
);
1136 TRACE("proprange(%d,%d) obj=%d\n", pr
->lMin
, pr
->lMax
, obj
);
1138 This
->wantmin
[obj
] = pr
->lMin
;
1139 This
->wantmax
[obj
] = pr
->lMax
;
1142 fake_current_js_state(This
);
1145 case (DWORD
)DIPROP_DEADZONE
: {
1146 LPCDIPROPDWORD pd
= (LPCDIPROPDWORD
)ph
;
1147 if (ph
->dwHow
== DIPH_DEVICE
) {
1149 TRACE("deadzone(%d) all\n", pd
->dwData
);
1150 for (i
= 0; i
< This
->df
->dwNumObjs
; i
++) {
1151 This
->deadz
[i
] = pd
->dwData
;
1154 int obj
= find_property_offset(This
, ph
);
1155 TRACE("deadzone(%d) obj=%d\n", pd
->dwData
, obj
);
1157 This
->deadz
[obj
] = pd
->dwData
;
1160 fake_current_js_state(This
);
1164 FIXME("Unknown type %p (%s)\n",rguid
,debugstr_guid(rguid
));
1171 /******************************************************************************
1172 * SetEventNotification : specifies event to be sent on state change
1174 static HRESULT WINAPI
JoystickAImpl_SetEventNotification(
1175 LPDIRECTINPUTDEVICE8A iface
, HANDLE hnd
1177 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1179 TRACE("(this=%p,%p)\n",This
,hnd
);
1184 static HRESULT WINAPI
JoystickAImpl_GetCapabilities(
1185 LPDIRECTINPUTDEVICE8A iface
,
1186 LPDIDEVCAPS lpDIDevCaps
)
1188 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1189 int i
,axes
,buttons
,povs
;
1191 TRACE("%p->(%p)\n",iface
,lpDIDevCaps
);
1194 WARN("invalid pointer\n");
1198 if (lpDIDevCaps
->dwSize
!= sizeof(DIDEVCAPS
)) {
1199 WARN("invalid argument\n");
1200 return DIERR_INVALIDPARAM
;
1203 lpDIDevCaps
->dwFlags
= DIDC_ATTACHED
;
1204 if (This
->dinput
->dwVersion
>= 0x0800)
1205 lpDIDevCaps
->dwDevType
= DI8DEVTYPE_JOYSTICK
| (DI8DEVTYPEJOYSTICK_STANDARD
<< 8);
1207 lpDIDevCaps
->dwDevType
= DIDEVTYPE_JOYSTICK
| (DIDEVTYPEJOYSTICK_TRADITIONAL
<< 8);
1210 for (i
=0;i
<ABS_MAX
;i
++) {
1211 if (!test_bit(This
->joydev
->absbits
,i
)) continue;
1213 case ABS_HAT0X
: case ABS_HAT0Y
:
1214 case ABS_HAT1X
: case ABS_HAT1Y
:
1215 case ABS_HAT2X
: case ABS_HAT2Y
:
1216 case ABS_HAT3X
: case ABS_HAT3Y
:
1217 /* will be handled as POV - see below */
1224 for (i
=0;i
<KEY_MAX
;i
++) if (test_bit(This
->joydev
->keybits
,i
)) buttons
++;
1226 for (i
=0; i
<4; i
++) {
1227 if (test_bit(This
->joydev
->absbits
,ABS_HAT0X
+(i
<<1)) && test_bit(This
->joydev
->absbits
,ABS_HAT0Y
+(i
<<1))) {
1232 if (This
->joydev
->has_ff
)
1233 lpDIDevCaps
->dwFlags
|= DIDC_FORCEFEEDBACK
;
1235 lpDIDevCaps
->dwAxes
= axes
;
1236 lpDIDevCaps
->dwButtons
= buttons
;
1237 lpDIDevCaps
->dwPOVs
= povs
;
1242 static HRESULT WINAPI
JoystickAImpl_Poll(LPDIRECTINPUTDEVICE8A iface
) {
1243 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1244 TRACE("(%p)\n",This
);
1246 if (This
->joyfd
==-1) {
1247 return DIERR_NOTACQUIRED
;
1254 /******************************************************************************
1255 * EnumObjects : enumerate the different buttons and axis...
1257 static HRESULT WINAPI
JoystickAImpl_EnumObjects(
1258 LPDIRECTINPUTDEVICE8A iface
,
1259 LPDIENUMDEVICEOBJECTSCALLBACKA lpCallback
,
1263 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1264 DIDEVICEOBJECTINSTANCEA ddoi
;
1265 int user_offset
, user_object
;
1267 TRACE("(this=%p,%p,%p,%08x)\n", This
, lpCallback
, lpvRef
, dwFlags
);
1268 if (TRACE_ON(dinput
)) {
1269 TRACE(" - flags = ");
1270 _dump_EnumObjects_flags(dwFlags
);
1274 /* Only the fields till dwFFMaxForce are relevant */
1275 ddoi
.dwSize
= FIELD_OFFSET(DIDEVICEOBJECTINSTANCEA
, dwFFMaxForce
);
1277 /* For the joystick, do as is done in the GetCapabilities function */
1278 /* FIXME: needs more items */
1279 if ((dwFlags
== DIDFT_ALL
) ||
1280 (dwFlags
& DIDFT_AXIS
)) {
1283 for (i
= 0; i
< ABS_MAX
; i
++) {
1284 if (!test_bit(This
->joydev
->absbits
,i
)) continue;
1288 ddoi
.guidType
= GUID_XAxis
;
1291 ddoi
.guidType
= GUID_YAxis
;
1294 ddoi
.guidType
= GUID_ZAxis
;
1297 ddoi
.guidType
= GUID_RxAxis
;
1300 ddoi
.guidType
= GUID_RyAxis
;
1303 ddoi
.guidType
= GUID_RzAxis
;
1306 ddoi
.guidType
= GUID_Slider
;
1309 ddoi
.guidType
= GUID_Slider
;
1311 case ABS_HAT0X
: case ABS_HAT0Y
:
1312 case ABS_HAT1X
: case ABS_HAT1Y
:
1313 case ABS_HAT2X
: case ABS_HAT2Y
:
1314 case ABS_HAT3X
: case ABS_HAT3Y
:
1315 /* will be handled as POV - see below */
1318 FIXME("unhandled abs axis 0x%02x, ignoring!\n",i
);
1321 user_offset
= lxinput_to_djoy2_offset(EV_ABS
, i
);
1322 if (user_offset
== -1) {
1325 user_offset
= This
->offsets
[user_offset
];
1326 if (user_offset
== -1) {
1329 user_object
= offset_to_object(This
, user_offset
);
1330 ddoi
.dwType
= This
->df
->rgodf
[user_object
].dwType
& 0x00ffffff;
1331 ddoi
.dwOfs
= This
->df
->rgodf
[user_object
].dwOfs
;
1332 /* Linux event force feedback supports only (and always) x and y axes */
1333 if (i
== ABS_X
|| i
== ABS_Y
) {
1334 if (This
->joydev
->has_ff
)
1335 ddoi
.dwFlags
|= DIDOI_FFACTUATOR
;
1337 sprintf(ddoi
.tszName
, "%d-Axis", i
);
1338 _dump_OBJECTINSTANCEA(&ddoi
);
1339 if (lpCallback(&ddoi
, lpvRef
) != DIENUM_CONTINUE
) {
1345 if ((dwFlags
== DIDFT_ALL
) ||
1346 (dwFlags
& DIDFT_POV
)) {
1348 ddoi
.guidType
= GUID_POV
;
1349 for (i
=0; i
<4; i
++) {
1350 if (test_bit(This
->joydev
->absbits
,ABS_HAT0X
+(i
<<1)) && test_bit(This
->joydev
->absbits
,ABS_HAT0Y
+(i
<<1))) {
1351 user_offset
= lxinput_to_djoy2_offset(EV_ABS
, ABS_HAT0X
+i
);
1352 if (user_offset
== -1) {
1355 user_offset
= This
->offsets
[user_offset
];
1356 if (user_offset
== -1) {
1359 user_object
= offset_to_object(This
, user_offset
);
1360 ddoi
.dwType
= This
->df
->rgodf
[user_object
].dwType
& 0x00ffffff;
1361 ddoi
.dwOfs
= This
->df
->rgodf
[user_object
].dwOfs
;
1362 sprintf(ddoi
.tszName
, "%d-POV", i
);
1363 _dump_OBJECTINSTANCEA(&ddoi
);
1364 if (lpCallback(&ddoi
, lpvRef
) != DIENUM_CONTINUE
) {
1371 if ((dwFlags
== DIDFT_ALL
) ||
1372 (dwFlags
& DIDFT_BUTTON
)) {
1375 /*The DInput SDK says that GUID_Button is only for mouse buttons but well*/
1377 ddoi
.guidType
= GUID_Button
;
1379 for (i
= 0; i
< KEY_MAX
; i
++) {
1380 if (!test_bit(This
->joydev
->keybits
,i
)) continue;
1381 user_offset
= lxinput_to_djoy2_offset(EV_KEY
, btncount
);
1382 if (user_offset
== -1) {
1385 user_offset
= This
->offsets
[user_offset
];
1386 if (user_offset
== -1) {
1389 user_object
= offset_to_object(This
, user_offset
);
1390 ddoi
.dwType
= This
->df
->rgodf
[user_object
].dwType
& 0x00ffffff;
1391 ddoi
.dwOfs
= This
->df
->rgodf
[user_object
].dwOfs
;
1392 sprintf(ddoi
.tszName
, "%d-Button", btncount
);
1394 _dump_OBJECTINSTANCEA(&ddoi
);
1395 if (lpCallback(&ddoi
, lpvRef
) != DIENUM_CONTINUE
) {
1404 static HRESULT WINAPI
JoystickWImpl_EnumObjects(LPDIRECTINPUTDEVICE8W iface
,
1405 LPDIENUMDEVICEOBJECTSCALLBACKW lpCallback
,
1409 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1411 device_enumobjects_AtoWcb_data data
;
1413 data
.lpCallBack
= lpCallback
;
1414 data
.lpvRef
= lpvRef
;
1416 return JoystickAImpl_EnumObjects((LPDIRECTINPUTDEVICE8A
) This
, (LPDIENUMDEVICEOBJECTSCALLBACKA
) DIEnumDevicesCallbackAtoW
, (LPVOID
) &data
, dwFlags
);
1419 /******************************************************************************
1420 * GetProperty : get input device properties
1422 static HRESULT WINAPI
JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface
,
1424 LPDIPROPHEADER pdiph
)
1426 JoystickImpl
*This
= (JoystickImpl
*)iface
;
1428 TRACE("(this=%p,%s,%p)\n",
1429 iface
, debugstr_guid(rguid
), pdiph
);
1431 if (TRACE_ON(dinput
))
1432 _dump_DIPROPHEADER(pdiph
);
1434 if (!HIWORD(rguid
)) {
1435 switch (LOWORD(rguid
)) {
1436 case (DWORD
) DIPROP_BUFFERSIZE
: {
1437 LPDIPROPDWORD pd
= (LPDIPROPDWORD
)pdiph
;
1439 TRACE(" return buffersize = %d\n",This
->queue_len
);
1440 pd
->dwData
= This
->queue_len
;
1444 case (DWORD
) DIPROP_RANGE
: {
1445 LPDIPROPRANGE pr
= (LPDIPROPRANGE
) pdiph
;
1446 int obj
= find_property_offset(This
, pdiph
);
1448 pr
->lMin
= This
->joydev
->havemin
[obj
];
1449 pr
->lMax
= This
->joydev
->havemax
[obj
];
1450 TRACE("range(%d, %d) obj=%d\n", pr
->lMin
, pr
->lMax
, obj
);
1457 FIXME("Unknown type %p (%s)\n",rguid
,debugstr_guid(rguid
));
1466 /******************************************************************************
1467 * CreateEffect - Create a new FF effect with the specified params
1469 static HRESULT WINAPI
JoystickAImpl_CreateEffect(LPDIRECTINPUTDEVICE8A iface
,
1472 LPDIRECTINPUTEFFECT
*ppdef
,
1473 LPUNKNOWN pUnkOuter
)
1475 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1476 EffectListItem
* new = NULL
;
1477 HRESULT retval
= DI_OK
;
1480 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1481 TRACE("(this=%p,%p,%p,%p,%p)\n", This
, rguid
, lpeff
, ppdef
, pUnkOuter
);
1483 #ifndef HAVE_STRUCT_FF_EFFECT_DIRECTION
1484 TRACE("not available (compiled w/o ff support)\n");
1489 new = malloc(sizeof(EffectListItem
));
1490 new->next
= This
->top_effect
;
1491 This
->top_effect
= new;
1493 retval
= linuxinput_create_effect(&(This
->joyfd
), rguid
, &(new->ref
));
1494 if (retval
!= DI_OK
)
1498 retval
= IDirectInputEffect_SetParameters(new->ref
, lpeff
, 0);
1499 if (retval
!= DI_OK
&& retval
!= DI_DOWNLOADSKIPPED
)
1504 if (pUnkOuter
!= NULL
)
1505 FIXME("Interface aggregation not implemented.\n");
1509 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */
1512 /*******************************************************************************
1513 * EnumEffects - Enumerate available FF effects
1515 static HRESULT WINAPI
JoystickAImpl_EnumEffects(LPDIRECTINPUTDEVICE8A iface
,
1516 LPDIENUMEFFECTSCALLBACKA lpCallback
,
1520 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1521 DIEFFECTINFOA dei
; /* feif */
1522 DWORD type
= DIEFT_GETTYPE(dwEffType
);
1523 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1525 TRACE("(this=%p,%p,%d) type=%d\n", This
, pvRef
, dwEffType
, type
);
1527 dei
.dwSize
= sizeof(DIEFFECTINFOA
);
1529 if ((type
== DIEFT_ALL
|| type
== DIEFT_CONSTANTFORCE
)
1530 && test_bit(This
->joydev
->ffbits
, FF_CONSTANT
)) {
1531 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_ConstantForce
);
1532 (*lpCallback
)(&dei
, pvRef
);
1535 if ((type
== DIEFT_ALL
|| type
== DIEFT_PERIODIC
)
1536 && test_bit(This
->joydev
->ffbits
, FF_PERIODIC
)) {
1537 if (test_bit(This
->joydev
->ffbits
, FF_SQUARE
)) {
1538 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Square
);
1539 (*lpCallback
)(&dei
, pvRef
);
1541 if (test_bit(This
->joydev
->ffbits
, FF_SINE
)) {
1542 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Sine
);
1543 (*lpCallback
)(&dei
, pvRef
);
1545 if (test_bit(This
->joydev
->ffbits
, FF_TRIANGLE
)) {
1546 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Triangle
);
1547 (*lpCallback
)(&dei
, pvRef
);
1549 if (test_bit(This
->joydev
->ffbits
, FF_SAW_UP
)) {
1550 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothUp
);
1551 (*lpCallback
)(&dei
, pvRef
);
1553 if (test_bit(This
->joydev
->ffbits
, FF_SAW_DOWN
)) {
1554 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothDown
);
1555 (*lpCallback
)(&dei
, pvRef
);
1559 if ((type
== DIEFT_ALL
|| type
== DIEFT_RAMPFORCE
)
1560 && test_bit(This
->joydev
->ffbits
, FF_RAMP
)) {
1561 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_RampForce
);
1562 (*lpCallback
)(&dei
, pvRef
);
1565 if (type
== DIEFT_ALL
|| type
== DIEFT_CONDITION
) {
1566 if (test_bit(This
->joydev
->ffbits
, FF_SPRING
)) {
1567 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Spring
);
1568 (*lpCallback
)(&dei
, pvRef
);
1570 if (test_bit(This
->joydev
->ffbits
, FF_DAMPER
)) {
1571 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Damper
);
1572 (*lpCallback
)(&dei
, pvRef
);
1574 if (test_bit(This
->joydev
->ffbits
, FF_INERTIA
)) {
1575 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Inertia
);
1576 (*lpCallback
)(&dei
, pvRef
);
1578 if (test_bit(This
->joydev
->ffbits
, FF_FRICTION
)) {
1579 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Friction
);
1580 (*lpCallback
)(&dei
, pvRef
);
1589 static HRESULT WINAPI
JoystickWImpl_EnumEffects(LPDIRECTINPUTDEVICE8W iface
,
1590 LPDIENUMEFFECTSCALLBACKW lpCallback
,
1594 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1595 /* seems silly to duplicate all this code but all the structures and functions
1596 * are actually different (A/W) */
1597 DIEFFECTINFOW dei
; /* feif */
1598 DWORD type
= DIEFT_GETTYPE(dwEffType
);
1599 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1600 int xfd
= This
->joyfd
;
1602 TRACE("(this=%p,%p,%d) type=%d fd=%d\n", This
, pvRef
, dwEffType
, type
, xfd
);
1604 dei
.dwSize
= sizeof(DIEFFECTINFOW
);
1606 if ((type
== DIEFT_ALL
|| type
== DIEFT_CONSTANTFORCE
)
1607 && test_bit(This
->joydev
->ffbits
, FF_CONSTANT
)) {
1608 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_ConstantForce
);
1609 (*lpCallback
)(&dei
, pvRef
);
1612 if ((type
== DIEFT_ALL
|| type
== DIEFT_PERIODIC
)
1613 && test_bit(This
->joydev
->ffbits
, FF_PERIODIC
)) {
1614 if (test_bit(This
->joydev
->ffbits
, FF_SQUARE
)) {
1615 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Square
);
1616 (*lpCallback
)(&dei
, pvRef
);
1618 if (test_bit(This
->joydev
->ffbits
, FF_SINE
)) {
1619 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Sine
);
1620 (*lpCallback
)(&dei
, pvRef
);
1622 if (test_bit(This
->joydev
->ffbits
, FF_TRIANGLE
)) {
1623 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Triangle
);
1624 (*lpCallback
)(&dei
, pvRef
);
1626 if (test_bit(This
->joydev
->ffbits
, FF_SAW_UP
)) {
1627 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothUp
);
1628 (*lpCallback
)(&dei
, pvRef
);
1630 if (test_bit(This
->joydev
->ffbits
, FF_SAW_DOWN
)) {
1631 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_SawtoothDown
);
1632 (*lpCallback
)(&dei
, pvRef
);
1636 if ((type
== DIEFT_ALL
|| type
== DIEFT_RAMPFORCE
)
1637 && test_bit(This
->joydev
->ffbits
, FF_RAMP
)) {
1638 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_RampForce
);
1639 (*lpCallback
)(&dei
, pvRef
);
1642 if (type
== DIEFT_ALL
|| type
== DIEFT_CONDITION
) {
1643 if (test_bit(This
->joydev
->ffbits
, FF_SPRING
)) {
1644 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Spring
);
1645 (*lpCallback
)(&dei
, pvRef
);
1647 if (test_bit(This
->joydev
->ffbits
, FF_DAMPER
)) {
1648 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Damper
);
1649 (*lpCallback
)(&dei
, pvRef
);
1651 if (test_bit(This
->joydev
->ffbits
, FF_INERTIA
)) {
1652 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Inertia
);
1653 (*lpCallback
)(&dei
, pvRef
);
1655 if (test_bit(This
->joydev
->ffbits
, FF_FRICTION
)) {
1656 IDirectInputDevice8_GetEffectInfo(iface
, &dei
, &GUID_Friction
);
1657 (*lpCallback
)(&dei
, pvRef
);
1661 /* return to unaquired state if that's where it was */
1663 IDirectInputDevice8_Unacquire(iface
);
1669 /*******************************************************************************
1670 * GetEffectInfo - Get information about a particular effect
1672 static HRESULT WINAPI
JoystickAImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8A iface
,
1673 LPDIEFFECTINFOA pdei
,
1676 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1678 TRACE("(this=%p,%p,%s)\n", This
, pdei
, _dump_dinput_GUID(guid
));
1680 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1681 return linuxinput_get_info_A(This
->joyfd
, guid
, pdei
);
1687 static HRESULT WINAPI
JoystickWImpl_GetEffectInfo(LPDIRECTINPUTDEVICE8W iface
,
1688 LPDIEFFECTINFOW pdei
,
1691 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1693 TRACE("(this=%p,%p,%s)\n", This
, pdei
, _dump_dinput_GUID(guid
));
1695 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1696 return linuxinput_get_info_W(This
->joyfd
, guid
, pdei
);
1702 /*******************************************************************************
1703 * GetForceFeedbackState - Get information about the device's FF state
1705 static HRESULT WINAPI
JoystickAImpl_GetForceFeedbackState(
1706 LPDIRECTINPUTDEVICE8A iface
,
1709 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1711 TRACE("(this=%p,%p)\n", This
, pdwOut
);
1715 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1716 /* DIGFFS_STOPPED is the only mandatory flag to report */
1717 if (This
->ff_state
== FF_STATUS_STOPPED
)
1718 (*pdwOut
) |= DIGFFS_STOPPED
;
1724 /*******************************************************************************
1725 * SendForceFeedbackCommand - Send a command to the device's FF system
1727 static HRESULT WINAPI
JoystickAImpl_SendForceFeedbackCommand(
1728 LPDIRECTINPUTDEVICE8A iface
,
1731 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1732 TRACE("(this=%p,%d)\n", This
, dwFlags
);
1734 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
1735 if (dwFlags
== DISFFC_STOPALL
) {
1736 /* Stop all effects */
1737 EffectListItem
* itr
= This
->top_effect
;
1739 IDirectInputEffect_Stop(itr
->ref
);
1742 } else if (dwFlags
== DISFFC_RESET
) {
1743 /* Stop, unload, release and free all effects */
1744 /* This returns the device to its "bare" state */
1745 while (This
->top_effect
) {
1746 EffectListItem
* temp
= This
->top_effect
;
1747 IDirectInputEffect_Stop(temp
->ref
);
1748 IDirectInputEffect_Unload(temp
->ref
);
1749 IDirectInputEffect_Release(temp
->ref
);
1750 This
->top_effect
= temp
->next
;
1753 } else if (dwFlags
== DISFFC_PAUSE
|| dwFlags
== DISFFC_CONTINUE
) {
1754 FIXME("No support for Pause or Continue in linux\n");
1755 } else if (dwFlags
== DISFFC_SETACTUATORSOFF
1756 || dwFlags
== DISFFC_SETACTUATORSON
) {
1757 FIXME("No direct actuator control in linux\n");
1759 FIXME("Unknown Force Feedback Command!\n");
1760 return DIERR_INVALIDPARAM
;
1764 return DIERR_UNSUPPORTED
;
1768 /*******************************************************************************
1769 * EnumCreatedEffectObjects - Enumerate all the effects that have been
1770 * created for this device.
1772 static HRESULT WINAPI
JoystickAImpl_EnumCreatedEffectObjects(
1773 LPDIRECTINPUTDEVICE8A iface
,
1774 LPDIENUMCREATEDEFFECTOBJECTSCALLBACK lpCallback
,
1778 /* this function is safe to call on non-ff-enabled builds */
1780 JoystickImpl
* This
= (JoystickImpl
*)iface
;
1781 EffectListItem
* itr
= This
->top_effect
;
1782 TRACE("(this=%p,%p,%p,%d)\n", This
, lpCallback
, pvRef
, dwFlags
);
1785 return DIERR_INVALIDPARAM
;
1788 FIXME("Flags specified, but no flags exist yet (DX9)!");
1791 (*lpCallback
)(itr
->ref
, pvRef
);
1798 static const IDirectInputDevice8AVtbl JoystickAvt
=
1800 IDirectInputDevice2AImpl_QueryInterface
,
1801 IDirectInputDevice2AImpl_AddRef
,
1802 JoystickAImpl_Release
,
1803 JoystickAImpl_GetCapabilities
,
1804 JoystickAImpl_EnumObjects
,
1805 JoystickAImpl_GetProperty
,
1806 JoystickAImpl_SetProperty
,
1807 JoystickAImpl_Acquire
,
1808 JoystickAImpl_Unacquire
,
1809 JoystickAImpl_GetDeviceState
,
1810 JoystickAImpl_GetDeviceData
,
1811 JoystickAImpl_SetDataFormat
,
1812 JoystickAImpl_SetEventNotification
,
1813 IDirectInputDevice2AImpl_SetCooperativeLevel
,
1814 IDirectInputDevice2AImpl_GetObjectInfo
,
1815 IDirectInputDevice2AImpl_GetDeviceInfo
,
1816 IDirectInputDevice2AImpl_RunControlPanel
,
1817 IDirectInputDevice2AImpl_Initialize
,
1818 JoystickAImpl_CreateEffect
,
1819 JoystickAImpl_EnumEffects
,
1820 JoystickAImpl_GetEffectInfo
,
1821 JoystickAImpl_GetForceFeedbackState
,
1822 JoystickAImpl_SendForceFeedbackCommand
,
1823 JoystickAImpl_EnumCreatedEffectObjects
,
1824 IDirectInputDevice2AImpl_Escape
,
1826 IDirectInputDevice2AImpl_SendDeviceData
,
1827 IDirectInputDevice7AImpl_EnumEffectsInFile
,
1828 IDirectInputDevice7AImpl_WriteEffectToFile
,
1829 IDirectInputDevice8AImpl_BuildActionMap
,
1830 IDirectInputDevice8AImpl_SetActionMap
,
1831 IDirectInputDevice8AImpl_GetImageInfo
1834 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1835 # define XCAST(fun) (typeof(JoystickWvt.fun))
1837 # define XCAST(fun) (void*)
1840 static const IDirectInputDevice8WVtbl JoystickWvt
=
1842 IDirectInputDevice2WImpl_QueryInterface
,
1843 XCAST(AddRef
)IDirectInputDevice2AImpl_AddRef
,
1844 XCAST(Release
)JoystickAImpl_Release
,
1845 XCAST(GetCapabilities
)JoystickAImpl_GetCapabilities
,
1846 JoystickWImpl_EnumObjects
,
1847 XCAST(GetProperty
)JoystickAImpl_GetProperty
,
1848 XCAST(SetProperty
)JoystickAImpl_SetProperty
,
1849 XCAST(Acquire
)JoystickAImpl_Acquire
,
1850 XCAST(Unacquire
)JoystickAImpl_Unacquire
,
1851 XCAST(GetDeviceState
)JoystickAImpl_GetDeviceState
,
1852 XCAST(GetDeviceData
)JoystickAImpl_GetDeviceData
,
1853 XCAST(SetDataFormat
)JoystickAImpl_SetDataFormat
,
1854 XCAST(SetEventNotification
)JoystickAImpl_SetEventNotification
,
1855 XCAST(SetCooperativeLevel
)IDirectInputDevice2AImpl_SetCooperativeLevel
,
1856 IDirectInputDevice2WImpl_GetObjectInfo
,
1857 IDirectInputDevice2WImpl_GetDeviceInfo
,
1858 XCAST(RunControlPanel
)IDirectInputDevice2AImpl_RunControlPanel
,
1859 XCAST(Initialize
)IDirectInputDevice2AImpl_Initialize
,
1860 XCAST(CreateEffect
)JoystickAImpl_CreateEffect
,
1861 JoystickWImpl_EnumEffects
,
1862 JoystickWImpl_GetEffectInfo
,
1863 XCAST(GetForceFeedbackState
)JoystickAImpl_GetForceFeedbackState
,
1864 XCAST(SendForceFeedbackCommand
)JoystickAImpl_SendForceFeedbackCommand
,
1865 XCAST(EnumCreatedEffectObjects
)JoystickAImpl_EnumCreatedEffectObjects
,
1866 XCAST(Escape
)IDirectInputDevice2AImpl_Escape
,
1867 XCAST(Poll
)JoystickAImpl_Poll
,
1868 XCAST(SendDeviceData
)IDirectInputDevice2AImpl_SendDeviceData
,
1869 IDirectInputDevice7WImpl_EnumEffectsInFile
,
1870 IDirectInputDevice7WImpl_WriteEffectToFile
,
1871 IDirectInputDevice8WImpl_BuildActionMap
,
1872 IDirectInputDevice8WImpl_SetActionMap
,
1873 IDirectInputDevice8WImpl_GetImageInfo
1877 #else /* HAVE_CORRECT_LINUXINPUT_H */
1879 const struct dinput_device joystick_linuxinput_device
= {
1880 "Wine Linux-input joystick driver",
1887 #endif /* HAVE_CORRECT_LINUXINPUT_H */