539334c553b200b642b24b728f83c3a9d642e95b
[reactos.git] / reactos / dll / directx / dinput / joystick.c
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 "joystick_private.h"
30 #include <wine/debug.h>
31 #include <winreg.h>
32
33 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
34
35 static inline JoystickGenericImpl *impl_from_IDirectInputDevice8A(IDirectInputDevice8A *iface)
36 {
37 return CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8A_iface), JoystickGenericImpl, base);
38 }
39 static inline JoystickGenericImpl *impl_from_IDirectInputDevice8W(IDirectInputDevice8W *iface)
40 {
41 return CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8W_iface), JoystickGenericImpl, base);
42 }
43 static inline IDirectInputDevice8A *IDirectInputDevice8A_from_impl(JoystickGenericImpl *This)
44 {
45 return &This->base.IDirectInputDevice8A_iface;
46 }
47 static inline IDirectInputDevice8W *IDirectInputDevice8W_from_impl(JoystickGenericImpl *This)
48 {
49 return &This->base.IDirectInputDevice8W_iface;
50 }
51
52 BOOL device_disabled_registry(const char* name)
53 {
54 static const char disabled_str[] = "disabled";
55 static const char joystick_key[] = "Joysticks";
56 char buffer[MAX_PATH];
57 HKEY hkey, appkey, temp;
58 BOOL do_disable = FALSE;
59
60 get_app_key(&hkey, &appkey);
61
62 /* Joystick settings are in the 'joysticks' subkey */
63 if (appkey)
64 {
65 if (RegOpenKeyA(appkey, joystick_key, &temp)) temp = 0;
66 RegCloseKey(appkey);
67 appkey = temp;
68 }
69 if (hkey)
70 {
71 if (RegOpenKeyA(hkey, joystick_key, &temp)) temp = 0;
72 RegCloseKey(hkey);
73 hkey = temp;
74 }
75
76 /* Look for the "controllername"="disabled" key */
77 if (!get_config_key(hkey, appkey, name, buffer, sizeof(buffer)))
78 if (!strcmp(disabled_str, buffer))
79 {
80 TRACE("Disabling joystick '%s' based on registry key.\n", name);
81 do_disable = TRUE;
82 }
83
84 if (appkey) RegCloseKey(appkey);
85 if (hkey) RegCloseKey(hkey);
86
87 return do_disable;
88 }
89
90 /******************************************************************************
91 * SetProperty : change input device properties
92 */
93 HRESULT WINAPI JoystickWGenericImpl_SetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPCDIPROPHEADER ph)
94 {
95 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
96 DWORD i;
97
98 TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
99
100 if (ph == NULL) {
101 WARN("invalid parameter: ph == NULL\n");
102 return DIERR_INVALIDPARAM;
103 }
104
105 if (TRACE_ON(dinput))
106 _dump_DIPROPHEADER(ph);
107
108 if (IS_DIPROP(rguid)) {
109 switch (LOWORD(rguid)) {
110 case (DWORD_PTR)DIPROP_RANGE: {
111 LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
112 if (ph->dwHow == DIPH_DEVICE) {
113 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
114 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
115 This->props[i].lMin = pr->lMin;
116 This->props[i].lMax = pr->lMax;
117 }
118 } else {
119 int obj = find_property(&This->base.data_format, ph);
120
121 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
122 if (obj >= 0) {
123 This->props[obj].lMin = pr->lMin;
124 This->props[obj].lMax = pr->lMax;
125 return DI_OK;
126 }
127 }
128 break;
129 }
130 case (DWORD_PTR)DIPROP_DEADZONE: {
131 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
132 if (ph->dwHow == DIPH_DEVICE) {
133 TRACE("deadzone(%d) all\n", pd->dwData);
134 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
135 This->props[i].lDeadZone = pd->dwData;
136 } else {
137 int obj = find_property(&This->base.data_format, ph);
138
139 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
140 if (obj >= 0) {
141 This->props[obj].lDeadZone = pd->dwData;
142 return DI_OK;
143 }
144 }
145 break;
146 }
147 case (DWORD_PTR)DIPROP_SATURATION: {
148 LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
149 if (ph->dwHow == DIPH_DEVICE) {
150 TRACE("saturation(%d) all\n", pd->dwData);
151 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
152 This->props[i].lSaturation = pd->dwData;
153 } else {
154 int obj = find_property(&This->base.data_format, ph);
155
156 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
157 if (obj >= 0) {
158 This->props[obj].lSaturation = pd->dwData;
159 return DI_OK;
160 }
161 }
162 break;
163 }
164 default:
165 return IDirectInputDevice2WImpl_SetProperty(iface, rguid, ph);
166 }
167 }
168
169 return DI_OK;
170 }
171
172 HRESULT WINAPI JoystickAGenericImpl_SetProperty(LPDIRECTINPUTDEVICE8A iface, REFGUID rguid, LPCDIPROPHEADER ph)
173 {
174 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
175 return JoystickWGenericImpl_SetProperty(IDirectInputDevice8W_from_impl(This), rguid, ph);
176 }
177
178 void _dump_DIDEVCAPS(const DIDEVCAPS *lpDIDevCaps)
179 {
180 TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
181 TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
182 TRACE("dwDevType: %08x %s\n", lpDIDevCaps->dwDevType,
183 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
184 lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
185 lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
186 lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
187 lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
188 lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
189 TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
190 TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
191 TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
192 if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
193 TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
194 TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
195 TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
196 TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
197 TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
198 }
199 }
200
201 HRESULT WINAPI JoystickWGenericImpl_GetCapabilities(LPDIRECTINPUTDEVICE8W iface, LPDIDEVCAPS lpDIDevCaps)
202 {
203 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
204 int size;
205
206 TRACE("%p->(%p)\n",iface,lpDIDevCaps);
207
208 if (lpDIDevCaps == NULL) {
209 WARN("invalid pointer\n");
210 return E_POINTER;
211 }
212
213 size = lpDIDevCaps->dwSize;
214
215 if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
216 WARN("invalid parameter\n");
217 return DIERR_INVALIDPARAM;
218 }
219
220 CopyMemory(lpDIDevCaps, &This->devcaps, size);
221 lpDIDevCaps->dwSize = size;
222
223 if (TRACE_ON(dinput))
224 _dump_DIDEVCAPS(lpDIDevCaps);
225
226 return DI_OK;
227 }
228
229 HRESULT WINAPI JoystickAGenericImpl_GetCapabilities(LPDIRECTINPUTDEVICE8A iface, LPDIDEVCAPS lpDIDevCaps)
230 {
231 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
232 return JoystickWGenericImpl_GetCapabilities(IDirectInputDevice8W_from_impl(This), lpDIDevCaps);
233 }
234
235 /******************************************************************************
236 * GetObjectInfo : get object info
237 */
238 HRESULT WINAPI JoystickWGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
239 LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
240 {
241 static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
242 static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
243 static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
244 HRESULT res;
245
246 res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
247 if (res != DI_OK) return res;
248
249 if (pdidoi->dwType & DIDFT_AXIS)
250 sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
251 else if (pdidoi->dwType & DIDFT_POV)
252 sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
253 else if (pdidoi->dwType & DIDFT_BUTTON)
254 sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
255
256 _dump_OBJECTINSTANCEW(pdidoi);
257 return res;
258 }
259
260 HRESULT WINAPI JoystickAGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
261 LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
262 {
263 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
264 HRESULT res;
265 DIDEVICEOBJECTINSTANCEW didoiW;
266 DWORD dwSize = pdidoi->dwSize;
267
268 didoiW.dwSize = sizeof(didoiW);
269 res = JoystickWGenericImpl_GetObjectInfo(IDirectInputDevice8W_from_impl(This), &didoiW, dwObj, dwHow);
270 if (res != DI_OK) return res;
271
272 memset(pdidoi, 0, pdidoi->dwSize);
273 memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
274 pdidoi->dwSize = dwSize;
275 WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
276 sizeof(pdidoi->tszName), NULL, NULL);
277
278 return res;
279 }
280
281 /******************************************************************************
282 * GetProperty : get input device properties
283 */
284 HRESULT WINAPI JoystickWGenericImpl_GetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPDIPROPHEADER pdiph)
285 {
286 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
287
288 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
289
290 if (TRACE_ON(dinput))
291 _dump_DIPROPHEADER(pdiph);
292
293 if (IS_DIPROP(rguid)) {
294 switch (LOWORD(rguid)) {
295 case (DWORD_PTR) DIPROP_RANGE: {
296 LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
297 int obj = find_property(&This->base.data_format, pdiph);
298
299 /* The app is querying the current range of the axis
300 * return the lMin and lMax values */
301 if (obj >= 0) {
302 pr->lMin = This->props[obj].lMin;
303 pr->lMax = This->props[obj].lMax;
304 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
305 return DI_OK;
306 }
307 break;
308 }
309 case (DWORD_PTR) DIPROP_DEADZONE: {
310 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
311 int obj = find_property(&This->base.data_format, pdiph);
312
313 if (obj >= 0) {
314 pd->dwData = This->props[obj].lDeadZone;
315 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
316 return DI_OK;
317 }
318 break;
319 }
320 case (DWORD_PTR) DIPROP_SATURATION: {
321 LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
322 int obj = find_property(&This->base.data_format, pdiph);
323
324 if (obj >= 0) {
325 pd->dwData = This->props[obj].lSaturation;
326 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
327 return DI_OK;
328 }
329 break;
330 }
331 case (DWORD_PTR) DIPROP_INSTANCENAME: {
332 DIPROPSTRING *ps = (DIPROPSTRING*) pdiph;
333 DIDEVICEINSTANCEW didev;
334
335 didev.dwSize = sizeof(didev);
336
337 IDirectInputDevice_GetDeviceInfo(iface, &didev);
338 lstrcpynW(ps->wsz, didev.tszInstanceName, MAX_PATH);
339
340 return DI_OK;
341 }
342 default:
343 return IDirectInputDevice2WImpl_GetProperty(iface, rguid, pdiph);
344 }
345 }
346
347 return DI_OK;
348 }
349
350 HRESULT WINAPI JoystickAGenericImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface, REFGUID rguid, LPDIPROPHEADER pdiph)
351 {
352 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
353 return JoystickWGenericImpl_GetProperty(IDirectInputDevice8W_from_impl(This), rguid, pdiph);
354 }
355
356 /******************************************************************************
357 * GetDeviceInfo : get information about a device's identity
358 */
359 HRESULT WINAPI JoystickAGenericImpl_GetDeviceInfo(
360 LPDIRECTINPUTDEVICE8A iface,
361 LPDIDEVICEINSTANCEA pdidi)
362 {
363 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
364
365 TRACE("(%p,%p)\n", iface, pdidi);
366
367 if (pdidi == NULL) {
368 WARN("invalid pointer\n");
369 return E_POINTER;
370 }
371
372 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
373 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
374 WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
375 return DIERR_INVALIDPARAM;
376 }
377
378 /* Return joystick */
379 pdidi->guidInstance = This->guidInstance;
380 pdidi->guidProduct = This->guidProduct;
381 /* we only support traditional joysticks for now */
382 pdidi->dwDevType = This->devcaps.dwDevType;
383 strcpy(pdidi->tszInstanceName, "Joystick");
384 strcpy(pdidi->tszProductName, This->name);
385 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
386 pdidi->guidFFDriver = GUID_NULL;
387 pdidi->wUsagePage = 0;
388 pdidi->wUsage = 0;
389 }
390
391 return DI_OK;
392 }
393
394 /******************************************************************************
395 * GetDeviceInfo : get information about a device's identity
396 */
397 HRESULT WINAPI JoystickWGenericImpl_GetDeviceInfo(
398 LPDIRECTINPUTDEVICE8W iface,
399 LPDIDEVICEINSTANCEW pdidi)
400 {
401 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
402
403 TRACE("(%p,%p)\n", iface, pdidi);
404
405 if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
406 (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
407 WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
408 return DIERR_INVALIDPARAM;
409 }
410
411 /* Return joystick */
412 pdidi->guidInstance = This->guidInstance;
413 pdidi->guidProduct = This->guidProduct;
414 /* we only support traditional joysticks for now */
415 pdidi->dwDevType = This->devcaps.dwDevType;
416 MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
417 MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
418 if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
419 pdidi->guidFFDriver = GUID_NULL;
420 pdidi->wUsagePage = 0;
421 pdidi->wUsage = 0;
422 }
423
424 return DI_OK;
425 }
426
427 HRESULT WINAPI JoystickWGenericImpl_Poll(LPDIRECTINPUTDEVICE8W iface)
428 {
429 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
430
431 TRACE("(%p)\n",This);
432
433 if (!This->base.acquired) {
434 WARN("not acquired\n");
435 return DIERR_NOTACQUIRED;
436 }
437
438 This->joy_polldev(IDirectInputDevice8A_from_impl(This));
439 return DI_OK;
440 }
441
442 HRESULT WINAPI JoystickAGenericImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
443 {
444 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
445 return JoystickWGenericImpl_Poll(IDirectInputDevice8W_from_impl(This));
446 }
447
448 /******************************************************************************
449 * GetDeviceState : returns the "state" of the joystick.
450 *
451 */
452 HRESULT WINAPI JoystickWGenericImpl_GetDeviceState(LPDIRECTINPUTDEVICE8W iface, DWORD len, LPVOID ptr)
453 {
454 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
455
456 TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
457
458 if (!This->base.acquired) {
459 WARN("not acquired\n");
460 return DIERR_NOTACQUIRED;
461 }
462
463 /* update joystick state */
464 This->joy_polldev(IDirectInputDevice8A_from_impl(This));
465
466 /* convert and copy data to user supplied buffer */
467 fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
468
469 return DI_OK;
470 }
471
472 HRESULT WINAPI JoystickAGenericImpl_GetDeviceState(LPDIRECTINPUTDEVICE8A iface, DWORD len, LPVOID ptr)
473 {
474 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
475 return JoystickWGenericImpl_GetDeviceState(IDirectInputDevice8W_from_impl(This), len, ptr);
476 }
477
478
479 HRESULT WINAPI JoystickWGenericImpl_BuildActionMap(LPDIRECTINPUTDEVICE8W iface,
480 LPDIACTIONFORMATW lpdiaf,
481 LPCWSTR lpszUserName,
482 DWORD dwFlags)
483 {
484 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
485 unsigned int i, j;
486 int has_actions = 0;
487 DWORD object_types[] = { DIDFT_AXIS, DIDFT_BUTTON };
488 DWORD type_map[] = { DIDFT_RELAXIS, DIDFT_PSHBUTTON };
489
490 FIXME("(%p)->(%p,%s,%08x): semi-stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
491
492 for (i=0; i < lpdiaf->dwNumActions; i++)
493 {
494 DWORD inst = (0x000000ff & (lpdiaf->rgoAction[i].dwSemantic)) - 1;
495 DWORD type = 0x000000ff & (lpdiaf->rgoAction[i].dwSemantic >> 8);
496 DWORD genre = 0xff000000 & lpdiaf->rgoAction[i].dwSemantic;
497
498 /* Don't touch an user configured action */
499 if (lpdiaf->rgoAction[i].dwHow == DIAH_USERCONFIG) continue;
500
501 /* Only consider actions of the right genre */
502 if (lpdiaf->dwGenre != genre && genre != DIGENRE_ANY) continue;
503
504 for (j=0; j < sizeof(object_types)/sizeof(object_types[0]); j++)
505 {
506 if (type & object_types[j])
507 {
508 /* Assure that the object exists */
509 LPDIOBJECTDATAFORMAT odf = dataformat_to_odf_by_type(This->base.data_format.wine_df, inst, object_types[j]);
510
511 if (odf != NULL)
512 {
513 lpdiaf->rgoAction[i].dwObjID = type_map[j] | (0x0000ff00 & (inst << 8));
514 lpdiaf->rgoAction[i].guidInstance = This->base.guid;
515 lpdiaf->rgoAction[i].dwHow = DIAH_DEFAULT;
516
517 has_actions = 1;
518
519 /* No need to try other types if the action was already mapped */
520 break;
521 }
522 }
523 }
524 }
525
526 if (!has_actions) return DI_NOEFFECT;
527
528 return IDirectInputDevice8WImpl_BuildActionMap(iface, lpdiaf, lpszUserName, dwFlags);
529 }
530
531 HRESULT WINAPI JoystickAGenericImpl_BuildActionMap(LPDIRECTINPUTDEVICE8A iface,
532 LPDIACTIONFORMATA lpdiaf,
533 LPCSTR lpszUserName,
534 DWORD dwFlags)
535 {
536 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
537 DIACTIONFORMATW diafW;
538 HRESULT hr;
539 WCHAR *lpszUserNameW = NULL;
540 int username_size;
541
542 diafW.rgoAction = HeapAlloc(GetProcessHeap(), 0, sizeof(DIACTIONW)*lpdiaf->dwNumActions);
543 _copy_diactionformatAtoW(&diafW, lpdiaf);
544
545 if (lpszUserName != NULL)
546 {
547 username_size = MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, NULL, 0);
548 lpszUserNameW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*username_size);
549 MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, lpszUserNameW, username_size);
550 }
551
552 hr = JoystickWGenericImpl_BuildActionMap(&This->base.IDirectInputDevice8W_iface, &diafW, lpszUserNameW, dwFlags);
553
554 _copy_diactionformatWtoA(lpdiaf, &diafW);
555 HeapFree(GetProcessHeap(), 0, diafW.rgoAction);
556 HeapFree(GetProcessHeap(), 0, lpszUserNameW);
557
558 return hr;
559 }
560
561 HRESULT WINAPI JoystickWGenericImpl_SetActionMap(LPDIRECTINPUTDEVICE8W iface,
562 LPDIACTIONFORMATW lpdiaf,
563 LPCWSTR lpszUserName,
564 DWORD dwFlags)
565 {
566 JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
567
568 FIXME("(%p)->(%p,%s,%08x): semi-stub !\n", iface, lpdiaf, debugstr_w(lpszUserName), dwFlags);
569
570 return _set_action_map(iface, lpdiaf, lpszUserName, dwFlags, This->base.data_format.wine_df);
571 }
572
573 HRESULT WINAPI JoystickAGenericImpl_SetActionMap(LPDIRECTINPUTDEVICE8A iface,
574 LPDIACTIONFORMATA lpdiaf,
575 LPCSTR lpszUserName,
576 DWORD dwFlags)
577 {
578 JoystickGenericImpl *This = impl_from_IDirectInputDevice8A(iface);
579 DIACTIONFORMATW diafW;
580 HRESULT hr;
581 WCHAR *lpszUserNameW = NULL;
582 int username_size;
583
584 diafW.rgoAction = HeapAlloc(GetProcessHeap(), 0, sizeof(DIACTIONW)*lpdiaf->dwNumActions);
585 _copy_diactionformatAtoW(&diafW, lpdiaf);
586
587 if (lpszUserName != NULL)
588 {
589 username_size = MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, NULL, 0);
590 lpszUserNameW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*username_size);
591 MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, lpszUserNameW, username_size);
592 }
593
594 hr = JoystickWGenericImpl_SetActionMap(&This->base.IDirectInputDevice8W_iface, &diafW, lpszUserNameW, dwFlags);
595
596 HeapFree(GetProcessHeap(), 0, diafW.rgoAction);
597 HeapFree(GetProcessHeap(), 0, lpszUserNameW);
598
599 return hr;
600 }
601
602 /*
603 * This maps the read value (from the input event) to a value in the
604 * 'wanted' range.
605 * Notes:
606 * Dead zone is in % multiplied by a 100 (range 0..10000)
607 */
608 LONG joystick_map_axis(ObjProps *props, int val)
609 {
610 LONG ret;
611 LONG dead_zone = MulDiv( props->lDeadZone, props->lDevMax - props->lDevMin, 10000 );
612 LONG dev_range = props->lDevMax - props->lDevMin - dead_zone;
613
614 /* Center input */
615 val -= (props->lDevMin + props->lDevMax) / 2;
616
617 /* Remove dead zone */
618 if (abs( val ) <= dead_zone / 2)
619 val = 0;
620 else
621 val = val < 0 ? val + dead_zone / 2 : val - dead_zone / 2;
622
623 /* Scale and map the value from the device range into the required range */
624 ret = MulDiv( val, props->lMax - props->lMin, dev_range ) +
625 (props->lMin + props->lMax) / 2;
626
627 /* Clamp in case or rounding errors */
628 if (ret > props->lMax) ret = props->lMax;
629 else if (ret < props->lMin) ret = props->lMin;
630
631 TRACE( "(%d <%d> %d) -> (%d <%d> %d): val=%d ret=%d\n",
632 props->lDevMin, dead_zone, props->lDevMax,
633 props->lMin, props->lDeadZone, props->lMax,
634 val, ret );
635
636 return ret;
637 }
638
639 /*
640 * Maps POV x & y event values to a DX "clock" position:
641 * 0
642 * 31500 4500
643 * 27000 -1 9000
644 * 22500 13500
645 * 18000
646 */
647 DWORD joystick_map_pov(const POINTL *p)
648 {
649 if (p->x > 0)
650 return p->y < 0 ? 4500 : !p->y ? 9000 : 13500;
651 else if (p->x < 0)
652 return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
653 else
654 return p->y < 0 ? 0 : !p->y ? -1 : 18000;
655 }
656
657 /*
658 * Setup the dinput options.
659 */
660
661 HRESULT setup_dinput_options(JoystickGenericImpl *This, const int *default_axis_map)
662 {
663 char buffer[MAX_PATH+16];
664 HKEY hkey, appkey;
665 int tokens = 0;
666 int axis = 0;
667 int pov = 0;
668
669 get_app_key(&hkey, &appkey);
670
671 /* get options */
672
673 if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, sizeof(buffer)))
674 {
675 This->deadzone = atoi(buffer);
676 TRACE("setting default deadzone to: \"%s\" %d\n", buffer, This->deadzone);
677 }
678
679 This->axis_map = HeapAlloc(GetProcessHeap(), 0, This->device_axis_count * sizeof(int));
680 if (!This->axis_map) return DIERR_OUTOFMEMORY;
681
682 if (!get_config_key(hkey, appkey, This->name, buffer, sizeof(buffer)))
683 {
684 static const char *axis_names[] = {"X", "Y", "Z", "Rx", "Ry", "Rz",
685 "Slider1", "Slider2",
686 "POV1", "POV2", "POV3", "POV4"};
687 const char *delim = ",";
688 char * ptr;
689 TRACE("\"%s\" = \"%s\"\n", This->name, buffer);
690
691 if ((ptr = strtok(buffer, delim)) != NULL)
692 {
693 do
694 {
695 int i;
696
697 for (i = 0; i < sizeof(axis_names) / sizeof(axis_names[0]); i++)
698 {
699 if (!strcmp(ptr, axis_names[i]))
700 {
701 if (!strncmp(ptr, "POV", 3))
702 {
703 if (pov >= 4)
704 {
705 WARN("Only 4 POVs supported - ignoring extra\n");
706 i = -1;
707 }
708 else
709 {
710 /* Pov takes two axes */
711 This->axis_map[tokens++] = i;
712 pov++;
713 }
714 }
715 else
716 {
717 if (axis >= 8)
718 {
719 FIXME("Only 8 Axes supported - ignoring extra\n");
720 i = -1;
721 }
722 else
723 axis++;
724 }
725 break;
726 }
727 }
728
729 if (i == sizeof(axis_names) / sizeof(axis_names[0]))
730 {
731 ERR("invalid joystick axis type: \"%s\"\n", ptr);
732 i = -1;
733 }
734
735 This->axis_map[tokens] = i;
736 tokens++;
737 } while ((ptr = strtok(NULL, delim)) != NULL);
738
739 if (tokens != This->device_axis_count)
740 {
741 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n",
742 This->device_axis_count, axis, pov, tokens);
743 while (tokens < This->device_axis_count)
744 {
745 This->axis_map[tokens] = -1;
746 tokens++;
747 }
748 }
749 }
750 }
751 else
752 {
753 int i;
754
755 if (default_axis_map)
756 {
757 /* Use default mapping from the driver */
758 for (i = 0; i < This->device_axis_count; i++)
759 {
760 This->axis_map[i] = default_axis_map[i];
761 tokens = default_axis_map[i];
762 if (tokens < 0)
763 continue;
764 if (tokens < 8)
765 axis++;
766 else if (tokens < 15)
767 {
768 i++;
769 pov++;
770 This->axis_map[i] = default_axis_map[i];
771 }
772 }
773 }
774 else
775 {
776 /* No config - set default mapping. */
777 for (i = 0; i < This->device_axis_count; i++)
778 {
779 if (i < 8)
780 This->axis_map[i] = axis++;
781 else if (i < 15)
782 {
783 This->axis_map[i++] = 8 + pov;
784 This->axis_map[i ] = 8 + pov++;
785 }
786 else
787 This->axis_map[i] = -1;
788 }
789 }
790 }
791 This->devcaps.dwAxes = axis;
792 This->devcaps.dwPOVs = pov;
793
794 if (appkey) RegCloseKey(appkey);
795 if (hkey) RegCloseKey(hkey);
796
797 return DI_OK;
798 }