?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msctf: Maintain context reference in ranges.
[wine.git] / dlls / dinput / joystick.c
blob8ea7850621c3486db94314f9f7df7a3989342661
1 /* DirectInput Generic Joystick device
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2009 Aric Stewart, CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 /*
24 * To Do:
25 * dead zone
26 * force feedback
27 */
28
29 #include <stdio.h>
30
31 #include "joystick_private.h"
32 #include "wine/debug.h"
33 #include "winreg.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
36
37 #define VID_MICROSOFT 0x045e
38
39 static const WORD PID_XBOX_CONTROLLERS[] = {
40 0x0202, /* Xbox Controller */
41 0x0285, /* Xbox Controller S */
42 0x0289, /* Xbox Controller S */
43 0x028e, /* Xbox360 Controller */
44 0x028f, /* Xbox360 Wireless Controller */
45 0x02d1, /* Xbox One Controller */
46 0x02dd, /* Xbox One Controller (Covert Forces/Firmware 2015) */
47 0x02e0, /* Xbox One X Controller */
48 0x02e3, /* Xbox One Elite Controller */
49 0x02e6, /* Wireless XBox Controller Dongle */
50 0x02ea, /* Xbox One S Controller */
51 0x02fd, /* Xbox One S Controller (Firmware 2017) */
52 0x0719, /* Xbox 360 Wireless Adapter */
53 };
54
55 /* Windows uses this GUID for guidProduct on non-keyboard/mouse devices.
56 * Data1 contains the device VID (low word) and PID (high word).
57 * Data4 ends with the ASCII bytes "PIDVID".
58 */
59 const GUID DInput_PIDVID_Product_GUID = { /* device_pidvid-0000-0000-0000-504944564944 */
60 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x50, 0x49, 0x44, 0x56, 0x49, 0x44}
61 };
62
63 static inline JoystickGenericImpl *impl_from_IDirectInputDevice8W(IDirectInputDevice8W *iface)
64 {
65 return CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8W_iface), JoystickGenericImpl, base);
66 }
67
68 DWORD typeFromGUID(REFGUID guid)
69 {
70 if (IsEqualGUID(guid, &GUID_ConstantForce)) {
71 return DIEFT_CONSTANTFORCE;
72 } else if (IsEqualGUID(guid, &GUID_Square)
73 || IsEqualGUID(guid, &GUID_Sine)
74 || IsEqualGUID(guid, &GUID_Triangle)
75 || IsEqualGUID(guid, &GUID_SawtoothUp)
76 || IsEqualGUID(guid, &GUID_SawtoothDown)) {
77 return DIEFT_PERIODIC;
78 } else if (IsEqualGUID(guid, &GUID_RampForce)) {
79 return DIEFT_RAMPFORCE;
80 } else if (IsEqualGUID(guid, &GUID_Spring)
81 || IsEqualGUID(guid, &GUID_Damper)
82 || IsEqualGUID(guid, &GUID_Inertia)
83 || IsEqualGUID(guid, &GUID_Friction)) {
84 return DIEFT_CONDITION;
85 } else if (IsEqualGUID(guid, &GUID_CustomForce)) {
86 return DIEFT_CUSTOMFORCE;
87 } else {
88 WARN("GUID (%s) is not a known force type\n", _dump_dinput_GUID(guid));
89 return 0;
90 }
91 }
92
93 DWORD get_device_type(DWORD version, BOOL is_joystick)
94 {
95 if (is_joystick)
96 return version >= 0x0800 ? DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8) :
97 DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
98
99 return version >= 0x0800 ? DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEJOYSTICK_STANDARD << 8) :
100 DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_GAMEPAD << 8);
101 }
102
103 static void _dump_DIEFFECT_flags(DWORD dwFlags)
104 {
105 if (TRACE_ON(dinput)) {
106 unsigned int i;
107 static const struct {
108 DWORD mask;
109 const char *name;
110 } flags[] = {
111 #define FE(x) { x, #x}
112 FE(DIEFF_CARTESIAN),
113 FE(DIEFF_OBJECTIDS),
114 FE(DIEFF_OBJECTOFFSETS),
115 FE(DIEFF_POLAR),
116 FE(DIEFF_SPHERICAL)
117 #undef FE
118 };
119 for (i = 0; i < ARRAY_SIZE(flags); i++)
120 if (flags[i].mask & dwFlags)
121 TRACE("%s ", flags[i].name);
122 TRACE("\n");
123 }
124 }
125
126 static void _dump_DIENVELOPE(LPCDIENVELOPE env)
127 {
128 if (env->dwSize != sizeof(DIENVELOPE)) {
129 WARN("Non-standard DIENVELOPE structure size %d.\n", env->dwSize);
130 }
131 TRACE("Envelope has attack (level: %d time: %d), fade (level: %d time: %d)\n",
132 env->dwAttackLevel, env->dwAttackTime, env->dwFadeLevel, env->dwFadeTime);
133 }
134
135 static void _dump_DICONSTANTFORCE(LPCDICONSTANTFORCE frc)
136 {
137 TRACE("Constant force has magnitude %d\n", frc->lMagnitude);
138 }
139
140 static void _dump_DIPERIODIC(LPCDIPERIODIC frc)
141 {
142 TRACE("Periodic force has magnitude %d, offset %d, phase %d, period %d\n",
143 frc->dwMagnitude, frc->lOffset, frc->dwPhase, frc->dwPeriod);
144 }
145
146 static void _dump_DIRAMPFORCE(LPCDIRAMPFORCE frc)
147 {
148 TRACE("Ramp force has start %d, end %d\n",
149 frc->lStart, frc->lEnd);
150 }
151
152 static void _dump_DICONDITION(LPCDICONDITION frc)
153 {
154 TRACE("Condition has offset %d, pos/neg coefficients %d and %d, pos/neg saturations %d and %d, deadband %d\n",
155 frc->lOffset, frc->lPositiveCoefficient, frc->lNegativeCoefficient,
156 frc->dwPositiveSaturation, frc->dwNegativeSaturation, frc->lDeadBand);
157 }
158
159 static void _dump_DICUSTOMFORCE(LPCDICUSTOMFORCE frc)
160 {
161 unsigned int i;
162 TRACE("Custom force uses %d channels, sample period %d. Has %d samples at %p.\n",
163 frc->cChannels, frc->dwSamplePeriod, frc->cSamples, frc->rglForceData);
164 if (frc->cSamples % frc->cChannels != 0)
165 WARN("Custom force has a non-integral samples-per-channel count!\n");
166 if (TRACE_ON(dinput)) {
167 TRACE("Custom force data (time aligned, axes in order):\n");
168 for (i = 1; i <= frc->cSamples; ++i) {
169 TRACE("%d ", frc->rglForceData[i]);
170 if (i % frc->cChannels == 0)
171 TRACE("\n");
172 }
173 }
174 }
175
176 void dump_DIEFFECT(LPCDIEFFECT eff, REFGUID guid, DWORD dwFlags)
177 {
178 DWORD type = typeFromGUID(guid);
179 unsigned int i;
180
181 TRACE("Dumping DIEFFECT structure:\n");
182 TRACE(" - dwSize: %d\n", eff->dwSize);
183 if ((eff->dwSize != sizeof(DIEFFECT)) && (eff->dwSize != sizeof(DIEFFECT_DX5))) {
184 WARN("Non-standard DIEFFECT structure size %d\n", eff->dwSize);
185 }
186 TRACE(" - dwFlags: %d\n", eff->dwFlags);
187 TRACE(" ");
188 _dump_DIEFFECT_flags(eff->dwFlags);
189 TRACE(" - dwDuration: %d\n", eff->dwDuration);
190 TRACE(" - dwGain: %d\n", eff->dwGain);
191
192 if (eff->dwGain > 10000)
193 WARN("dwGain is out of range (>10,000)\n");
194
195 TRACE(" - dwTriggerButton: %d\n", eff->dwTriggerButton);
196 TRACE(" - dwTriggerRepeatInterval: %d\n", eff->dwTriggerRepeatInterval);
197 TRACE(" - rglDirection: %p\n", eff->rglDirection);
198 if (dwFlags & DIEP_DIRECTION && eff->rglDirection) {
199 TRACE(" ");
200 for (i = 0; i < eff->cAxes; ++i)
201 TRACE("%d ", eff->rglDirection[i]);
202 TRACE("\n");
203 }
204 TRACE(" - cbTypeSpecificParams: %d\n", eff->cbTypeSpecificParams);
205 TRACE(" - lpvTypeSpecificParams: %p\n", eff->lpvTypeSpecificParams);
206
207 /* Only trace some members if dwFlags indicates they have data */
208 if (dwFlags & DIEP_AXES) {
209 TRACE(" - cAxes: %d\n", eff->cAxes);
210 TRACE(" - rgdwAxes: %p\n", eff->rgdwAxes);
211
212 if (TRACE_ON(dinput) && eff->rgdwAxes) {
213 TRACE(" ");
214 for (i = 0; i < eff->cAxes; ++i)
215 TRACE("%d ", eff->rgdwAxes[i]);
216 TRACE("\n");
217 }
218 }
219
220 if (dwFlags & DIEP_ENVELOPE) {
221 TRACE(" - lpEnvelope: %p\n", eff->lpEnvelope);
222 if (eff->lpEnvelope != NULL)
223 _dump_DIENVELOPE(eff->lpEnvelope);
224 }
225
226 if (eff->dwSize > sizeof(DIEFFECT_DX5))
227 TRACE(" - dwStartDelay: %d\n", eff->dwStartDelay);
228
229 if (type == DIEFT_CONSTANTFORCE) {
230 if (eff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE)) {
231 WARN("Effect claims to be a constant force but the type-specific params are the wrong size!\n");
232 } else if (!eff->lpvTypeSpecificParams) {
233 WARN("Size of type-specific params is correct but pointer is NULL!\n");
234 } else {
235 _dump_DICONSTANTFORCE(eff->lpvTypeSpecificParams);
236 }
237 } else if (type == DIEFT_PERIODIC) {
238 if (eff->cbTypeSpecificParams != sizeof(DIPERIODIC)) {
239 WARN("Effect claims to be a periodic force but the type-specific params are the wrong size!\n");
240 } else if (!eff->lpvTypeSpecificParams) {
241 WARN("Size of type-specific params is correct but pointer is NULL!\n");
242 } else {
243 _dump_DIPERIODIC(eff->lpvTypeSpecificParams);
244 }
245 } else if (type == DIEFT_RAMPFORCE) {
246 if (eff->cbTypeSpecificParams != sizeof(DIRAMPFORCE)) {
247 WARN("Effect claims to be a ramp force but the type-specific params are the wrong size!\n");
248 } else if (!eff->lpvTypeSpecificParams) {
249 WARN("Size of type-specific params is correct but pointer is NULL!\n");
250 } else {
251 _dump_DIRAMPFORCE(eff->lpvTypeSpecificParams);
252 }
253 } else if (type == DIEFT_CONDITION) {
254 if (eff->cbTypeSpecificParams == sizeof(DICONDITION) && eff->lpvTypeSpecificParams) {
255 _dump_DICONDITION(eff->lpvTypeSpecificParams);
256 } else if (eff->cbTypeSpecificParams == 2 * sizeof(DICONDITION) && eff->lpvTypeSpecificParams) {
257 DICONDITION *condition = eff->lpvTypeSpecificParams;
258 _dump_DICONDITION(&condition[0]);
259 _dump_DICONDITION(&condition[1]);
260 } else {
261 WARN("Effect claims to be a condition but the type-specific params are the wrong size or NULL!\n");
262 }
263 } else if (type == DIEFT_CUSTOMFORCE) {
264 if (eff->cbTypeSpecificParams != sizeof(DICUSTOMFORCE)) {
265 WARN("Effect claims to be a custom force but the type-specific params are the wrong size!\n");
266 } else if (!eff->lpvTypeSpecificParams) {
267 WARN("Size of type-specific params is correct but pointer is NULL!\n");
268 } else {
269 _dump_DICUSTOMFORCE(eff->lpvTypeSpecificParams);
270 }
271 }
272 }
273
274 BOOL device_disabled_registry(const char* name)
275 {
276 static const char disabled_str[] = "disabled";
277 static const char joystick_key[] = "Joysticks";
278 char buffer[MAX_PATH];
279 HKEY hkey, appkey, temp;
280 BOOL do_disable = FALSE;
281
282 get_app_key(&hkey, &appkey);
283
284 /* Joystick settings are in the 'joysticks' subkey */
285 if (appkey)
286 {
287 if (RegOpenKeyA(appkey, joystick_key, &temp)) temp = 0;
288 RegCloseKey(appkey);
289 appkey = temp;
290 }
291 if (hkey)
292 {
293 if (RegOpenKeyA(hkey, joystick_key, &temp)) temp = 0;
294 RegCloseKey(hkey);
295 hkey = temp;
296 }
297
298 /* Look for the "controllername"="disabled" key */
299 if (!get_config_key(hkey, appkey, name, buffer, sizeof(buffer)))
300 if (!strcmp(disabled_str, buffer))
301 {
302 TRACE("Disabling joystick '%s' based on registry key.\n", name);
303 do_disable = TRUE;
304 }
305
306 if (appkey) RegCloseKey(appkey);
307 if (hkey) RegCloseKey(hkey);
308
309 return do_disable;
310 }
311
312 BOOL is_xinput_device(const DIDEVCAPS *devcaps, WORD vid, WORD pid)
313 {
314 int i;
315
316 if (vid == VID_MICROSOFT)
317 {
318 for (i = 0; i < ARRAY_SIZE(PID_XBOX_CONTROLLERS); i++)
319 if (pid == PID_XBOX_CONTROLLERS[i]) return TRUE;
320 }
321
322 return (devcaps->dwAxes == 6 && devcaps->dwButtons >= 14);
323 }
324
325 /******************************************************************************
326 * SetProperty : change input device properties
327 */
328 HRESULT WINAPI JoystickWGenericImpl_SetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPCDIPROPHEADER ph)
329 {
330 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
331 DWORD i;
332 ObjProps remap_props;
333
334 TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
335
336 if (ph == NULL) {
337 WARN("invalid parameter: ph == NULL\n");
338 return DIERR_INVALIDPARAM;
339 }
340
341 if (TRACE_ON(dinput))
342 _dump_DIPROPHEADER(ph);
343
344 if (IS_DIPROP(rguid)) {
345 switch (LOWORD(rguid)) {
346 case (DWORD_PTR)DIPROP_RANGE: {
347 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
348 if (ph->dwHow == DIPH_DEVICE) {
349
350 /* Many games poll the joystick immediately after setting the range
351 * for calibration purposes, so the old values need to be remapped
352 * to the new range before it does so */
353
354 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
355 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
356
357 remap_props.lDevMin = This->props[i].lMin;
358 remap_props.lDevMax = This->props[i].lMax;
359
360 remap_props.lDeadZone = This->props[i].lDeadZone;
361 remap_props.lSaturation = This->props[i].lSaturation;
362
363 remap_props.lMin = pr->lMin;
364 remap_props.lMax = pr->lMax;
365
366 switch (This->base.data_format.wine_df->rgodf[i].dwOfs) {
367 case DIJOFS_X : This->js.lX = joystick_map_axis(&remap_props, This->js.lX); break;
368 case DIJOFS_Y : This->js.lY = joystick_map_axis(&remap_props, This->js.lY); break;
369 case DIJOFS_Z : This->js.lZ = joystick_map_axis(&remap_props, This->js.lZ); break;
370 case DIJOFS_RX : This->js.lRx = joystick_map_axis(&remap_props, This->js.lRx); break;
371 case DIJOFS_RY : This->js.lRy = joystick_map_axis(&remap_props, This->js.lRy); break;
372 case DIJOFS_RZ : This->js.lRz = joystick_map_axis(&remap_props, This->js.lRz); break;
373 case DIJOFS_SLIDER(0): This->js.rglSlider[0] = joystick_map_axis(&remap_props, This->js.rglSlider[0]); break;
374 case DIJOFS_SLIDER(1): This->js.rglSlider[1] = joystick_map_axis(&remap_props, This->js.rglSlider[1]); break;
375 default: break;
376 }
377
378 This->props[i].lMin = pr->lMin;
379 This->props[i].lMax = pr->lMax;
380 }
381 } else {
382 int obj = find_property(&This->base.data_format, ph);
383
384 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
385 if (obj >= 0) {
386
387 remap_props.lDevMin = This->props[obj].lMin;
388 remap_props.lDevMax = This->props[obj].lMax;
389
390 remap_props.lDeadZone = This->props[obj].lDeadZone;
391 remap_props.lSaturation = This->props[obj].lSaturation;
392
393 remap_props.lMin = pr->lMin;
394 remap_props.lMax = pr->lMax;
395
396 switch (This->base.data_format.wine_df->rgodf[obj].dwOfs) {
397 case DIJOFS_X : This->js.lX = joystick_map_axis(&remap_props, This->js.lX); break;
398 case DIJOFS_Y : This->js.lY = joystick_map_axis(&remap_props, This->js.lY); break;
399 case DIJOFS_Z : This->js.lZ = joystick_map_axis(&remap_props, This->js.lZ); break;
400 case DIJOFS_RX : This->js.lRx = joystick_map_axis(&remap_props, This->js.lRx); break;
401 case DIJOFS_RY : This->js.lRy = joystick_map_axis(&remap_props, This->js.lRy); break;
402 case DIJOFS_RZ : This->js.lRz = joystick_map_axis(&remap_props, This->js.lRz); break;
403 case DIJOFS_SLIDER(0): This->js.rglSlider[0] = joystick_map_axis(&remap_props, This->js.rglSlider[0]); break;
404 case DIJOFS_SLIDER(1): This->js.rglSlider[1] = joystick_map_axis(&remap_props, This->js.rglSlider[1]); break;
405 default: break;
406 }
407
408 This->props[obj].lMin = pr->lMin;
409 This->props[obj].lMax = pr->lMax;
410 return DI_OK;
411 }
412 }
413 break;
414 }
415 case (DWORD_PTR)DIPROP_DEADZONE: {
416 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
417 if (ph->dwHow == DIPH_DEVICE) {
418 TRACE("deadzone(%d) all\n", pd->dwData);
419 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
420 This->props[i].lDeadZone = pd->dwData;
421 } else {
422 int obj = find_property(&This->base.data_format, ph);
423
424 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
425 if (obj >= 0) {
426 This->props[obj].lDeadZone = pd->dwData;
427 return DI_OK;
428 }
429 }
430 break;
431 }
432 case (DWORD_PTR)DIPROP_SATURATION: {
433 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
434 if (ph->dwHow == DIPH_DEVICE) {
435 TRACE("saturation(%d) all\n", pd->dwData);
436 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
437 This->props[i].lSaturation = pd->dwData;
438 } else {
439 int obj = find_property(&This->base.data_format, ph);
440
441 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
442 if (obj >= 0) {
443 This->props[obj].lSaturation = pd->dwData;
444 return DI_OK;
445 }
446 }
447 break;
448 }
449 case (DWORD_PTR)DIPROP_CALIBRATIONMODE: {
450 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
451 FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd->dwData);
452 break;
453 }
454 default:
455 return IDirectInputDevice2WImpl_SetProperty(iface, rguid, ph);
456 }
457 }
458
459 return DI_OK;
460 }
461
462 #define DEBUG_TYPE(x) case (x): str = #x; break
463 void _dump_DIDEVCAPS(const DIDEVCAPS *lpDIDevCaps)
464 {
465 int type = GET_DIDEVICE_TYPE(lpDIDevCaps->dwDevType);
466 const char *str, *hid = "";
467 TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
468 TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
469 switch(type)
470 {
471 /* Direct X <= 7 definitions */
472 DEBUG_TYPE(DIDEVTYPE_DEVICE);
473 DEBUG_TYPE(DIDEVTYPE_MOUSE);
474 DEBUG_TYPE(DIDEVTYPE_KEYBOARD);
475 DEBUG_TYPE(DIDEVTYPE_JOYSTICK);
476 /* Direct X >= 8 definitions */
477 DEBUG_TYPE(DI8DEVTYPE_DEVICE);
478 DEBUG_TYPE(DI8DEVTYPE_MOUSE);
479 DEBUG_TYPE(DI8DEVTYPE_KEYBOARD);
480 DEBUG_TYPE(DI8DEVTYPE_JOYSTICK);
481 DEBUG_TYPE(DI8DEVTYPE_GAMEPAD);
482 DEBUG_TYPE(DI8DEVTYPE_DRIVING);
483 DEBUG_TYPE(DI8DEVTYPE_FLIGHT);
484 DEBUG_TYPE(DI8DEVTYPE_1STPERSON);
485 DEBUG_TYPE(DI8DEVTYPE_DEVICECTRL);
486 DEBUG_TYPE(DI8DEVTYPE_SCREENPOINTER);
487 DEBUG_TYPE(DI8DEVTYPE_REMOTE);
488 DEBUG_TYPE(DI8DEVTYPE_SUPPLEMENTAL);
489 default: str = "UNKNOWN";
490 }
491
492 if (lpDIDevCaps->dwDevType & DIDEVTYPE_HID)
493 hid = " (HID)";
494
495 TRACE("dwDevType: %08x %s%s\n", lpDIDevCaps->dwDevType, str, hid);
496 TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
497 TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
498 TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
499 if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
500 TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
501 TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
502 TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
503 TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
504 TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
505 }
506 }
507 #undef DEBUG_TYPE
508
509 HRESULT WINAPI JoystickWGenericImpl_GetCapabilities(LPDIRECTINPUTDEVICE8W iface, LPDIDEVCAPS lpDIDevCaps)
510 {
511 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
512 int size;
513
514 TRACE("%p->(%p)\n",This,lpDIDevCaps);
515
516 if (lpDIDevCaps == NULL) {
517 WARN("invalid pointer\n");
518 return E_POINTER;
519 }
520
521 size = lpDIDevCaps->dwSize;
522
523 if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
524 WARN("invalid parameter\n");
525 return DIERR_INVALIDPARAM;
526 }
527
528 CopyMemory(lpDIDevCaps, &This->devcaps, size);
529 lpDIDevCaps->dwSize = size;
530
531 if (TRACE_ON(dinput))
532 _dump_DIDEVCAPS(lpDIDevCaps);
533
534 return DI_OK;
535 }
536
537
538 ULONG WINAPI JoystickWGenericImpl_Release(LPDIRECTINPUTDEVICE8W iface)
539 {
540 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
541 void *axis_map = This->axis_map;
542 ULONG res = IDirectInputDevice2WImpl_Release(iface);
543 if (!res) HeapFree(GetProcessHeap(), 0, axis_map);
544 return res;
545 }
546
547
548 /******************************************************************************
549 * GetObjectInfo : get object info
550 */
551 HRESULT WINAPI JoystickWGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
552 LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
553 {
554 static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
555 static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
556 static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
557 HRESULT res;
558
559 res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
560 if (res != DI_OK) return res;
561
562 if (pdidoi->dwType & DIDFT_AXIS) {
563 sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
564 pdidoi->dwFlags |= DIDOI_ASPECTPOSITION;
565 } else if (pdidoi->dwType & DIDFT_POV)
566 sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
567 else if (pdidoi->dwType & DIDFT_BUTTON)
568 sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
569
570 _dump_OBJECTINSTANCEW(pdidoi);
571 return res;
572 }
573
574 /******************************************************************************
575 * GetProperty : get input device properties
576 */
577 HRESULT WINAPI JoystickWGenericImpl_GetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPDIPROPHEADER pdiph)
578 {
579 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
580
581 TRACE("(%p,%s,%p)\n", This, debugstr_guid(rguid), pdiph);
582
583 if (TRACE_ON(dinput))
584 _dump_DIPROPHEADER(pdiph);
585
586 if (IS_DIPROP(rguid)) {
587 switch (LOWORD(rguid)) {
588 case (DWORD_PTR) DIPROP_RANGE: {
589 LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
590 int obj = find_property(&This->base.data_format, pdiph);
591
592 /* The app is querying the current range of the axis
593 * return the lMin and lMax values */
594 if (obj >= 0) {
595 pr->lMin = This->props[obj].lMin;
596 pr->lMax = This->props[obj].lMax;
597 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
598 return DI_OK;
599 }
600 break;
601 }
602 case (DWORD_PTR) DIPROP_DEADZONE: {
603 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
604 int obj = find_property(&This->base.data_format, pdiph);
605
606 if (obj >= 0) {
607 pd->dwData = This->props[obj].lDeadZone;
608 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
609 return DI_OK;
610 }
611 break;
612 }
613 case (DWORD_PTR) DIPROP_SATURATION: {
614 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
615 int obj = find_property(&This->base.data_format, pdiph);
616
617 if (obj >= 0) {
618 pd->dwData = This->props[obj].lSaturation;
619 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
620 return DI_OK;
621 }
622 break;
623 }
624 case (DWORD_PTR) DIPROP_PRODUCTNAME:
625 case (DWORD_PTR) DIPROP_INSTANCENAME: {
626 DIPROPSTRING *ps = (DIPROPSTRING*) pdiph;
627 DIDEVICEINSTANCEW didev;
628
629 didev.dwSize = sizeof(didev);
630
631 IDirectInputDevice_GetDeviceInfo(iface, &didev);
632 if (LOWORD(rguid) == (DWORD_PTR) DIPROP_PRODUCTNAME)
633 lstrcpynW(ps->wsz, didev.tszProductName, MAX_PATH);
634 else
635 lstrcpynW(ps->wsz, didev.tszInstanceName, MAX_PATH);
636
637 return DI_OK;
638 }
639 default:
640 return IDirectInputDevice2WImpl_GetProperty(iface, rguid, pdiph);
641 }
642 }
643
644 return DI_OK;
645 }
646
647 /******************************************************************************
648 * GetDeviceInfo : get information about a device's identity
649 */
650 HRESULT WINAPI JoystickWGenericImpl_GetDeviceInfo(
651 LPDIRECTINPUTDEVICE8W iface,
652 LPDIDEVICEINSTANCEW pdidi)
653 {
654 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
655 CHAR buffer[MAX_PATH];
656 DIPROPDWORD pd;
657 DWORD index = 0;
658
659 TRACE("(%p,%p)\n", iface, pdidi);
660
661 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
662 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
663 WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
664 return DIERR_INVALIDPARAM;
665 }
666
667 /* Try to get joystick index */
668 pd.diph.dwSize = sizeof(pd);
669 pd.diph.dwHeaderSize = sizeof(pd.diph);
670 pd.diph.dwObj = 0;
671 pd.diph.dwHow = DIPH_DEVICE;
672 if (SUCCEEDED(IDirectInputDevice2_GetProperty(iface, DIPROP_JOYSTICKID, &pd.diph)))
673 index = pd.dwData;
674
675 /* Return joystick */
676 pdidi->guidInstance = This->base.guid;
677 pdidi->guidProduct = This->guidProduct;
678 /* we only support traditional joysticks for now */
679 pdidi->dwDevType = This->devcaps.dwDevType;
680 snprintf(buffer, sizeof(buffer), "Joystick %d", index);
681 MultiByteToWideChar(CP_ACP, 0, buffer, -1, pdidi->tszInstanceName, MAX_PATH);
682 MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
683 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
684 pdidi->guidFFDriver = GUID_NULL;
685 pdidi->wUsagePage = 0;
686 pdidi->wUsage = 0;
687 }
688
689 return DI_OK;
690 }
691
692 HRESULT WINAPI JoystickWGenericImpl_Poll(LPDIRECTINPUTDEVICE8W iface)
693 {
694 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
695
696 TRACE("(%p)\n",This);
697
698 if (!This->base.acquired) {
699 WARN("not acquired\n");
700 return DIERR_NOTACQUIRED;
701 }
702
703 This->joy_polldev( iface );
704 return DI_OK;
705 }
706
707 /******************************************************************************
708 * GetDeviceState : returns the "state" of the joystick.
709 *
710 */
711 HRESULT WINAPI JoystickWGenericImpl_GetDeviceState(LPDIRECTINPUTDEVICE8W iface, DWORD len, LPVOID ptr)
712 {
713 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
714
715 TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
716
717 if (!This->base.acquired) {
718 WARN("not acquired\n");
719 return DIERR_NOTACQUIRED;
720 }
721
722 /* update joystick state */
723 This->joy_polldev( iface );
724
725 /* convert and copy data to user supplied buffer */
726 fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
727
728 return DI_OK;
729 }
730
731 HRESULT WINAPI JoystickWGenericImpl_BuildActionMap(LPDIRECTINPUTDEVICE8W iface,
732 LPDIACTIONFORMATW lpdiaf,
733 LPCWSTR lpszUserName,
734 DWORD dwFlags)
735 {
736 static const DWORD object_types[] = { DIDFT_AXIS, DIDFT_BUTTON };
737 static const DWORD type_map[] = { DIDFT_RELAXIS, DIDFT_PSHBUTTON };
738 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
739 unsigned int i, j;
740 BOOL has_actions = FALSE;
741
742 FIXME("(%p)->(%p,%s,%08x): semi-stub !\n", This, lpdiaf, debugstr_w(lpszUserName), dwFlags);
743
744 for (i=0; i < lpdiaf->dwNumActions; i++)
745 {
746 DWORD inst = (0x000000ff & (lpdiaf->rgoAction[i].dwSemantic)) - 1;
747 DWORD type = 0x000000ff & (lpdiaf->rgoAction[i].dwSemantic >> 8);
748 DWORD genre = 0xff000000 & lpdiaf->rgoAction[i].dwSemantic;
749
750 /* Don't touch a user configured action */
751 if (lpdiaf->rgoAction[i].dwHow == DIAH_USERCONFIG) continue;
752
753 /* Only consider actions of the right genre */
754 if (lpdiaf->dwGenre != genre && genre != DIGENRE_ANY) continue;
755
756 for (j = 0; j < ARRAY_SIZE(object_types); j++)
757 {
758 if (type & object_types[j])
759 {
760 /* Ensure that the object exists */
761 LPDIOBJECTDATAFORMAT odf = dataformat_to_odf_by_type(This->base.data_format.wine_df, inst, object_types[j]);
762
763 if (odf != NULL)
764 {
765 lpdiaf->rgoAction[i].dwObjID = type_map[j] | (0x0000ff00 & (inst << 8));
766 lpdiaf->rgoAction[i].guidInstance = This->base.guid;
767 lpdiaf->rgoAction[i].dwHow = DIAH_DEFAULT;
768
769 has_actions = TRUE;
770
771 /* No need to try other types if the action was already mapped */
772 break;
773 }
774 }
775 }
776 }
777
778 if (!has_actions) return DI_NOEFFECT;
779
780 return IDirectInputDevice8WImpl_BuildActionMap(iface, lpdiaf, lpszUserName, dwFlags);
781 }
782
783 HRESULT WINAPI JoystickWGenericImpl_SetActionMap(LPDIRECTINPUTDEVICE8W iface,
784 LPDIACTIONFORMATW lpdiaf,
785 LPCWSTR lpszUserName,
786 DWORD dwFlags)
787 {
788 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
789
790 FIXME("(%p)->(%p,%s,%08x): semi-stub !\n", This, lpdiaf, debugstr_w(lpszUserName), dwFlags);
791
792 return _set_action_map(iface, lpdiaf, lpszUserName, dwFlags, This->base.data_format.wine_df);
793 }
794
795 /*
796 * This maps the read value (from the input event) to a value in the
797 * 'wanted' range.
798 * Notes:
799 * Dead zone is in % multiplied by a 100 (range 0..10000)
800 */
801 LONG joystick_map_axis(ObjProps *props, int val)
802 {
803 LONG ret;
804 LONG dead_zone = MulDiv( props->lDeadZone, props->lDevMax - props->lDevMin, 10000 );
805 LONG dev_range = props->lDevMax - props->lDevMin - dead_zone;
806
807 /* Center input */
808 val -= (props->lDevMin + props->lDevMax) / 2;
809
810 /* Remove dead zone */
811 if (abs( val ) <= dead_zone / 2)
812 val = 0;
813 else
814 val = val < 0 ? val + dead_zone / 2 : val - dead_zone / 2;
815
816 /* Scale and map the value from the device range into the required range */
817 ret = MulDiv( val, props->lMax - props->lMin, dev_range ) +
818 (props->lMin + props->lMax) / 2;
819
820 /* Clamp in case or rounding errors */
821 if (ret > props->lMax) ret = props->lMax;
822 else if (ret < props->lMin) ret = props->lMin;
823
824 TRACE( "(%d <%d> %d) -> (%d <%d> %d): val=%d ret=%d\n",
825 props->lDevMin, dead_zone, props->lDevMax,
826 props->lMin, props->lDeadZone, props->lMax,
827 val, ret );
828
829 return ret;
830 }
831
832 /*
833 * Maps POV x & y event values to a DX "clock" position:
834 * 0
835 * 31500 4500
836 * 27000 -1 9000
837 * 22500 13500
838 * 18000
839 */
840 DWORD joystick_map_pov(const POINTL *p)
841 {
842 if (p->x > 0)
843 return p->y < 0 ? 4500 : !p->y ? 9000 : 13500;
844 else if (p->x < 0)
845 return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
846 else
847 return p->y < 0 ? 0 : !p->y ? -1 : 18000;
848 }
849
850 /*
851 * Setup the dinput options.
852 */
853
854 HRESULT setup_dinput_options(JoystickGenericImpl *This, const int *default_axis_map)
855 {
856 char buffer[MAX_PATH+16];
857 HKEY hkey, appkey;
858 int tokens = 0;
859 int axis = 0;
860 int pov = 0;
861
862 get_app_key(&hkey, &appkey);
863
864 /* get options */
865
866 if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, sizeof(buffer)))
867 {
868 This->deadzone = atoi(buffer);
869 TRACE("setting default deadzone to: \"%s\" %d\n", buffer, This->deadzone);
870 }
871
872 This->axis_map = HeapAlloc(GetProcessHeap(), 0, This->device_axis_count * sizeof(int));
873 if (!This->axis_map) return DIERR_OUTOFMEMORY;
874
875 if (!get_config_key(hkey, appkey, This->name, buffer, sizeof(buffer)))
876 {
877 static const char *axis_names[] = {"X", "Y", "Z", "Rx", "Ry", "Rz",
878 "Slider1", "Slider2",
879 "POV1", "POV2", "POV3", "POV4"};
880 const char *delim = ",";
881 char * ptr;
882 TRACE("\"%s\" = \"%s\"\n", This->name, buffer);
883
884 if ((ptr = strtok(buffer, delim)) != NULL)
885 {
886 do
887 {
888 int i;
889
890 for (i = 0; i < ARRAY_SIZE(axis_names); i++)
891 {
892 if (!strcmp(ptr, axis_names[i]))
893 {
894 if (!strncmp(ptr, "POV", 3))
895 {
896 if (pov >= 4)
897 {
898 WARN("Only 4 POVs supported - ignoring extra\n");
899 i = -1;
900 }
901 else
902 {
903 /* Pov takes two axes */
904 This->axis_map[tokens++] = i;
905 pov++;
906 }
907 }
908 else
909 {
910 if (axis >= 8)
911 {
912 FIXME("Only 8 Axes supported - ignoring extra\n");
913 i = -1;
914 }
915 else
916 axis++;
917 }
918 break;
919 }
920 }
921
922 if (i == ARRAY_SIZE(axis_names))
923 {
924 ERR("invalid joystick axis type: \"%s\"\n", ptr);
925 i = -1;
926 }
927
928 This->axis_map[tokens] = i;
929 tokens++;
930 } while ((ptr = strtok(NULL, delim)) != NULL);
931
932 if (tokens != This->device_axis_count)
933 {
934 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n",
935 This->device_axis_count, axis, pov, tokens);
936 while (tokens < This->device_axis_count)
937 {
938 This->axis_map[tokens] = -1;
939 tokens++;
940 }
941 }
942 }
943 }
944 else
945 {
946 int i;
947
948 if (default_axis_map)
949 {
950 /* Use default mapping from the driver */
951 for (i = 0; i < This->device_axis_count; i++)
952 {
953 This->axis_map[i] = default_axis_map[i];
954 tokens = default_axis_map[i];
955 if (tokens < 0)
956 continue;
957 if (tokens < 8)
958 axis++;
959 else if (tokens < 15)
960 {
961 i++;
962 pov++;
963 This->axis_map[i] = default_axis_map[i];
964 }
965 }
966 }
967 else
968 {
969 /* No config - set default mapping. */
970 for (i = 0; i < This->device_axis_count; i++)
971 {
972 if (i < 8)
973 This->axis_map[i] = axis++;
974 else if (i < 15)
975 {
976 This->axis_map[i++] = 8 + pov;
977 This->axis_map[i ] = 8 + pov++;
978 }
979 else
980 This->axis_map[i] = -1;
981 }
982 }
983 }
984 This->devcaps.dwAxes = axis;
985 This->devcaps.dwPOVs = pov;
986
987 if (appkey) RegCloseKey(appkey);
988 if (hkey) RegCloseKey(hkey);
989
990 return DI_OK;
991 }
Windows API implementation