1 /* DirectInput Joystick device for Mac OS/X
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998,1999 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2009 CodeWeavers, Aric Stewart
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 #include "config.h"
24 #include "wine/port.h"
25
26 #if defined(HAVE_CARBON_CARBON_H) && defined(HAVE_IOKIT_HID_IOHIDLIB_H)
27 #define LoadResource __carbon_LoadResource
28 #define CompareString __carbon_CompareString
29 #define GetCurrentThread __carbon_GetCurrentThread
30 #define GetCurrentProcess __carbon_GetCurrentProcess
31 #define AnimatePalette __carbon_AnimatePalette
32 #define EqualRgn __carbon_EqualRgn
33 #define FillRgn __carbon_FillRgn
34 #define FrameRgn __carbon_FrameRgn
35 #define GetPixel __carbon_GetPixel
36 #define InvertRgn __carbon_InvertRgn
37 #define LineTo __carbon_LineTo
38 #define OffsetRgn __carbon_OffsetRgn
39 #define PaintRgn __carbon_PaintRgn
40 #define Polygon __carbon_Polygon
41 #define ResizePalette __carbon_ResizePalette
42 #define SetRectRgn __carbon_SetRectRgn
43 #define ULONG __carbon_ULONG
44 #define E_INVALIDARG __carbon_E_INVALIDARG
45 #define E_OUTOFMEMORY __carbon_E_OUTOFMEMORY
46 #define E_HANDLE __carbon_E_HANDLE
47 #define E_ACCESSDENIED __carbon_E_ACCESSDENIED
48 #define E_UNEXPECTED __carbon_E_UNEXPECTED
49 #define E_FAIL __carbon_E_FAIL
50 #define E_ABORT __carbon_E_ABORT
51 #define E_POINTER __carbon_E_POINTER
52 #define E_NOINTERFACE __carbon_E_NOINTERFACE
53 #define E_NOTIMPL __carbon_E_NOTIMPL
54 #define S_FALSE __carbon_S_FALSE
55 #define S_OK __carbon_S_OK
56 #define HRESULT_FACILITY __carbon_HRESULT_FACILITY
57 #define IS_ERROR __carbon_IS_ERROR
58 #define FAILED __carbon_FAILED
59 #define SUCCEEDED __carbon_SUCCEEDED
60 #define MAKE_HRESULT __carbon_MAKE_HRESULT
61 #define HRESULT __carbon_HRESULT
62 #define STDMETHODCALLTYPE __carbon_STDMETHODCALLTYPE
63 #include <Carbon/Carbon.h>
64 #include <IOKit/hid/IOHIDLib.h>
65 #undef LoadResource
66 #undef CompareString
67 #undef GetCurrentThread
68 #undef _CDECL
69 #undef DPRINTF
70 #undef GetCurrentProcess
71 #undef AnimatePalette
72 #undef EqualRgn
73 #undef FillRgn
74 #undef FrameRgn
75 #undef GetPixel
76 #undef InvertRgn
77 #undef LineTo
78 #undef OffsetRgn
79 #undef PaintRgn
80 #undef Polygon
81 #undef ResizePalette
82 #undef SetRectRgn
83 #undef ULONG
84 #undef E_INVALIDARG
85 #undef E_OUTOFMEMORY
86 #undef E_HANDLE
87 #undef E_ACCESSDENIED
88 #undef E_UNEXPECTED
89 #undef E_FAIL
90 #undef E_ABORT
91 #undef E_POINTER
92 #undef E_NOINTERFACE
93 #undef E_NOTIMPL
94 #undef S_FALSE
95 #undef S_OK
96 #undef HRESULT_FACILITY
97 #undef IS_ERROR
98 #undef FAILED
99 #undef SUCCEEDED
100 #undef MAKE_HRESULT
101 #undef HRESULT
102 #undef STDMETHODCALLTYPE
103 #endif /* HAVE_CARBON_CARBON_H */
104
105 #include "wine/debug.h"
106 #include "wine/unicode.h"
107 #include "windef.h"
108 #include "winbase.h"
109 #include "winerror.h"
110 #include "winreg.h"
111 #include "dinput.h"
112
113 #include "dinput_private.h"
114 #include "device_private.h"
115 #include "joystick_private.h"
116
117 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
118
119 #ifdef HAVE_IOHIDMANAGERCREATE
120
121 static IOHIDManagerRef gIOHIDManagerRef = NULL;
122 static CFArrayRef gCollections = NULL;
123
124 typedef struct JoystickImpl JoystickImpl;
125 static const IDirectInputDevice8AVtbl JoystickAvt;
126 static const IDirectInputDevice8WVtbl JoystickWvt;
127
128 struct JoystickImpl
129 {
130 struct JoystickGenericImpl generic;
131
132 /* osx private */
133 int id;
134 CFMutableArrayRef elementCFArrayRef;
135 ObjProps **propmap;
136 };
137
138 static const GUID DInput_Wine_OsX_Joystick_GUID = { /* 59CAD8F6-E617-41E2-8EB7-47B23EEEDC5A */
139 0x59CAD8F6, 0xE617, 0x41E2, {0x8E, 0xB7, 0x47, 0xB2, 0x3E, 0xEE, 0xDC, 0x5A}
140 };
141
142 static void CFSetApplierFunctionCopyToCFArray(const void *value, void *context)
143 {
144 CFArrayAppendValue( ( CFMutableArrayRef ) context, value );
145 }
146
147 static CFMutableDictionaryRef creates_osx_device_match(int usage)
148 {
149 CFMutableDictionaryRef result;
150
151 result = CFDictionaryCreateMutable( kCFAllocatorDefault, 0,
152 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
153
154 if ( result )
155 {
156 int number = kHIDPage_GenericDesktop;
157 CFNumberRef pageCFNumberRef = CFNumberCreate( kCFAllocatorDefault,
158 kCFNumberIntType, &number);
159
160 if ( pageCFNumberRef )
161 {
162 CFNumberRef usageCFNumberRef;
163
164 CFDictionarySetValue( result, CFSTR( kIOHIDDeviceUsagePageKey ),
165 pageCFNumberRef );
166 CFRelease( pageCFNumberRef );
167
168 usageCFNumberRef = CFNumberCreate( kCFAllocatorDefault,
169 kCFNumberIntType, &usage);
170 if ( usageCFNumberRef )
171 {
172 CFDictionarySetValue( result, CFSTR( kIOHIDDeviceUsageKey ),
173 usageCFNumberRef );
174 CFRelease( usageCFNumberRef );
175 }
176 else
177 {
178 ERR("CFNumberCreate() failed.\n");
179 return NULL;
180 }
181 }
182 else
183 {
184 ERR("CFNumberCreate failed.\n");
185 return NULL;
186 }
187 }
188 else
189 {
190 ERR("CFDictionaryCreateMutable failed.\n");
191 return NULL;
192 }
193
194 return result;
195 }
196
197 static CFIndex find_top_level(IOHIDDeviceRef tIOHIDDeviceRef, CFArrayRef topLevels)
198 {
199 CFArrayRef gElementCFArrayRef;
200 CFIndex numTops = 0;
201
202 if (!tIOHIDDeviceRef)
203 return 0;
204
205 gElementCFArrayRef = IOHIDDeviceCopyMatchingElements(tIOHIDDeviceRef, NULL, 0);
206
207 if (gElementCFArrayRef)
208 {
209 CFIndex idx, cnt = CFArrayGetCount(gElementCFArrayRef);
210 for (idx=0; idx<cnt; idx++)
211 {
212 IOHIDElementRef tIOHIDElementRef = (IOHIDElementRef)CFArrayGetValueAtIndex(gElementCFArrayRef, idx);
213 int eleType = IOHIDElementGetType(tIOHIDElementRef);
214
215 /* Check for top-level gaming device collections */
216 if (eleType == kIOHIDElementTypeCollection && IOHIDElementGetParent(tIOHIDElementRef) == 0)
217 {
218 int tUsagePage = IOHIDElementGetUsagePage(tIOHIDElementRef);
219 int tUsage = IOHIDElementGetUsage(tIOHIDElementRef);
220
221 if (tUsagePage == kHIDPage_GenericDesktop &&
222 (tUsage == kHIDUsage_GD_Joystick || tUsage == kHIDUsage_GD_GamePad))
223 {
224 CFArrayAppendValue((CFMutableArrayRef)topLevels, tIOHIDElementRef);
225 numTops++;
226 }
227 }
228 }
229 }
230 return numTops;
231 }
232
233 static void get_element_children(IOHIDElementRef tElement, CFArrayRef childElements)
234 {
235 CFIndex idx, cnt;
236 CFArrayRef tElementChildrenArray = IOHIDElementGetChildren(tElement);
237
238 cnt = CFArrayGetCount(tElementChildrenArray);
239 if (cnt < 1)
240 return;
241
242 /* Either add the element to the array or grab its children */
243 for (idx=0; idx<cnt; idx++)
244 {
245 IOHIDElementRef tChildElementRef;
246
247 tChildElementRef = (IOHIDElementRef)CFArrayGetValueAtIndex(tElementChildrenArray, idx);
248 if (IOHIDElementGetType(tChildElementRef) == kIOHIDElementTypeCollection)
249 get_element_children(tChildElementRef, childElements);
250 else
251 CFArrayAppendValue((CFMutableArrayRef)childElements, tChildElementRef);
252 }
253 }
254
255 static int find_osx_devices(void)
256 {
257 IOReturn tIOReturn;
258 CFMutableDictionaryRef result;
259 CFSetRef devset;
260 CFArrayRef matching;
261
262 gIOHIDManagerRef = IOHIDManagerCreate( kCFAllocatorDefault, 0L );
263 tIOReturn = IOHIDManagerOpen( gIOHIDManagerRef, 0L);
264 if ( kIOReturnSuccess != tIOReturn )
265 {
266 ERR("Couldn't open IOHIDManager.\n");
267 return 0;
268 }
269
270 matching = CFArrayCreateMutable( kCFAllocatorDefault, 0,
271 &kCFTypeArrayCallBacks );
272
273 /* build matching dictionary */
274 result = creates_osx_device_match(kHIDUsage_GD_Joystick);
275 if (!result)
276 {
277 CFRelease(matching);
278 return 0;
279 }
280 CFArrayAppendValue( ( CFMutableArrayRef )matching, result );
281 result = creates_osx_device_match(kHIDUsage_GD_GamePad);
282 if (!result)
283 {
284 CFRelease(matching);
285 return 0;
286 }
287 CFArrayAppendValue( ( CFMutableArrayRef )matching, result );
288
289 IOHIDManagerSetDeviceMatchingMultiple( gIOHIDManagerRef, matching);
290 devset = IOHIDManagerCopyDevices( gIOHIDManagerRef );
291 if (devset)
292 {
293 CFIndex countDevices, countCollections, idx;
294 CFArrayRef gDevices = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
295 CFSetApplyFunction(devset, CFSetApplierFunctionCopyToCFArray, (void*)gDevices);
296 CFRelease( devset);
297 countDevices = CFArrayGetCount(gDevices);
298
299 gCollections = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
300 if (!gCollections)
301 return 0;
302
303 countCollections = 0;
304 for (idx = 0; idx < countDevices; idx++)
305 {
306 CFIndex tTop;
307 IOHIDDeviceRef tDevice;
308
309 tDevice = (IOHIDDeviceRef) CFArrayGetValueAtIndex(gDevices, idx);
310 tTop = find_top_level(tDevice, gCollections);
311 countCollections += tTop;
312 }
313
314 CFRelease(gDevices);
315
316 TRACE("found %i device(s), %i collection(s)\n",(int)countDevices,(int)countCollections);
317 return (int)countCollections;
318 }
319 return 0;
320 }
321
322 static int get_osx_device_name(int id, char *name, int length)
323 {
324 CFStringRef str;
325 IOHIDElementRef tIOHIDElementRef;
326 IOHIDDeviceRef tIOHIDDeviceRef;
327
328 if (!gCollections)
329 return 0;
330
331 tIOHIDElementRef = (IOHIDElementRef)CFArrayGetValueAtIndex(gCollections, id);
332
333 if (!tIOHIDElementRef)
334 {
335 ERR("Invalid Element requested %i\n",id);
336 return 0;
337 }
338
339 tIOHIDDeviceRef = IOHIDElementGetDevice(tIOHIDElementRef);
340
341 if (name)
342 name[0] = 0;
343
344 if (!tIOHIDDeviceRef)
345 {
346 ERR("Invalid Device requested %i\n",id);
347 return 0;
348 }
349
350 str = IOHIDDeviceGetProperty(tIOHIDDeviceRef, CFSTR( kIOHIDProductKey ));
351 if (str)
352 {
353 CFIndex len = CFStringGetLength(str);
354 if (length >= len)
355 {
356 CFStringGetCString(str,name,length,kCFStringEncodingASCII);
357 return len;
358 }
359 else
360 return (len+1);
361 }
362 return 0;
363 }
364
365 static void insert_sort_button(int header, IOHIDElementRef tIOHIDElementRef,
366 CFMutableArrayRef elementCFArrayRef, int index,
367 int target)
368 {
369 IOHIDElementRef targetElement;
370 int usage;
371
372 CFArraySetValueAtIndex(elementCFArrayRef, header+index, NULL);
373 targetElement = ( IOHIDElementRef ) CFArrayGetValueAtIndex( elementCFArrayRef, header+target);
374 if (targetElement == NULL)
375 {
376 CFArraySetValueAtIndex(elementCFArrayRef, header+target,tIOHIDElementRef);
377 return;
378 }
379 usage = IOHIDElementGetUsage( targetElement );
380 usage --; /* usage 1 based index */
381
382 insert_sort_button(header, targetElement, elementCFArrayRef, target, usage);
383 CFArraySetValueAtIndex(elementCFArrayRef, header+target,tIOHIDElementRef);
384 }
385
386 static void get_osx_device_elements(JoystickImpl *device, int axis_map[8])
387 {
388 IOHIDElementRef tIOHIDElementRef;
389 CFArrayRef gElementCFArrayRef;
390 DWORD axes = 0;
391 DWORD sliders = 0;
392 DWORD buttons = 0;
393 DWORD povs = 0;
394
395 device->elementCFArrayRef = NULL;
396
397 if (!gCollections)
398 return;
399
400 tIOHIDElementRef = (IOHIDElementRef)CFArrayGetValueAtIndex(gCollections, device->id);
401
402 if (!tIOHIDElementRef)
403 return;
404
405 gElementCFArrayRef = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
406 get_element_children(tIOHIDElementRef, gElementCFArrayRef);
407
408 if (gElementCFArrayRef)
409 {
410 CFIndex idx, cnt = CFArrayGetCount( gElementCFArrayRef );
411 /* build our element array in the order that dinput expects */
412 device->elementCFArrayRef = CFArrayCreateMutable(NULL,0,NULL);
413
414 for ( idx = 0; idx < cnt; idx++ )
415 {
416 IOHIDElementRef tIOHIDElementRef = ( IOHIDElementRef ) CFArrayGetValueAtIndex( gElementCFArrayRef, idx );
417 int eleType = IOHIDElementGetType( tIOHIDElementRef );
418 switch(eleType)
419 {
420 case kIOHIDElementTypeInput_Button:
421 {
422 int usagePage = IOHIDElementGetUsagePage( tIOHIDElementRef );
423 if (usagePage != kHIDPage_Button)
424 {
425 /* avoid strange elements found on the 360 controler */
426 continue;
427 }
428
429 if (buttons < 128)
430 {
431 CFArrayInsertValueAtIndex(device->elementCFArrayRef, (axes+povs+buttons), tIOHIDElementRef);
432 buttons++;
433 }
434 break;
435 }
436 case kIOHIDElementTypeInput_Axis:
437 {
438 CFArrayInsertValueAtIndex(device->elementCFArrayRef, axes, tIOHIDElementRef);
439 axes++;
440 break;
441 }
442 case kIOHIDElementTypeInput_Misc:
443 {
444 uint32_t usage = IOHIDElementGetUsage( tIOHIDElementRef );
445 switch(usage)
446 {
447 case kHIDUsage_GD_Hatswitch:
448 {
449 CFArrayInsertValueAtIndex(device->elementCFArrayRef, (axes+povs), tIOHIDElementRef);
450 povs++;
451 break;
452 }
453 case kHIDUsage_GD_Slider:
454 sliders ++;
455 if (sliders > 2)
456 break;
457 /* fallthrough, sliders are axis */
458 case kHIDUsage_GD_X:
459 case kHIDUsage_GD_Y:
460 case kHIDUsage_GD_Z:
461 case kHIDUsage_GD_Rx:
462 case kHIDUsage_GD_Ry:
463 case kHIDUsage_GD_Rz:
464 {
465 CFArrayInsertValueAtIndex(device->elementCFArrayRef, axes, tIOHIDElementRef);
466 axis_map[axes]=usage;
467 axes++;
468 break;
469 }
470 default:
471 FIXME("Unhandled usage %i\n",usage);
472 }
473 break;
474 }
475 default:
476 FIXME("Unhandled type %i\n",eleType);
477 }
478 }
479 }
480
481 device->generic.devcaps.dwAxes = axes;
482 device->generic.devcaps.dwButtons = buttons;
483 device->generic.devcaps.dwPOVs = povs;
484
485 /* Sort buttons into correct order */
486 for (buttons = 0; buttons < device->generic.devcaps.dwButtons; buttons++)
487 {
488 IOHIDElementRef tIOHIDElementRef = ( IOHIDElementRef ) CFArrayGetValueAtIndex( device->elementCFArrayRef, axes+povs+buttons);
489 uint32_t usage = IOHIDElementGetUsage( tIOHIDElementRef );
490 usage --; /* usage is 1 indexed we need 0 indexed */
491 if (usage == buttons)
492 continue;
493
494 insert_sort_button(axes+povs, tIOHIDElementRef, device->elementCFArrayRef,buttons,usage);
495 }
496 }
497
498 static void get_osx_device_elements_props(JoystickImpl *device)
499 {
500 CFArrayRef gElementCFArrayRef = device->elementCFArrayRef;
501
502 if (gElementCFArrayRef)
503 {
504 CFIndex idx, cnt = CFArrayGetCount( gElementCFArrayRef );
505
506 for ( idx = 0; idx < cnt; idx++ )
507 {
508 IOHIDElementRef tIOHIDElementRef = ( IOHIDElementRef ) CFArrayGetValueAtIndex( gElementCFArrayRef, idx );
509
510 device->generic.props[idx].lDevMin = IOHIDElementGetLogicalMin(tIOHIDElementRef);
511 device->generic.props[idx].lDevMax = IOHIDElementGetLogicalMax(tIOHIDElementRef);
512 device->generic.props[idx].lMin = 0;
513 device->generic.props[idx].lMax = 0xffff;
514 device->generic.props[idx].lDeadZone = 0;
515 device->generic.props[idx].lSaturation = 0;
516 }
517 }
518 }
519
520 static void poll_osx_device_state(JoystickGenericImpl *device_in)
521 {
522 JoystickImpl *device = (JoystickImpl*)device_in;
523 IOHIDElementRef tIOHIDTopElementRef;
524 IOHIDDeviceRef tIOHIDDeviceRef;
525 CFArrayRef gElementCFArrayRef = device->elementCFArrayRef;
526
527 TRACE("polling device %i\n",device->id);
528
529 if (!gCollections)
530 return;
531
532 tIOHIDTopElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(gCollections, device->id);
533 tIOHIDDeviceRef = IOHIDElementGetDevice(tIOHIDTopElementRef);
534
535 if (!tIOHIDDeviceRef)
536 return;
537
538 if (gElementCFArrayRef)
539 {
540 int button_idx = 0;
541 int pov_idx = 0;
542 int slider_idx = 0;
543 CFIndex idx, cnt = CFArrayGetCount( gElementCFArrayRef );
544
545 for ( idx = 0; idx < cnt; idx++ )
546 {
547 IOHIDValueRef valueRef;
548 int val;
549 IOHIDElementRef tIOHIDElementRef = ( IOHIDElementRef ) CFArrayGetValueAtIndex( gElementCFArrayRef, idx );
550 int eleType = IOHIDElementGetType( tIOHIDElementRef );
551
552 switch(eleType)
553 {
554 case kIOHIDElementTypeInput_Button:
555 if(button_idx < 128)
556 {
557 IOHIDDeviceGetValue(tIOHIDDeviceRef, tIOHIDElementRef, &valueRef);
558 val = IOHIDValueGetIntegerValue(valueRef);
559 device->generic.js.rgbButtons[button_idx] = val ? 0x80 : 0x00;
560 button_idx ++;
561 }
562 break;
563 case kIOHIDElementTypeInput_Misc:
564 {
565 uint32_t usage = IOHIDElementGetUsage( tIOHIDElementRef );
566 switch(usage)
567 {
568 case kHIDUsage_GD_Hatswitch:
569 {
570 IOHIDDeviceGetValue(tIOHIDDeviceRef, tIOHIDElementRef, &valueRef);
571 val = IOHIDValueGetIntegerValue(valueRef);
572 if (val >= 8)
573 device->generic.js.rgdwPOV[pov_idx] = -1;
574 else
575 device->generic.js.rgdwPOV[pov_idx] = val * 4500;
576 pov_idx ++;
577 break;
578 }
579 case kHIDUsage_GD_X:
580 case kHIDUsage_GD_Y:
581 case kHIDUsage_GD_Z:
582 case kHIDUsage_GD_Rx:
583 case kHIDUsage_GD_Ry:
584 case kHIDUsage_GD_Rz:
585 case kHIDUsage_GD_Slider:
586 {
587 IOHIDDeviceGetValue(tIOHIDDeviceRef, tIOHIDElementRef, &valueRef);
588 val = IOHIDValueGetIntegerValue(valueRef);
589 switch (usage)
590 {
591 case kHIDUsage_GD_X:
592 device->generic.js.lX = joystick_map_axis(&device->generic.props[idx], val);
593 break;
594 case kHIDUsage_GD_Y:
595 device->generic.js.lY = joystick_map_axis(&device->generic.props[idx], val);
596 break;
597 case kHIDUsage_GD_Z:
598 device->generic.js.lZ = joystick_map_axis(&device->generic.props[idx], val);
599 break;
600 case kHIDUsage_GD_Rx:
601 device->generic.js.lRx = joystick_map_axis(&device->generic.props[idx], val);
602 break;
603 case kHIDUsage_GD_Ry:
604 device->generic.js.lRy = joystick_map_axis(&device->generic.props[idx], val);
605 break;
606 case kHIDUsage_GD_Rz:
607 device->generic.js.lRz = joystick_map_axis(&device->generic.props[idx], val);
608 break;
609 case kHIDUsage_GD_Slider:
610 device->generic.js.rglSlider[slider_idx] = joystick_map_axis(&device->generic.props[idx], val);
611 slider_idx ++;
612 break;
613 }
614 break;
615 }
616 default:
617 FIXME("unhandled usage %i\n",usage);
618 }
619 break;
620 }
621 default:
622 FIXME("Unhandled type %i\n",eleType);
623 }
624 }
625 }
626 }
627
628 static INT find_joystick_devices(void)
629 {
630 static INT joystick_devices_count = -1;
631
632 if (joystick_devices_count != -1) return joystick_devices_count;
633
634 joystick_devices_count = find_osx_devices();
635
636 return joystick_devices_count;
637 }
638
639 static BOOL joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
640 {
641 if (id >= find_joystick_devices()) return FALSE;
642
643 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
644 WARN("force feedback not supported\n");
645 return FALSE;
646 }
647
648 if ((dwDevType == 0) ||
649 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
650 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800)))
651 {
652 /* Return joystick */
653 lpddi->guidInstance = DInput_Wine_OsX_Joystick_GUID;
654 lpddi->guidInstance.Data3 = id;
655 lpddi->guidProduct = DInput_Wine_OsX_Joystick_GUID;
656 /* we only support traditional joysticks for now */
657 if (version >= 0x0800)
658 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
659 else
660 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
661 sprintf(lpddi->tszInstanceName, "Joystick %d", id);
662
663 /* get the device name */
664 get_osx_device_name(id, lpddi->tszProductName, MAX_PATH);
665
666 lpddi->guidFFDriver = GUID_NULL;
667 return TRUE;
668 }
669
670 return FALSE;
671 }
672
673 static BOOL joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
674 {
675 char name[MAX_PATH];
676 char friendly[32];
677
678 if (id >= find_joystick_devices()) return FALSE;
679
680 if (dwFlags & DIEDFL_FORCEFEEDBACK) {
681 WARN("force feedback not supported\n");
682 return FALSE;
683 }
684
685 if ((dwDevType == 0) ||
686 ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
687 (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
688 /* Return joystick */
689 lpddi->guidInstance = DInput_Wine_OsX_Joystick_GUID;
690 lpddi->guidInstance.Data3 = id;
691 lpddi->guidProduct = DInput_Wine_OsX_Joystick_GUID;
692 /* we only support traditional joysticks for now */
693 if (version >= 0x0800)
694 lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
695 else
696 lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
697 sprintf(friendly, "Joystick %d", id);
698 MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH);
699 /* get the device name */
700 get_osx_device_name(id, name, MAX_PATH);
701
702 MultiByteToWideChar(CP_ACP, 0, name, -1, lpddi->tszProductName, MAX_PATH);
703 lpddi->guidFFDriver = GUID_NULL;
704 return TRUE;
705 }
706
707 return FALSE;
708 }
709
710 static HRESULT alloc_device(REFGUID rguid, const void *jvt, IDirectInputImpl *dinput,
711 LPDIRECTINPUTDEVICEA* pdev, unsigned short index)
712 {
713 DWORD i;
714 JoystickImpl* newDevice;
715 char name[MAX_PATH];
716 HRESULT hr;
717 LPDIDATAFORMAT df = NULL;
718 int idx = 0;
719 int axis_map[8]; /* max axes */
720 int slider_count = 0;
721
722 TRACE("%s %p %p %p %hu\n", debugstr_guid(rguid), jvt, dinput, pdev, index);
723
724 newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
725 if (newDevice == 0) {
726 WARN("out of memory\n");
727 *pdev = 0;
728 return DIERR_OUTOFMEMORY;
729 }
730
731 newDevice->id = index;
732
733 newDevice->generic.guidInstance = DInput_Wine_OsX_Joystick_GUID;
734 newDevice->generic.guidInstance.Data3 = index;
735 newDevice->generic.guidProduct = DInput_Wine_OsX_Joystick_GUID;
736 newDevice->generic.joy_polldev = poll_osx_device_state;
737
738 /* get the device name */
739 get_osx_device_name(index, name, MAX_PATH);
740 TRACE("Name %s\n",name);
741
742 /* copy the device name */
743 newDevice->generic.name = HeapAlloc(GetProcessHeap(),0,strlen(name) + 1);
744 strcpy(newDevice->generic.name, name);
745
746 memset(axis_map, 0, sizeof(axis_map));
747 get_osx_device_elements(newDevice, axis_map);
748
749 TRACE("%i axes %i buttons %i povs\n",newDevice->generic.devcaps.dwAxes,newDevice->generic.devcaps.dwButtons,newDevice->generic.devcaps.dwPOVs);
750
751 if (newDevice->generic.devcaps.dwButtons > 128)
752 {
753 WARN("Can't support %d buttons. Clamping down to 128\n", newDevice->generic.devcaps.dwButtons);
754 newDevice->generic.devcaps.dwButtons = 128;
755 }
756
757 newDevice->generic.base.lpVtbl = jvt;
758 newDevice->generic.base.ref = 1;
759 newDevice->generic.base.dinput = dinput;
760 newDevice->generic.base.guid = *rguid;
761 InitializeCriticalSection(&newDevice->generic.base.crit);
762 newDevice->generic.base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->generic.base.crit");
763
764 /* Create copy of default data format */
765 if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto FAILED;
766 memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
767
768 df->dwNumObjs = newDevice->generic.devcaps.dwAxes + newDevice->generic.devcaps.dwPOVs + newDevice->generic.devcaps.dwButtons;
769 if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto FAILED;
770
771 for (i = 0; i < newDevice->generic.devcaps.dwAxes; i++)
772 {
773 int wine_obj = -1;
774 switch (axis_map[i])
775 {
776 case kHIDUsage_GD_X: wine_obj = 0; break;
777 case kHIDUsage_GD_Y: wine_obj = 1; break;
778 case kHIDUsage_GD_Z: wine_obj = 2; break;
779 case kHIDUsage_GD_Rx: wine_obj = 3; break;
780 case kHIDUsage_GD_Ry: wine_obj = 4; break;
781 case kHIDUsage_GD_Rz: wine_obj = 5; break;
782 case kHIDUsage_GD_Slider:
783 wine_obj = 6 + slider_count;
784 slider_count++;
785 break;
786 }
787 if (wine_obj < 0 ) continue;
788
789 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[wine_obj], df->dwObjSize);
790 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(wine_obj) | DIDFT_ABSAXIS;
791 }
792
793 for (i = 0; i < newDevice->generic.devcaps.dwPOVs; i++)
794 {
795 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + 8], df->dwObjSize);
796 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_POV;
797 }
798
799 for (i = 0; i < newDevice->generic.devcaps.dwButtons; i++)
800 {
801 memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + 12], df->dwObjSize);
802 df->rgodf[idx ].pguid = &GUID_Button;
803 df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_PSHBUTTON;
804 }
805 newDevice->generic.base.data_format.wine_df = df;
806
807 /* initialize default properties */
808 get_osx_device_elements_props(newDevice);
809
810 IDirectInput_AddRef((LPDIRECTINPUTDEVICE8A)newDevice->generic.base.dinput);
811
812 newDevice->generic.devcaps.dwSize = sizeof(newDevice->generic.devcaps);
813 newDevice->generic.devcaps.dwFlags = DIDC_ATTACHED;
814 if (newDevice->generic.base.dinput->dwVersion >= 0x0800)
815 newDevice->generic.devcaps.dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
816 else
817 newDevice->generic.devcaps.dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
818 newDevice->generic.devcaps.dwFFSamplePeriod = 0;
819 newDevice->generic.devcaps.dwFFMinTimeResolution = 0;
820 newDevice->generic.devcaps.dwFirmwareRevision = 0;
821 newDevice->generic.devcaps.dwHardwareRevision = 0;
822 newDevice->generic.devcaps.dwFFDriverVersion = 0;
823
824 if (TRACE_ON(dinput)) {
825 _dump_DIDATAFORMAT(newDevice->generic.base.data_format.wine_df);
826 _dump_DIDEVCAPS(&newDevice->generic.devcaps);
827 }
828
829 *pdev = (LPDIRECTINPUTDEVICEA)newDevice;
830
831 return DI_OK;
832
833 FAILED:
834 hr = DIERR_OUTOFMEMORY;
835 if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
836 HeapFree(GetProcessHeap(), 0, df);
837 release_DataFormat(&newDevice->generic.base.data_format);
838 HeapFree(GetProcessHeap(),0,newDevice->generic.name);
839 HeapFree(GetProcessHeap(),0,newDevice);
840 *pdev = 0;
841
842 return hr;
843 }
844
845 /******************************************************************************
846 * get_joystick_index : Get the joystick index from a given GUID
847 */
848 static unsigned short get_joystick_index(REFGUID guid)
849 {
850 GUID wine_joystick = DInput_Wine_OsX_Joystick_GUID;
851 GUID dev_guid = *guid;
852
853 wine_joystick.Data3 = 0;
854 dev_guid.Data3 = 0;
855
856 /* for the standard joystick GUID use index 0 */
857 if(IsEqualGUID(&GUID_Joystick,guid)) return 0;
858
859 /* for the wine joystick GUIDs use the index stored in Data3 */
860 if(IsEqualGUID(&wine_joystick, &dev_guid)) return guid->Data3;
861
862 return 0xffff;
863 }
864
865 static HRESULT joydev_create_deviceA(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEA* pdev)
866 {
867 unsigned short index;
868 int joystick_devices_count;
869
870 TRACE("%p %s %p %p\n",dinput, debugstr_guid(rguid), riid, pdev);
871 *pdev = NULL;
872
873 if ((joystick_devices_count = find_joystick_devices()) == 0)
874 return DIERR_DEVICENOTREG;
875
876 if ((index = get_joystick_index(rguid)) < 0xffff &&
877 joystick_devices_count && index < joystick_devices_count)
878 {
879 if ((riid == NULL) ||
880 IsEqualGUID(&IID_IDirectInputDeviceA, riid) ||
881 IsEqualGUID(&IID_IDirectInputDevice2A, riid) ||
882 IsEqualGUID(&IID_IDirectInputDevice7A, riid) ||
883 IsEqualGUID(&IID_IDirectInputDevice8A, riid))
884 {
885 return alloc_device(rguid, &JoystickAvt, dinput, pdev, index);
886 }
887
888 WARN("no interface\n");
889 return DIERR_NOINTERFACE;
890 }
891
892 return DIERR_DEVICENOTREG;
893 }
894
895 static HRESULT joydev_create_deviceW(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPDIRECTINPUTDEVICEW* pdev)
896 {
897 unsigned short index;
898 int joystick_devices_count;
899
900 TRACE("%p %s %p %p\n",dinput, debugstr_guid(rguid), riid, pdev);
901 *pdev = NULL;
902
903 if ((joystick_devices_count = find_joystick_devices()) == 0)
904 return DIERR_DEVICENOTREG;
905
906 if ((index = get_joystick_index(rguid)) < 0xffff &&
907 joystick_devices_count && index < joystick_devices_count)
908 {
909 if ((riid == NULL) ||
910 IsEqualGUID(&IID_IDirectInputDeviceW, riid) ||
911 IsEqualGUID(&IID_IDirectInputDevice2W, riid) ||
912 IsEqualGUID(&IID_IDirectInputDevice7W, riid) ||
913 IsEqualGUID(&IID_IDirectInputDevice8W, riid))
914 {
915 return alloc_device(rguid, &JoystickWvt, dinput, (LPDIRECTINPUTDEVICEA *)pdev, index);
916 }
917 WARN("no interface\n");
918 return DIERR_NOINTERFACE;
919 }
920
921 WARN("invalid device GUID %s\n",debugstr_guid(rguid));
922 return DIERR_DEVICENOTREG;
923 }
924
925 const struct dinput_device joystick_osx_device = {
926 "Wine OS X joystick driver",
927 joydev_enum_deviceA,
928 joydev_enum_deviceW,
929 joydev_create_deviceA,
930 joydev_create_deviceW
931 };
932
933 static const IDirectInputDevice8AVtbl JoystickAvt =
934 {
935 IDirectInputDevice2AImpl_QueryInterface,
936 IDirectInputDevice2AImpl_AddRef,
937 IDirectInputDevice2AImpl_Release,
938 JoystickAGenericImpl_GetCapabilities,
939 IDirectInputDevice2AImpl_EnumObjects,
940 JoystickAGenericImpl_GetProperty,
941 JoystickAGenericImpl_SetProperty,
942 IDirectInputDevice2AImpl_Acquire,
943 IDirectInputDevice2AImpl_Unacquire,
944 JoystickAGenericImpl_GetDeviceState,
945 IDirectInputDevice2AImpl_GetDeviceData,
946 IDirectInputDevice2AImpl_SetDataFormat,
947 IDirectInputDevice2AImpl_SetEventNotification,
948 IDirectInputDevice2AImpl_SetCooperativeLevel,
949 JoystickAGenericImpl_GetObjectInfo,
950 JoystickAGenericImpl_GetDeviceInfo,
951 IDirectInputDevice2AImpl_RunControlPanel,
952 IDirectInputDevice2AImpl_Initialize,
953 IDirectInputDevice2AImpl_CreateEffect,
954 IDirectInputDevice2AImpl_EnumEffects,
955 IDirectInputDevice2AImpl_GetEffectInfo,
956 IDirectInputDevice2AImpl_GetForceFeedbackState,
957 IDirectInputDevice2AImpl_SendForceFeedbackCommand,
958 IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
959 IDirectInputDevice2AImpl_Escape,
960 JoystickAGenericImpl_Poll,
961 IDirectInputDevice2AImpl_SendDeviceData,
962 IDirectInputDevice7AImpl_EnumEffectsInFile,
963 IDirectInputDevice7AImpl_WriteEffectToFile,
964 IDirectInputDevice8AImpl_BuildActionMap,
965 IDirectInputDevice8AImpl_SetActionMap,
966 IDirectInputDevice8AImpl_GetImageInfo
967 };
968
969 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
970 # define XCAST(fun) (typeof(JoystickWvt.fun))
971 #else
972 # define XCAST(fun) (void*)
973 #endif
974
975 static const IDirectInputDevice8WVtbl JoystickWvt =
976 {
977 IDirectInputDevice2WImpl_QueryInterface,
978 XCAST(AddRef)IDirectInputDevice2AImpl_AddRef,
979 XCAST(Release)IDirectInputDevice2AImpl_Release,
980 XCAST(GetCapabilities)JoystickAGenericImpl_GetCapabilities,
981 IDirectInputDevice2WImpl_EnumObjects,
982 XCAST(GetProperty)JoystickAGenericImpl_GetProperty,
983 XCAST(SetProperty)JoystickAGenericImpl_SetProperty,
984 XCAST(Acquire)IDirectInputDevice2AImpl_Acquire,
985 XCAST(Unacquire)IDirectInputDevice2AImpl_Unacquire,
986 XCAST(GetDeviceState)JoystickAGenericImpl_GetDeviceState,
987 XCAST(GetDeviceData)IDirectInputDevice2AImpl_GetDeviceData,
988 XCAST(SetDataFormat)IDirectInputDevice2AImpl_SetDataFormat,
989 XCAST(SetEventNotification)IDirectInputDevice2AImpl_SetEventNotification,
990 XCAST(SetCooperativeLevel)IDirectInputDevice2AImpl_SetCooperativeLevel,
991 JoystickWGenericImpl_GetObjectInfo,
992 JoystickWGenericImpl_GetDeviceInfo,
993 XCAST(RunControlPanel)IDirectInputDevice2AImpl_RunControlPanel,
994 XCAST(Initialize)IDirectInputDevice2AImpl_Initialize,
995 XCAST(CreateEffect)IDirectInputDevice2AImpl_CreateEffect,
996 IDirectInputDevice2WImpl_EnumEffects,
997 IDirectInputDevice2WImpl_GetEffectInfo,
998 XCAST(GetForceFeedbackState)IDirectInputDevice2AImpl_GetForceFeedbackState,
999 XCAST(SendForceFeedbackCommand)IDirectInputDevice2AImpl_SendForceFeedbackCommand,
1000 XCAST(EnumCreatedEffectObjects)IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1001 XCAST(Escape)IDirectInputDevice2AImpl_Escape,
1002 XCAST(Poll)JoystickAGenericImpl_Poll,
1003 XCAST(SendDeviceData)IDirectInputDevice2AImpl_SendDeviceData,
1004 IDirectInputDevice7WImpl_EnumEffectsInFile,
1005 IDirectInputDevice7WImpl_WriteEffectToFile,
1006 IDirectInputDevice8WImpl_BuildActionMap,
1007 IDirectInputDevice8WImpl_SetActionMap,
1008 IDirectInputDevice8WImpl_GetImageInfo
1009 };
1010 #undef XCAST
1011
1012 #else /* HAVE_IOHIDMANAGERCREATE */
1013
1014 const struct dinput_device joystick_osx_device = {
1015 "Wine OS X joystick driver",
1016 NULL,
1017 NULL,
1018 NULL,
1019 NULL
1020 };
1021
1022 #endif /* HAVE_IOHIDMANAGERCREATE */
1023
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.