?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Make sure __int64 is correctly defined on PPC64.
[wine.git] / dlls / dinput / joystick.c
blob2eab4d3a33da4784dd3daa8cd64c23a96229c6b4
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_IDirectInputDevice8A(IDirectInputDevice8A *iface)
64 {
65 return CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8A_iface), JoystickGenericImpl, base);
66 }
67 static inline JoystickGenericImpl *impl_from_IDirectInputDevice8W(IDirectInputDevice8W *iface)
68 {
69 return CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8W_iface), JoystickGenericImpl, base);
70 }
71 static inline IDirectInputDevice8A *IDirectInputDevice8A_from_impl(JoystickGenericImpl *This)
72 {
73 return &This->base.IDirectInputDevice8A_iface;
74 }
75 static inline IDirectInputDevice8W *IDirectInputDevice8W_from_impl(JoystickGenericImpl *This)
76 {
77 return &This->base.IDirectInputDevice8W_iface;
78 }
79
80 DWORD typeFromGUID(REFGUID guid)
81 {
82 if (IsEqualGUID(guid, &GUID_ConstantForce)) {
83 return DIEFT_CONSTANTFORCE;
84 } else if (IsEqualGUID(guid, &GUID_Square)
85 || IsEqualGUID(guid, &GUID_Sine)
86 || IsEqualGUID(guid, &GUID_Triangle)
87 || IsEqualGUID(guid, &GUID_SawtoothUp)
88 || IsEqualGUID(guid, &GUID_SawtoothDown)) {
89 return DIEFT_PERIODIC;
90 } else if (IsEqualGUID(guid, &GUID_RampForce)) {
91 return DIEFT_RAMPFORCE;
92 } else if (IsEqualGUID(guid, &GUID_Spring)
93 || IsEqualGUID(guid, &GUID_Damper)
94 || IsEqualGUID(guid, &GUID_Inertia)
95 || IsEqualGUID(guid, &GUID_Friction)) {
96 return DIEFT_CONDITION;
97 } else if (IsEqualGUID(guid, &GUID_CustomForce)) {
98 return DIEFT_CUSTOMFORCE;
99 } else {
100 WARN("GUID (%s) is not a known force type\n", _dump_dinput_GUID(guid));
101 return 0;
102 }
103 }
104
105 DWORD get_device_type(DWORD version, BOOL is_joystick)
106 {
107 if (is_joystick)
108 return version >= 0x0800 ? DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8) :
109 DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
110
111 return version >= 0x0800 ? DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEJOYSTICK_STANDARD << 8) :
112 DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_GAMEPAD << 8);
113 }
114
115 static void _dump_DIEFFECT_flags(DWORD dwFlags)
116 {
117 if (TRACE_ON(dinput)) {
118 unsigned int i;
119 static const struct {
120 DWORD mask;
121 const char *name;
122 } flags[] = {
123 #define FE(x) { x, #x}
124 FE(DIEFF_CARTESIAN),
125 FE(DIEFF_OBJECTIDS),
126 FE(DIEFF_OBJECTOFFSETS),
127 FE(DIEFF_POLAR),
128 FE(DIEFF_SPHERICAL)
129 #undef FE
130 };
131 for (i = 0; i < ARRAY_SIZE(flags); i++)
132 if (flags[i].mask & dwFlags)
133 TRACE("%s ", flags[i].name);
134 TRACE("\n");
135 }
136 }
137
138 static void _dump_DIENVELOPE(LPCDIENVELOPE env)
139 {
140 if (env->dwSize != sizeof(DIENVELOPE)) {
141 WARN("Non-standard DIENVELOPE structure size %d.\n", env->dwSize);
142 }
143 TRACE("Envelope has attack (level: %d time: %d), fade (level: %d time: %d)\n",
144 env->dwAttackLevel, env->dwAttackTime, env->dwFadeLevel, env->dwFadeTime);
145 }
146
147 static void _dump_DICONSTANTFORCE(LPCDICONSTANTFORCE frc)
148 {
149 TRACE("Constant force has magnitude %d\n", frc->lMagnitude);
150 }
151
152 static void _dump_DIPERIODIC(LPCDIPERIODIC frc)
153 {
154 TRACE("Periodic force has magnitude %d, offset %d, phase %d, period %d\n",
155 frc->dwMagnitude, frc->lOffset, frc->dwPhase, frc->dwPeriod);
156 }
157
158 static void _dump_DIRAMPFORCE(LPCDIRAMPFORCE frc)
159 {
160 TRACE("Ramp force has start %d, end %d\n",
161 frc->lStart, frc->lEnd);
162 }
163
164 static void _dump_DICONDITION(LPCDICONDITION frc)
165 {
166 TRACE("Condition has offset %d, pos/neg coefficients %d and %d, pos/neg saturations %d and %d, deadband %d\n",
167 frc->lOffset, frc->lPositiveCoefficient, frc->lNegativeCoefficient,
168 frc->dwPositiveSaturation, frc->dwNegativeSaturation, frc->lDeadBand);
169 }
170
171 static void _dump_DICUSTOMFORCE(LPCDICUSTOMFORCE frc)
172 {
173 unsigned int i;
174 TRACE("Custom force uses %d channels, sample period %d. Has %d samples at %p.\n",
175 frc->cChannels, frc->dwSamplePeriod, frc->cSamples, frc->rglForceData);
176 if (frc->cSamples % frc->cChannels != 0)
177 WARN("Custom force has a non-integral samples-per-channel count!\n");
178 if (TRACE_ON(dinput)) {
179 TRACE("Custom force data (time aligned, axes in order):\n");
180 for (i = 1; i <= frc->cSamples; ++i) {
181 TRACE("%d ", frc->rglForceData[i]);
182 if (i % frc->cChannels == 0)
183 TRACE("\n");
184 }
185 }
186 }
187
188 void dump_DIEFFECT(LPCDIEFFECT eff, REFGUID guid, DWORD dwFlags)
189 {
190 DWORD type = typeFromGUID(guid);
191 unsigned int i;
192
193 TRACE("Dumping DIEFFECT structure:\n");
194 TRACE(" - dwSize: %d\n", eff->dwSize);
195 if ((eff->dwSize != sizeof(DIEFFECT)) && (eff->dwSize != sizeof(DIEFFECT_DX5))) {
196 WARN("Non-standard DIEFFECT structure size %d\n", eff->dwSize);
197 }
198 TRACE(" - dwFlags: %d\n", eff->dwFlags);
199 TRACE(" ");
200 _dump_DIEFFECT_flags(eff->dwFlags);
201 TRACE(" - dwDuration: %d\n", eff->dwDuration);
202 TRACE(" - dwGain: %d\n", eff->dwGain);
203
204 if (eff->dwGain > 10000)
205 WARN("dwGain is out of range (>10,000)\n");
206
207 TRACE(" - dwTriggerButton: %d\n", eff->dwTriggerButton);
208 TRACE(" - dwTriggerRepeatInterval: %d\n", eff->dwTriggerRepeatInterval);
209 TRACE(" - rglDirection: %p\n", eff->rglDirection);
210 if (dwFlags & DIEP_DIRECTION && eff->rglDirection) {
211 TRACE(" ");
212 for (i = 0; i < eff->cAxes; ++i)
213 TRACE("%d ", eff->rglDirection[i]);
214 TRACE("\n");
215 }
216 TRACE(" - cbTypeSpecificParams: %d\n", eff->cbTypeSpecificParams);
217 TRACE(" - lpvTypeSpecificParams: %p\n", eff->lpvTypeSpecificParams);
218
219 /* Only trace some members if dwFlags indicates they have data */
220 if (dwFlags & DIEP_AXES) {
221 TRACE(" - cAxes: %d\n", eff->cAxes);
222 TRACE(" - rgdwAxes: %p\n", eff->rgdwAxes);
223
224 if (TRACE_ON(dinput) && eff->rgdwAxes) {
225 TRACE(" ");
226 for (i = 0; i < eff->cAxes; ++i)
227 TRACE("%d ", eff->rgdwAxes[i]);
228 TRACE("\n");
229 }
230 }
231
232 if (dwFlags & DIEP_ENVELOPE) {
233 TRACE(" - lpEnvelope: %p\n", eff->lpEnvelope);
234 if (eff->lpEnvelope != NULL)
235 _dump_DIENVELOPE(eff->lpEnvelope);
236 }
237
238 if (eff->dwSize > sizeof(DIEFFECT_DX5))
239 TRACE(" - dwStartDelay: %d\n", eff->dwStartDelay);
240
241 if (type == DIEFT_CONSTANTFORCE) {
242 if (eff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE)) {
243 WARN("Effect claims to be a constant force but the type-specific params are the wrong size!\n");
244 } else if (!eff->lpvTypeSpecificParams) {
245 WARN("Size of type-specific params is correct but pointer is NULL!\n");
246 } else {
247 _dump_DICONSTANTFORCE(eff->lpvTypeSpecificParams);
248 }
249 } else if (type == DIEFT_PERIODIC) {
250 if (eff->cbTypeSpecificParams != sizeof(DIPERIODIC)) {
251 WARN("Effect claims to be a periodic force but the type-specific params are the wrong size!\n");
252 } else if (!eff->lpvTypeSpecificParams) {
253 WARN("Size of type-specific params is correct but pointer is NULL!\n");
254 } else {
255 _dump_DIPERIODIC(eff->lpvTypeSpecificParams);
256 }
257 } else if (type == DIEFT_RAMPFORCE) {
258 if (eff->cbTypeSpecificParams != sizeof(DIRAMPFORCE)) {
259 WARN("Effect claims to be a ramp force but the type-specific params are the wrong size!\n");
260 } else if (!eff->lpvTypeSpecificParams) {
261 WARN("Size of type-specific params is correct but pointer is NULL!\n");
262 } else {
263 _dump_DIRAMPFORCE(eff->lpvTypeSpecificParams);
264 }
265 } else if (type == DIEFT_CONDITION) {
266 if (eff->cbTypeSpecificParams == sizeof(DICONDITION) && eff->lpvTypeSpecificParams) {
267 _dump_DICONDITION(eff->lpvTypeSpecificParams);
268 } else if (eff->cbTypeSpecificParams == 2 * sizeof(DICONDITION) && eff->lpvTypeSpecificParams) {
269 DICONDITION *condition = eff->lpvTypeSpecificParams;
270 _dump_DICONDITION(&condition[0]);
271 _dump_DICONDITION(&condition[1]);
272 } else {
273 WARN("Effect claims to be a condition but the type-specific params are the wrong size or NULL!\n");
274 }
275 } else if (type == DIEFT_CUSTOMFORCE) {
276 if (eff->cbTypeSpecificParams != sizeof(DICUSTOMFORCE)) {
277 WARN("Effect claims to be a custom force but the type-specific params are the wrong size!\n");
278 } else if (!eff->lpvTypeSpecificParams) {
279 WARN("Size of type-specific params is correct but pointer is NULL!\n");
280 } else {
281 _dump_DICUSTOMFORCE(eff->lpvTypeSpecificParams);
282 }
283 }
284 }
285
286 BOOL device_disabled_registry(const char* name)
287 {
288 static const char disabled_str[] = "disabled";
289 static const char joystick_key[] = "Joysticks";
290 char buffer[MAX_PATH];
291 HKEY hkey, appkey, temp;
292 BOOL do_disable = FALSE;
293
294 get_app_key(&hkey, &appkey);
295
296 /* Joystick settings are in the 'joysticks' subkey */
297 if (appkey)
298 {
299 if (RegOpenKeyA(appkey, joystick_key, &temp)) temp = 0;
300 RegCloseKey(appkey);
301 appkey = temp;
302 }
303 if (hkey)
304 {
305 if (RegOpenKeyA(hkey, joystick_key, &temp)) temp = 0;
306 RegCloseKey(hkey);
307 hkey = temp;
308 }
309
310 /* Look for the "controllername"="disabled" key */
311 if (!get_config_key(hkey, appkey, name, buffer, sizeof(buffer)))
312 if (!strcmp(disabled_str, buffer))
313 {
314 TRACE("Disabling joystick '%s' based on registry key.\n", name);
315 do_disable = TRUE;
316 }
317
318 if (appkey) RegCloseKey(appkey);
319 if (hkey) RegCloseKey(hkey);
320
321 return do_disable;
322 }
323
324 BOOL is_xinput_device(const DIDEVCAPS *devcaps, WORD vid, WORD pid)
325 {
326 int i;
327
328 if (vid == VID_MICROSOFT)
329 {
330 for (i = 0; i < ARRAY_SIZE(PID_XBOX_CONTROLLERS); i++)
331 if (pid == PID_XBOX_CONTROLLERS[i]) return TRUE;
332 }
333
334 return (devcaps->dwAxes == 6 && devcaps->dwButtons >= 14);
335 }
336
337 /******************************************************************************
338 * SetProperty : change input device properties
339 */
340 HRESULT WINAPI JoystickWGenericImpl_SetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPCDIPROPHEADER ph)
341 {
342 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
343 DWORD i;
344 ObjProps remap_props;
345
346 TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
347
348 if (ph == NULL) {
349 WARN("invalid parameter: ph == NULL\n");
350 return DIERR_INVALIDPARAM;
351 }
352
353 if (TRACE_ON(dinput))
354 _dump_DIPROPHEADER(ph);
355
356 if (IS_DIPROP(rguid)) {
357 switch (LOWORD(rguid)) {
358 case (DWORD_PTR)DIPROP_RANGE: {
359 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
360 if (ph->dwHow == DIPH_DEVICE) {
361
362 /* Many games poll the joystick immediately after setting the range
363 * for calibration purposes, so the old values need to be remapped
364 * to the new range before it does so */
365
366 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
367 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
368
369 remap_props.lDevMin = This->props[i].lMin;
370 remap_props.lDevMax = This->props[i].lMax;
371
372 remap_props.lDeadZone = This->props[i].lDeadZone;
373 remap_props.lSaturation = This->props[i].lSaturation;
374
375 remap_props.lMin = pr->lMin;
376 remap_props.lMax = pr->lMax;
377
378 switch (This->base.data_format.wine_df->rgodf[i].dwOfs) {
379 case DIJOFS_X : This->js.lX = joystick_map_axis(&remap_props, This->js.lX); break;
380 case DIJOFS_Y : This->js.lY = joystick_map_axis(&remap_props, This->js.lY); break;
381 case DIJOFS_Z : This->js.lZ = joystick_map_axis(&remap_props, This->js.lZ); break;
382 case DIJOFS_RX : This->js.lRx = joystick_map_axis(&remap_props, This->js.lRx); break;
383 case DIJOFS_RY : This->js.lRy = joystick_map_axis(&remap_props, This->js.lRy); break;
384 case DIJOFS_RZ : This->js.lRz = joystick_map_axis(&remap_props, This->js.lRz); break;
385 case DIJOFS_SLIDER(0): This->js.rglSlider[0] = joystick_map_axis(&remap_props, This->js.rglSlider[0]); break;
386 case DIJOFS_SLIDER(1): This->js.rglSlider[1] = joystick_map_axis(&remap_props, This->js.rglSlider[1]); break;
387 default: break;
388 }
389
390 This->props[i].lMin = pr->lMin;
391 This->props[i].lMax = pr->lMax;
392 }
393 } else {
394 int obj = find_property(&This->base.data_format, ph);
395
396 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
397 if (obj >= 0) {
398
399 remap_props.lDevMin = This->props[obj].lMin;
400 remap_props.lDevMax = This->props[obj].lMax;
401
402 remap_props.lDeadZone = This->props[obj].lDeadZone;
403 remap_props.lSaturation = This->props[obj].lSaturation;
404
405 remap_props.lMin = pr->lMin;
406 remap_props.lMax = pr->lMax;
407
408 switch (This->base.data_format.wine_df->rgodf[obj].dwOfs) {
409 case DIJOFS_X : This->js.lX = joystick_map_axis(&remap_props, This->js.lX); break;
410 case DIJOFS_Y : This->js.lY = joystick_map_axis(&remap_props, This->js.lY); break;
411 case DIJOFS_Z : This->js.lZ = joystick_map_axis(&remap_props, This->js.lZ); break;
412 case DIJOFS_RX : This->js.lRx = joystick_map_axis(&remap_props, This->js.lRx); break;
413 case DIJOFS_RY : This->js.lRy = joystick_map_axis(&remap_props, This->js.lRy); break;
414 case DIJOFS_RZ : This->js.lRz = joystick_map_axis(&remap_props, This->js.lRz); break;
415 case DIJOFS_SLIDER(0): This->js.rglSlider[0] = joystick_map_axis(&remap_props, This->js.rglSlider[0]); break;
416 case DIJOFS_SLIDER(1): This->js.rglSlider[1] = joystick_map_axis(&remap_props, This->js.rglSlider[1]); break;
417 default: break;
418 }
419
420 This->props[obj].lMin = pr->lMin;
421 This->props[obj].lMax = pr->lMax;
422 return DI_OK;
423 }
424 }
425 break;
426 }
427 case (DWORD_PTR)DIPROP_DEADZONE: {
428 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
429 if (ph->dwHow == DIPH_DEVICE) {
430 TRACE("deadzone(%d) all\n", pd->dwData);
431 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
432 This->props[i].lDeadZone = pd->dwData;
433 } else {
434 int obj = find_property(&This->base.data_format, ph);
435
436 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
437 if (obj >= 0) {
438 This->props[obj].lDeadZone = pd->dwData;
439 return DI_OK;
440 }
441 }
442 break;
443 }
444 case (DWORD_PTR)DIPROP_SATURATION: {
445 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
446 if (ph->dwHow == DIPH_DEVICE) {
447 TRACE("saturation(%d) all\n", pd->dwData);
448 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
449 This->props[i].lSaturation = pd->dwData;
450 } else {
451 int obj = find_property(&This->base.data_format, ph);
452
453 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
454 if (obj >= 0) {
455 This->props[obj].lSaturation = pd->dwData;
456 return DI_OK;
457 }
458 }
459 break;
460 }
461 case (DWORD_PTR)DIPROP_CALIBRATIONMODE: {
462 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
463 FIXME("DIPROP_CALIBRATIONMODE(%d)\n", pd->dwData);
464 break;
465 }
466 default:
467 return IDirectInputDevice2WImpl_SetProperty(iface, rguid, ph);
468 }
469 }
470
471 return DI_OK;
472 }
473
474 HRESULT WINAPI JoystickAGenericImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface, REFGUID rguid, LPCDIPROPHEADER ph)
475 {
476 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
477 return JoystickWGenericImpl_SetProperty(IDirectInputDevice8W_from_impl(This), rguid, ph);
478 }
479
480 #define DEBUG_TYPE(x) case (x): str = #x; break
481 void _dump_DIDEVCAPS(const DIDEVCAPS *lpDIDevCaps)
482 {
483 int type = GET_DIDEVICE_TYPE(lpDIDevCaps->dwDevType);
484 const char *str, *hid = "";
485 TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
486 TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
487 switch(type)
488 {
489 /* Direct X <= 7 definitions */
490 DEBUG_TYPE(DIDEVTYPE_DEVICE);
491 DEBUG_TYPE(DIDEVTYPE_MOUSE);
492 DEBUG_TYPE(DIDEVTYPE_KEYBOARD);
493 DEBUG_TYPE(DIDEVTYPE_JOYSTICK);
494 /* Direct X >= 8 definitions */
495 DEBUG_TYPE(DI8DEVTYPE_DEVICE);
496 DEBUG_TYPE(DI8DEVTYPE_MOUSE);
497 DEBUG_TYPE(DI8DEVTYPE_KEYBOARD);
498 DEBUG_TYPE(DI8DEVTYPE_JOYSTICK);
499 DEBUG_TYPE(DI8DEVTYPE_GAMEPAD);
500 DEBUG_TYPE(DI8DEVTYPE_DRIVING);
501 DEBUG_TYPE(DI8DEVTYPE_FLIGHT);
502 DEBUG_TYPE(DI8DEVTYPE_1STPERSON);
503 DEBUG_TYPE(DI8DEVTYPE_DEVICECTRL);
504 DEBUG_TYPE(DI8DEVTYPE_SCREENPOINTER);
505 DEBUG_TYPE(DI8DEVTYPE_REMOTE);
506 DEBUG_TYPE(DI8DEVTYPE_SUPPLEMENTAL);
507 default: str = "UNKNOWN";
508 }
509
510 if (lpDIDevCaps->dwDevType & DIDEVTYPE_HID)
511 hid = " (HID)";
512
513 TRACE("dwDevType: %08x %s%s\n", lpDIDevCaps->dwDevType, str, hid);
514 TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
515 TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
516 TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
517 if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
518 TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
519 TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
520 TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
521 TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
522 TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
523 }
524 }
525 #undef DEBUG_TYPE
526
527 HRESULT WINAPI JoystickWGenericImpl_GetCapabilities(LPDIRECTINPUTDEVICE8W iface, LPDIDEVCAPS lpDIDevCaps)
528 {
529 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
530 int size;
531
532 TRACE("%p->(%p)\n",This,lpDIDevCaps);
533
534 if (lpDIDevCaps == NULL) {
535 WARN("invalid pointer\n");
536 return E_POINTER;
537 }
538
539 size = lpDIDevCaps->dwSize;
540
541 if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
542 WARN("invalid parameter\n");
543 return DIERR_INVALIDPARAM;
544 }
545
546 CopyMemory(lpDIDevCaps, &This->devcaps, size);
547 lpDIDevCaps->dwSize = size;
548
549 if (TRACE_ON(dinput))
550 _dump_DIDEVCAPS(lpDIDevCaps);
551
552 return DI_OK;
553 }
554
555 HRESULT WINAPI JoystickAGenericImpl_GetCapabilities(LPDIRECTINPUTDEVICE8A iface, LPDIDEVCAPS lpDIDevCaps)
556 {
557 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
558 return JoystickWGenericImpl_GetCapabilities(IDirectInputDevice8W_from_impl(This), lpDIDevCaps);
559 }
560
561 /******************************************************************************
562 * GetObjectInfo : get object info
563 */
564 HRESULT WINAPI JoystickWGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
565 LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
566 {
567 static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
568 static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
569 static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
570 HRESULT res;
571
572 res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
573 if (res != DI_OK) return res;
574
575 if (pdidoi->dwType & DIDFT_AXIS) {
576 sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
577 pdidoi->dwFlags |= DIDOI_ASPECTPOSITION;
578 } else if (pdidoi->dwType & DIDFT_POV)
579 sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
580 else if (pdidoi->dwType & DIDFT_BUTTON)
581 sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
582
583 _dump_OBJECTINSTANCEW(pdidoi);
584 return res;
585 }
586
587 HRESULT WINAPI JoystickAGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
588 LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
589 {
590 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
591 HRESULT res;
592 DIDEVICEOBJECTINSTANCEW didoiW;
593 DWORD dwSize = pdidoi->dwSize;
594
595 didoiW.dwSize = sizeof(didoiW);
596 res = JoystickWGenericImpl_GetObjectInfo(IDirectInputDevice8W_from_impl(This), &didoiW, dwObj, dwHow);
597 if (res != DI_OK) return res;
598
599 memset(pdidoi, 0, pdidoi->dwSize);
600 memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
601 pdidoi->dwSize = dwSize;
602 WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
603 sizeof(pdidoi->tszName), NULL, NULL);
604
605 return res;
606 }
607
608 /******************************************************************************
609 * GetProperty : get input device properties
610 */
611 HRESULT WINAPI JoystickWGenericImpl_GetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPDIPROPHEADER pdiph)
612 {
613 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
614
615 TRACE("(%p,%s,%p)\n", This, debugstr_guid(rguid), pdiph);
616
617 if (TRACE_ON(dinput))
618 _dump_DIPROPHEADER(pdiph);
619
620 if (IS_DIPROP(rguid)) {
621 switch (LOWORD(rguid)) {
622 case (DWORD_PTR) DIPROP_RANGE: {
623 LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
624 int obj = find_property(&This->base.data_format, pdiph);
625
626 /* The app is querying the current range of the axis
627 * return the lMin and lMax values */
628 if (obj >= 0) {
629 pr->lMin = This->props[obj].lMin;
630 pr->lMax = This->props[obj].lMax;
631 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
632 return DI_OK;
633 }
634 break;
635 }
636 case (DWORD_PTR) DIPROP_DEADZONE: {
637 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
638 int obj = find_property(&This->base.data_format, pdiph);
639
640 if (obj >= 0) {
641 pd->dwData = This->props[obj].lDeadZone;
642 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
643 return DI_OK;
644 }
645 break;
646 }
647 case (DWORD_PTR) DIPROP_SATURATION: {
648 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
649 int obj = find_property(&This->base.data_format, pdiph);
650
651 if (obj >= 0) {
652 pd->dwData = This->props[obj].lSaturation;
653 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
654 return DI_OK;
655 }
656 break;
657 }
658 case (DWORD_PTR) DIPROP_PRODUCTNAME:
659 case (DWORD_PTR) DIPROP_INSTANCENAME: {
660 DIPROPSTRING *ps = (DIPROPSTRING*) pdiph;
661 DIDEVICEINSTANCEW didev;
662
663 didev.dwSize = sizeof(didev);
664
665 IDirectInputDevice_GetDeviceInfo(iface, &didev);
666 if (LOWORD(rguid) == (DWORD_PTR) DIPROP_PRODUCTNAME)
667 lstrcpynW(ps->wsz, didev.tszProductName, MAX_PATH);
668 else
669 lstrcpynW(ps->wsz, didev.tszInstanceName, MAX_PATH);
670
671 return DI_OK;
672 }
673 default:
674 return IDirectInputDevice2WImpl_GetProperty(iface, rguid, pdiph);
675 }
676 }
677
678 return DI_OK;
679 }
680
681 HRESULT WINAPI JoystickAGenericImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface, REFGUID rguid, LPDIPROPHEADER pdiph)
682 {
683 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
684 return JoystickWGenericImpl_GetProperty(IDirectInputDevice8W_from_impl(This), rguid, pdiph);
685 }
686
687 /******************************************************************************
688 * GetDeviceInfo : get information about a device's identity
689 */
690 HRESULT WINAPI JoystickAGenericImpl_GetDeviceInfo(
691 LPDIRECTINPUTDEVICE8A iface,
692 LPDIDEVICEINSTANCEA pdidi)
693 {
694 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
695 DIPROPDWORD pd;
696 DWORD index = 0;
697
698 TRACE("(%p,%p)\n", This, pdidi);
699
700 if (pdidi == NULL) {
701 WARN("invalid pointer\n");
702 return E_POINTER;
703 }
704
705 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
706 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
707 WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
708 return DIERR_INVALIDPARAM;
709 }
710
711 /* Try to get joystick index */
712 pd.diph.dwSize = sizeof(pd);
713 pd.diph.dwHeaderSize = sizeof(pd.diph);
714 pd.diph.dwObj = 0;
715 pd.diph.dwHow = DIPH_DEVICE;
716 if (SUCCEEDED(IDirectInputDevice2_GetProperty(iface, DIPROP_JOYSTICKID, &pd.diph)))
717 index = pd.dwData;
718
719 /* Return joystick */
720 pdidi->guidInstance = This->guidInstance;
721 pdidi->guidProduct = This->guidProduct;
722 /* we only support traditional joysticks for now */
723 pdidi->dwDevType = This->devcaps.dwDevType;
724 snprintf(pdidi->tszInstanceName, MAX_PATH, "Joystick %d", index);
725 lstrcpynA(pdidi->tszProductName, This->name, MAX_PATH);
726 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
727 pdidi->guidFFDriver = GUID_NULL;
728 pdidi->wUsagePage = 0;
729 pdidi->wUsage = 0;
730 }
731
732 return DI_OK;
733 }
734
735 /******************************************************************************
736 * GetDeviceInfo : get information about a device's identity
737 */
738 HRESULT WINAPI JoystickWGenericImpl_GetDeviceInfo(
739 LPDIRECTINPUTDEVICE8W iface,
740 LPDIDEVICEINSTANCEW pdidi)
741 {
742 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
743 CHAR buffer[MAX_PATH];
744 DIPROPDWORD pd;
745 DWORD index = 0;
746
747 TRACE("(%p,%p)\n", iface, pdidi);
748
749 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
750 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
751 WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
752 return DIERR_INVALIDPARAM;
753 }
754
755 /* Try to get joystick index */
756 pd.diph.dwSize = sizeof(pd);
757 pd.diph.dwHeaderSize = sizeof(pd.diph);
758 pd.diph.dwObj = 0;
759 pd.diph.dwHow = DIPH_DEVICE;
760 if (SUCCEEDED(IDirectInputDevice2_GetProperty(iface, DIPROP_JOYSTICKID, &pd.diph)))
761 index = pd.dwData;
762
763 /* Return joystick */
764 pdidi->guidInstance = This->guidInstance;
765 pdidi->guidProduct = This->guidProduct;
766 /* we only support traditional joysticks for now */
767 pdidi->dwDevType = This->devcaps.dwDevType;
768 snprintf(buffer, sizeof(buffer), "Joystick %d", index);
769 MultiByteToWideChar(CP_ACP, 0, buffer, -1, pdidi->tszInstanceName, MAX_PATH);
770 MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
771 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
772 pdidi->guidFFDriver = GUID_NULL;
773 pdidi->wUsagePage = 0;
774 pdidi->wUsage = 0;
775 }
776
777 return DI_OK;
778 }
779
780 HRESULT WINAPI JoystickWGenericImpl_Poll(LPDIRECTINPUTDEVICE8W iface)
781 {
782 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
783
784 TRACE("(%p)\n",This);
785
786 if (!This->base.acquired) {
787 WARN("not acquired\n");
788 return DIERR_NOTACQUIRED;
789 }
790
791 This->joy_polldev(IDirectInputDevice8A_from_impl(This));
792 return DI_OK;
793 }
794
795 HRESULT WINAPI JoystickAGenericImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
796 {
797 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
798 return JoystickWGenericImpl_Poll(IDirectInputDevice8W_from_impl(This));
799 }
800
801 /******************************************************************************
802 * GetDeviceState : returns the "state" of the joystick.
803 *
804 */
805 HRESULT WINAPI JoystickWGenericImpl_GetDeviceState(LPDIRECTINPUTDEVICE8W iface, DWORD len, LPVOID ptr)
806 {
807 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
808
809 TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
810
811 if (!This->base.acquired) {
812 WARN("not acquired\n");
813 return DIERR_NOTACQUIRED;
814 }
815
816 /* update joystick state */
817 This->joy_polldev(IDirectInputDevice8A_from_impl(This));
818
819 /* convert and copy data to user supplied buffer */
820 fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
821
822 return DI_OK;
823 }
824
825 HRESULT WINAPI JoystickAGenericImpl_GetDeviceState(LPDIRECTINPUTDEVICE8A iface, DWORD len, LPVOID ptr)
826 {
827 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
828 return JoystickWGenericImpl_GetDeviceState(IDirectInputDevice8W_from_impl(This), len, ptr);
829 }
830
831
832 HRESULT WINAPI JoystickWGenericImpl_BuildActionMap(LPDIRECTINPUTDEVICE8W iface,
833 LPDIACTIONFORMATW lpdiaf,
834 LPCWSTR lpszUserName,
835 DWORD dwFlags)
836 {
837 static const DWORD object_types[] = { DIDFT_AXIS, DIDFT_BUTTON };
838 static const DWORD type_map[] = { DIDFT_RELAXIS, DIDFT_PSHBUTTON };
839 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
840 unsigned int i, j;
841 BOOL has_actions = FALSE;
842
843 FIXME("(%p)->(%p,%s,%08x): semi-stub !\n", This, lpdiaf, debugstr_w(lpszUserName), dwFlags);
844
845 for (i=0; i < lpdiaf->dwNumActions; i++)
846 {
847 DWORD inst = (0x000000ff & (lpdiaf->rgoAction[i].dwSemantic)) - 1;
848 DWORD type = 0x000000ff & (lpdiaf->rgoAction[i].dwSemantic >> 8);
849 DWORD genre = 0xff000000 & lpdiaf->rgoAction[i].dwSemantic;
850
851 /* Don't touch a user configured action */
852 if (lpdiaf->rgoAction[i].dwHow == DIAH_USERCONFIG) continue;
853
854 /* Only consider actions of the right genre */
855 if (lpdiaf->dwGenre != genre && genre != DIGENRE_ANY) continue;
856
857 for (j = 0; j < ARRAY_SIZE(object_types); j++)
858 {
859 if (type & object_types[j])
860 {
861 /* Ensure that the object exists */
862 LPDIOBJECTDATAFORMAT odf = dataformat_to_odf_by_type(This->base.data_format.wine_df, inst, object_types[j]);
863
864 if (odf != NULL)
865 {
866 lpdiaf->rgoAction[i].dwObjID = type_map[j] | (0x0000ff00 & (inst << 8));
867 lpdiaf->rgoAction[i].guidInstance = This->base.guid;
868 lpdiaf->rgoAction[i].dwHow = DIAH_DEFAULT;
869
870 has_actions = TRUE;
871
872 /* No need to try other types if the action was already mapped */
873 break;
874 }
875 }
876 }
877 }
878
879 if (!has_actions) return DI_NOEFFECT;
880
881 return IDirectInputDevice8WImpl_BuildActionMap(iface, lpdiaf, lpszUserName, dwFlags);
882 }
883
884 HRESULT WINAPI JoystickAGenericImpl_BuildActionMap(LPDIRECTINPUTDEVICE8A iface,
885 LPDIACTIONFORMATA lpdiaf,
886 LPCSTR lpszUserName,
887 DWORD dwFlags)
888 {
889 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
890 DIACTIONFORMATW diafW;
891 HRESULT hr;
892 WCHAR *lpszUserNameW = NULL;
893 int username_size;
894
895 diafW.rgoAction = HeapAlloc(GetProcessHeap(), 0, sizeof(DIACTIONW)*lpdiaf->dwNumActions);
896 _copy_diactionformatAtoW(&diafW, lpdiaf);
897
898 if (lpszUserName != NULL)
899 {
900 username_size = MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, NULL, 0);
901 lpszUserNameW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*username_size);
902 MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, lpszUserNameW, username_size);
903 }
904
905 hr = JoystickWGenericImpl_BuildActionMap(&This->base.IDirectInputDevice8W_iface, &diafW, lpszUserNameW, dwFlags);
906
907 _copy_diactionformatWtoA(lpdiaf, &diafW);
908 HeapFree(GetProcessHeap(), 0, diafW.rgoAction);
909 HeapFree(GetProcessHeap(), 0, lpszUserNameW);
910
911 return hr;
912 }
913
914 HRESULT WINAPI JoystickWGenericImpl_SetActionMap(LPDIRECTINPUTDEVICE8W iface,
915 LPDIACTIONFORMATW lpdiaf,
916 LPCWSTR lpszUserName,
917 DWORD dwFlags)
918 {
919 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
920
921 FIXME("(%p)->(%p,%s,%08x): semi-stub !\n", This, lpdiaf, debugstr_w(lpszUserName), dwFlags);
922
923 return _set_action_map(iface, lpdiaf, lpszUserName, dwFlags, This->base.data_format.wine_df);
924 }
925
926 HRESULT WINAPI JoystickAGenericImpl_SetActionMap(LPDIRECTINPUTDEVICE8A iface,
927 LPDIACTIONFORMATA lpdiaf,
928 LPCSTR lpszUserName,
929 DWORD dwFlags)
930 {
931 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
932 DIACTIONFORMATW diafW;
933 HRESULT hr;
934 WCHAR *lpszUserNameW = NULL;
935 int username_size;
936
937 diafW.rgoAction = HeapAlloc(GetProcessHeap(), 0, sizeof(DIACTIONW)*lpdiaf->dwNumActions);
938 _copy_diactionformatAtoW(&diafW, lpdiaf);
939
940 if (lpszUserName != NULL)
941 {
942 username_size = MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, NULL, 0);
943 lpszUserNameW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*username_size);
944 MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, lpszUserNameW, username_size);
945 }
946
947 hr = JoystickWGenericImpl_SetActionMap(&This->base.IDirectInputDevice8W_iface, &diafW, lpszUserNameW, dwFlags);
948
949 HeapFree(GetProcessHeap(), 0, diafW.rgoAction);
950 HeapFree(GetProcessHeap(), 0, lpszUserNameW);
951
952 return hr;
953 }
954
955 /*
956 * This maps the read value (from the input event) to a value in the
957 * 'wanted' range.
958 * Notes:
959 * Dead zone is in % multiplied by a 100 (range 0..10000)
960 */
961 LONG joystick_map_axis(ObjProps *props, int val)
962 {
963 LONG ret;
964 LONG dead_zone = MulDiv( props->lDeadZone, props->lDevMax - props->lDevMin, 10000 );
965 LONG dev_range = props->lDevMax - props->lDevMin - dead_zone;
966
967 /* Center input */
968 val -= (props->lDevMin + props->lDevMax) / 2;
969
970 /* Remove dead zone */
971 if (abs( val ) <= dead_zone / 2)
972 val = 0;
973 else
974 val = val < 0 ? val + dead_zone / 2 : val - dead_zone / 2;
975
976 /* Scale and map the value from the device range into the required range */
977 ret = MulDiv( val, props->lMax - props->lMin, dev_range ) +
978 (props->lMin + props->lMax) / 2;
979
980 /* Clamp in case or rounding errors */
981 if (ret > props->lMax) ret = props->lMax;
982 else if (ret < props->lMin) ret = props->lMin;
983
984 TRACE( "(%d <%d> %d) -> (%d <%d> %d): val=%d ret=%d\n",
985 props->lDevMin, dead_zone, props->lDevMax,
986 props->lMin, props->lDeadZone, props->lMax,
987 val, ret );
988
989 return ret;
990 }
991
992 /*
993 * Maps POV x & y event values to a DX "clock" position:
994 * 0
995 * 31500 4500
996 * 27000 -1 9000
997 * 22500 13500
998 * 18000
999 */
1000 DWORD joystick_map_pov(const POINTL *p)
1001 {
1002 if (p->x > 0)
1003 return p->y < 0 ? 4500 : !p->y ? 9000 : 13500;
1004 else if (p->x < 0)
1005 return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
1006 else
1007 return p->y < 0 ? 0 : !p->y ? -1 : 18000;
1008 }
1009
1010 /*
1011 * Setup the dinput options.
1012 */
1013
1014 HRESULT setup_dinput_options(JoystickGenericImpl *This, const int *default_axis_map)
1015 {
1016 char buffer[MAX_PATH+16];
1017 HKEY hkey, appkey;
1018 int tokens = 0;
1019 int axis = 0;
1020 int pov = 0;
1021
1022 get_app_key(&hkey, &appkey);
1023
1024 /* get options */
1025
1026 if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, sizeof(buffer)))
1027 {
1028 This->deadzone = atoi(buffer);
1029 TRACE("setting default deadzone to: \"%s\" %d\n", buffer, This->deadzone);
1030 }
1031
1032 This->axis_map = HeapAlloc(GetProcessHeap(), 0, This->device_axis_count * sizeof(int));
1033 if (!This->axis_map) return DIERR_OUTOFMEMORY;
1034
1035 if (!get_config_key(hkey, appkey, This->name, buffer, sizeof(buffer)))
1036 {
1037 static const char *axis_names[] = {"X", "Y", "Z", "Rx", "Ry", "Rz",
1038 "Slider1", "Slider2",
1039 "POV1", "POV2", "POV3", "POV4"};
1040 const char *delim = ",";
1041 char * ptr;
1042 TRACE("\"%s\" = \"%s\"\n", This->name, buffer);
1043
1044 if ((ptr = strtok(buffer, delim)) != NULL)
1045 {
1046 do
1047 {
1048 int i;
1049
1050 for (i = 0; i < ARRAY_SIZE(axis_names); i++)
1051 {
1052 if (!strcmp(ptr, axis_names[i]))
1053 {
1054 if (!strncmp(ptr, "POV", 3))
1055 {
1056 if (pov >= 4)
1057 {
1058 WARN("Only 4 POVs supported - ignoring extra\n");
1059 i = -1;
1060 }
1061 else
1062 {
1063 /* Pov takes two axes */
1064 This->axis_map[tokens++] = i;
1065 pov++;
1066 }
1067 }
1068 else
1069 {
1070 if (axis >= 8)
1071 {
1072 FIXME("Only 8 Axes supported - ignoring extra\n");
1073 i = -1;
1074 }
1075 else
1076 axis++;
1077 }
1078 break;
1079 }
1080 }
1081
1082 if (i == ARRAY_SIZE(axis_names))
1083 {
1084 ERR("invalid joystick axis type: \"%s\"\n", ptr);
1085 i = -1;
1086 }
1087
1088 This->axis_map[tokens] = i;
1089 tokens++;
1090 } while ((ptr = strtok(NULL, delim)) != NULL);
1091
1092 if (tokens != This->device_axis_count)
1093 {
1094 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n",
1095 This->device_axis_count, axis, pov, tokens);
1096 while (tokens < This->device_axis_count)
1097 {
1098 This->axis_map[tokens] = -1;
1099 tokens++;
1100 }
1101 }
1102 }
1103 }
1104 else
1105 {
1106 int i;
1107
1108 if (default_axis_map)
1109 {
1110 /* Use default mapping from the driver */
1111 for (i = 0; i < This->device_axis_count; i++)
1112 {
1113 This->axis_map[i] = default_axis_map[i];
1114 tokens = default_axis_map[i];
1115 if (tokens < 0)
1116 continue;
1117 if (tokens < 8)
1118 axis++;
1119 else if (tokens < 15)
1120 {
1121 i++;
1122 pov++;
1123 This->axis_map[i] = default_axis_map[i];
1124 }
1125 }
1126 }
1127 else
1128 {
1129 /* No config - set default mapping. */
1130 for (i = 0; i < This->device_axis_count; i++)
1131 {
1132 if (i < 8)
1133 This->axis_map[i] = axis++;
1134 else if (i < 15)
1135 {
1136 This->axis_map[i++] = 8 + pov;
1137 This->axis_map[i ] = 8 + pov++;
1138 }
1139 else
1140 This->axis_map[i] = -1;
1141 }
1142 }
1143 }
1144 This->devcaps.dwAxes = axis;
1145 This->devcaps.dwPOVs = pov;
1146
1147 if (appkey) RegCloseKey(appkey);
1148 if (hkey) RegCloseKey(hkey);
1149
1150 return DI_OK;
1151 }
Windows API implementation