dlls/dinput/joystick_osx.c

   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_IOKIT_HID_IOHIDLIB_H)
  27 #define DWORD UInt32
  28 #define LPDWORD UInt32*
  29 #define LONG SInt32
  30 #define LPLONG SInt32*
  31 #define E_PENDING __carbon_E_PENDING
  32 #define ULONG __carbon_ULONG
  33 #define E_INVALIDARG __carbon_E_INVALIDARG
  34 #define E_OUTOFMEMORY __carbon_E_OUTOFMEMORY
  35 #define E_HANDLE __carbon_E_HANDLE
  36 #define E_ACCESSDENIED __carbon_E_ACCESSDENIED
  37 #define E_UNEXPECTED __carbon_E_UNEXPECTED
  38 #define E_FAIL __carbon_E_FAIL
  39 #define E_ABORT __carbon_E_ABORT
  40 #define E_POINTER __carbon_E_POINTER
  41 #define E_NOINTERFACE __carbon_E_NOINTERFACE
  42 #define E_NOTIMPL __carbon_E_NOTIMPL
  43 #define S_FALSE __carbon_S_FALSE
  44 #define S_OK __carbon_S_OK
  45 #define HRESULT_FACILITY __carbon_HRESULT_FACILITY
  46 #define IS_ERROR __carbon_IS_ERROR
  47 #define FAILED __carbon_FAILED
  48 #define SUCCEEDED __carbon_SUCCEEDED
  49 #define MAKE_HRESULT __carbon_MAKE_HRESULT
  50 #define HRESULT __carbon_HRESULT
  51 #define STDMETHODCALLTYPE __carbon_STDMETHODCALLTYPE
  52 #include <IOKit/IOKitLib.h>
  53 #include <IOKit/hid/IOHIDLib.h>
  54 #include <ForceFeedback/ForceFeedback.h>
  55 #undef ULONG
  56 #undef E_INVALIDARG
  57 #undef E_OUTOFMEMORY
  58 #undef E_HANDLE
  59 #undef E_ACCESSDENIED
  60 #undef E_UNEXPECTED
  61 #undef E_FAIL
  62 #undef E_ABORT
  63 #undef E_POINTER
  64 #undef E_NOINTERFACE
  65 #undef E_NOTIMPL
  66 #undef S_FALSE
  67 #undef S_OK
  68 #undef HRESULT_FACILITY
  69 #undef IS_ERROR
  70 #undef FAILED
  71 #undef SUCCEEDED
  72 #undef MAKE_HRESULT
  73 #undef HRESULT
  74 #undef STDMETHODCALLTYPE
  75 #undef DWORD
  76 #undef LPDWORD
  77 #undef LONG
  78 #undef LPLONG
  79 #undef E_PENDING
  80 #endif /* HAVE_IOKIT_HID_IOHIDLIB_H */
  81
  82 #include "wine/debug.h"
  83 #include "wine/unicode.h"
  84 #include "windef.h"
  85 #include "winbase.h"
  86 #include "winerror.h"
  87 #include "winreg.h"
  88 #include "dinput.h"
  89
  90 #include "dinput_private.h"
  91 #include "device_private.h"
  92 #include "joystick_private.h"
  93
  94 #ifdef HAVE_IOHIDMANAGERCREATE
  95
  96 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  97
  98 static IOHIDManagerRef hid_manager = NULL;
  99 static CFMutableArrayRef device_main_elements = NULL;
 100
 101 typedef struct JoystickImpl JoystickImpl;
 102 static const IDirectInputDevice8AVtbl JoystickAvt;
 103 static const IDirectInputDevice8WVtbl JoystickWvt;
 104
 105 struct JoystickImpl
 106 {
 107     struct JoystickGenericImpl generic;
 108
 109     /* osx private */
 110     int                    id;
 111     CFArrayRef             elements;
 112     ObjProps               **propmap;
 113     FFDeviceObjectReference ff;
 114     struct list effects;
 115 };
 116
 117 static inline JoystickImpl *impl_from_IDirectInputDevice8A(IDirectInputDevice8A *iface)
 118 {
 119     return CONTAINING_RECORD(CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8A_iface),
 120            JoystickGenericImpl, base), JoystickImpl, generic);
 121 }
 122 static inline JoystickImpl *impl_from_IDirectInputDevice8W(IDirectInputDevice8W *iface)
 123 {
 124     return CONTAINING_RECORD(CONTAINING_RECORD(CONTAINING_RECORD(iface, IDirectInputDeviceImpl, IDirectInputDevice8W_iface),
 125            JoystickGenericImpl, base), JoystickImpl, generic);
 126 }
 127
 128 typedef struct _EffectImpl {
 129     IDirectInputEffect IDirectInputEffect_iface;
 130     LONG ref;
 131
 132     JoystickImpl *device;
 133     FFEffectObjectReference effect;
 134     GUID guid;
 135
 136     struct list entry;
 137 } EffectImpl;
 138
 139 static EffectImpl *impl_from_IDirectInputEffect(IDirectInputEffect *iface)
 140 {
 141     return CONTAINING_RECORD(iface, EffectImpl, IDirectInputEffect_iface);
 142 }
 143
 144 static const IDirectInputEffectVtbl EffectVtbl;
 145
 146 static const GUID DInput_Wine_OsX_Joystick_GUID = { /* 59CAD8F6-E617-41E2-8EB7-47B23EEEDC5A */
 147   0x59CAD8F6, 0xE617, 0x41E2, {0x8E, 0xB7, 0x47, 0xB2, 0x3E, 0xEE, 0xDC, 0x5A}
 148 };
 149
 150 static HRESULT osx_to_win32_hresult(HRESULT in)
 151 {
 152     /* OSX returns 16-bit COM runtime errors, which we should
 153      * convert to win32 */
 154     switch(in){
 155     case 0x80000001:
 156         return E_NOTIMPL;
 157     case 0x80000002:
 158         return E_OUTOFMEMORY;
 159     case 0x80000003:
 160         return E_INVALIDARG;
 161     case 0x80000004:
 162         return E_NOINTERFACE;
 163     case 0x80000005:
 164         return E_POINTER;
 165     case 0x80000006:
 166         return E_HANDLE;
 167     case 0x80000007:
 168         return E_ABORT;
 169     case 0x80000008:
 170         return E_FAIL;
 171     case 0x80000009:
 172         return E_ACCESSDENIED;
 173     case 0x8000FFFF:
 174         return E_UNEXPECTED;
 175     }
 176     return in;
 177 }
 178
 179 static void CFSetApplierFunctionCopyToCFArray(const void *value, void *context)
 180 {
 181     CFArrayAppendValue( ( CFMutableArrayRef ) context, value );
 182 }
 183
 184 static IOHIDDeviceRef get_device_ref(int id)
 185 {
 186     IOHIDElementRef device_main_element;
 187     IOHIDDeviceRef hid_device;
 188
 189     if (!device_main_elements || id >= CFArrayGetCount(device_main_elements))
 190         return 0;
 191
 192     device_main_element = (IOHIDElementRef)CFArrayGetValueAtIndex(device_main_elements, id);
 193     if (!device_main_element)
 194     {
 195         ERR("Invalid Element requested %i\n",id);
 196         return 0;
 197     }
 198
 199     hid_device = IOHIDElementGetDevice(device_main_element);
 200     if (!hid_device)
 201     {
 202         ERR("Invalid Device requested %i\n",id);
 203         return 0;
 204     }
 205
 206     return hid_device;
 207 }
 208
 209 static HRESULT get_ff(IOHIDDeviceRef device, FFDeviceObjectReference *ret)
 210 {
 211     io_service_t service;
 212     CFMutableDictionaryRef matching;
 213     CFTypeRef location_id;
 214
 215     matching = IOServiceMatching(kIOHIDDeviceKey);
 216     if(!matching){
 217         WARN("IOServiceMatching failed, force feedback disabled\n");
 218         return DIERR_DEVICENOTREG;
 219     }
 220
 221     location_id = IOHIDDeviceGetProperty(device, CFSTR(kIOHIDLocationIDKey));
 222     if(!location_id){
 223         CFRelease(matching);
 224         WARN("IOHIDDeviceGetProperty failed, force feedback disabled\n");
 225         return DIERR_DEVICENOTREG;
 226     }
 227
 228     CFDictionaryAddValue(matching, CFSTR(kIOHIDLocationIDKey), location_id);
 229
 230     service = IOServiceGetMatchingService(kIOMasterPortDefault, matching);
 231
 232     if(!ret)
 233         return FFIsForceFeedback(service) == FF_OK ? S_OK : S_FALSE;
 234
 235     return osx_to_win32_hresult(FFCreateDevice(service, ret));
 236 }
 237
 238 static CFMutableDictionaryRef create_osx_device_match(int usage)
 239 {
 240     CFMutableDictionaryRef result;
 241
 242     result = CFDictionaryCreateMutable( kCFAllocatorDefault, 0,
 243             &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
 244
 245     if ( result )
 246     {
 247         int number = kHIDPage_GenericDesktop;
 248         CFNumberRef page = CFNumberCreate( kCFAllocatorDefault,
 249                           kCFNumberIntType, &number);
 250
 251         if (page)
 252         {
 253             CFNumberRef cf_usage;
 254
 255             CFDictionarySetValue( result, CFSTR( kIOHIDDeviceUsagePageKey ), page );
 256             CFRelease( page );
 257
 258             cf_usage = CFNumberCreate( kCFAllocatorDefault,
 259                         kCFNumberIntType, &usage);
 260             if (cf_usage)
 261             {
 262                 CFDictionarySetValue( result, CFSTR( kIOHIDDeviceUsageKey ), cf_usage );
 263                 CFRelease( cf_usage );
 264             }
 265             else
 266             {
 267                 ERR("CFNumberCreate() failed.\n");
 268                 return NULL;
 269             }
 270         }
 271         else
 272         {
 273             ERR("CFNumberCreate failed.\n");
 274             return NULL;
 275         }
 276     }
 277     else
 278     {
 279         ERR("CFDictionaryCreateMutable failed.\n");
 280         return NULL;
 281     }
 282
 283     return result;
 284 }
 285
 286 static CFIndex find_top_level(IOHIDDeviceRef hid_device, CFMutableArrayRef main_elements)
 287 {
 288     CFArrayRef      elements;
 289     CFIndex         total = 0;
 290
 291     if (!hid_device)
 292         return 0;
 293
 294     elements = IOHIDDeviceCopyMatchingElements(hid_device, NULL, 0);
 295
 296     if (elements)
 297     {
 298         CFIndex idx, cnt = CFArrayGetCount(elements);
 299         for (idx=0; idx<cnt; idx++)
 300         {
 301             IOHIDElementRef element = (IOHIDElementRef)CFArrayGetValueAtIndex(elements, idx);
 302             int type = IOHIDElementGetType(element);
 303
 304             /* Check for top-level gaming device collections */
 305             if (type == kIOHIDElementTypeCollection && IOHIDElementGetParent(element) == 0)
 306             {
 307                 int usage_page = IOHIDElementGetUsagePage(element);
 308                 int usage = IOHIDElementGetUsage(element);
 309
 310                 if (usage_page == kHIDPage_GenericDesktop &&
 311                     (usage == kHIDUsage_GD_Joystick || usage == kHIDUsage_GD_GamePad))
 312                 {
 313                     CFArrayAppendValue(main_elements, element);
 314                     total++;
 315                 }
 316             }
 317         }
 318     }
 319     return total;
 320 }
 321
 322 static void get_element_children(IOHIDElementRef element, CFMutableArrayRef all_children)
 323 {
 324     CFIndex    idx, cnt;
 325     CFArrayRef element_children = IOHIDElementGetChildren(element);
 326
 327     cnt = CFArrayGetCount(element_children);
 328
 329     /* Either add the element to the array or grab its children */
 330     for (idx=0; idx<cnt; idx++)
 331     {
 332         IOHIDElementRef child;
 333
 334         child = (IOHIDElementRef)CFArrayGetValueAtIndex(element_children, idx);
 335         if (IOHIDElementGetType(child) == kIOHIDElementTypeCollection)
 336             get_element_children(child, all_children);
 337         else
 338             CFArrayAppendValue(all_children, child);
 339     }
 340 }
 341
 342 static int find_osx_devices(void)
 343 {
 344     CFMutableDictionaryRef result;
 345     CFSetRef devset;
 346     CFMutableArrayRef matching;
 347
 348     hid_manager = IOHIDManagerCreate( kCFAllocatorDefault, 0L );
 349     if (IOHIDManagerOpen( hid_manager, 0 ) != kIOReturnSuccess)
 350     {
 351         ERR("Couldn't open IOHIDManager.\n");
 352         return 0;
 353     }
 354
 355      matching = CFArrayCreateMutable( kCFAllocatorDefault, 0,
 356                         &kCFTypeArrayCallBacks );
 357
 358     /* build matching dictionary */
 359     result = create_osx_device_match(kHIDUsage_GD_Joystick);
 360     if (!result)
 361     {
 362         CFRelease(matching);
 363         return 0;
 364     }
 365     CFArrayAppendValue( matching, result );
 366     result = create_osx_device_match(kHIDUsage_GD_GamePad);
 367     if (!result)
 368     {
 369         CFRelease(matching);
 370         return 0;
 371     }
 372     CFArrayAppendValue( matching, result );
 373
 374     IOHIDManagerSetDeviceMatchingMultiple( hid_manager, matching);
 375     devset = IOHIDManagerCopyDevices( hid_manager );
 376     if (devset)
 377     {
 378         CFIndex num_devices, num_main_elements, idx;
 379         CFMutableArrayRef devices = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 380         CFSetApplyFunction(devset, CFSetApplierFunctionCopyToCFArray, devices);
 381         CFRelease( devset);
 382         num_devices = CFArrayGetCount(devices);
 383
 384         device_main_elements = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 385         if (!device_main_elements)
 386             return 0;
 387
 388         num_main_elements = 0;
 389         for (idx = 0; idx < num_devices; idx++)
 390         {
 391             CFIndex top;
 392             IOHIDDeviceRef hid_device;
 393
 394             hid_device = (IOHIDDeviceRef) CFArrayGetValueAtIndex(devices, idx);
 395             top = find_top_level(hid_device, device_main_elements);
 396             num_main_elements += top;
 397         }
 398
 399         CFRelease(devices);
 400
 401         TRACE("found %i device(s), %i collection(s)\n",(int)num_devices,(int)num_main_elements);
 402         return (int)num_main_elements;
 403     }
 404     return 0;
 405 }
 406
 407 static int get_osx_device_name(int id, char *name, int length)
 408 {
 409     CFStringRef str;
 410     IOHIDDeviceRef hid_device;
 411
 412     hid_device = get_device_ref(id);
 413
 414     if (name)
 415         name[0] = 0;
 416
 417     if (!hid_device)
 418         return 0;
 419
 420     str = IOHIDDeviceGetProperty(hid_device, CFSTR( kIOHIDProductKey ));
 421     if (str)
 422     {
 423         CFIndex len = CFStringGetLength(str);
 424         if (length >= len)
 425         {
 426             CFStringGetCString(str,name,length,kCFStringEncodingASCII);
 427             return len;
 428         }
 429         else
 430             return (len+1);
 431     }
 432     return 0;
 433 }
 434
 435 static CFComparisonResult button_usage_comparator(const void *val1, const void *val2, void *context)
 436 {
 437     IOHIDElementRef element1 = (IOHIDElementRef)val1, element2 = (IOHIDElementRef)val2;
 438     int usage1 = IOHIDElementGetUsage(element1), usage2 = IOHIDElementGetUsage(element2);
 439
 440     if (usage1 < usage2)
 441         return kCFCompareLessThan;
 442     if (usage1 > usage2)
 443         return kCFCompareGreaterThan;
 444     return kCFCompareEqualTo;
 445 }
 446
 447 static void get_osx_device_elements(JoystickImpl *device, int axis_map[8])
 448 {
 449     IOHIDElementRef device_main_element;
 450     CFMutableArrayRef elements;
 451     DWORD           sliders = 0;
 452
 453     device->elements = NULL;
 454
 455     if (!device_main_elements || device->id >= CFArrayGetCount(device_main_elements))
 456         return;
 457
 458     device_main_element = (IOHIDElementRef)CFArrayGetValueAtIndex(device_main_elements, device->id);
 459
 460     if (!device_main_element)
 461         return;
 462
 463     elements = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 464     get_element_children(device_main_element, elements);
 465
 466     if (elements)
 467     {
 468         CFIndex idx, cnt = CFArrayGetCount( elements );
 469         CFMutableArrayRef axes = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 470         CFMutableArrayRef buttons = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 471         CFMutableArrayRef povs = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 472
 473         for ( idx = 0; idx < cnt; idx++ )
 474         {
 475             IOHIDElementRef element = ( IOHIDElementRef ) CFArrayGetValueAtIndex( elements, idx );
 476             int type = IOHIDElementGetType( element );
 477             switch(type)
 478             {
 479                 case kIOHIDElementTypeInput_Button:
 480                 {
 481                     int usage_page = IOHIDElementGetUsagePage( element );
 482                     if (usage_page != kHIDPage_Button)
 483                     {
 484                         /* avoid strange elements found on the 360 controller */
 485                         continue;
 486                     }
 487
 488                     if (CFArrayGetCount(buttons) < 128)
 489                         CFArrayAppendValue(buttons, element);
 490                     break;
 491                 }
 492                 case kIOHIDElementTypeInput_Axis:
 493                 {
 494                     CFArrayAppendValue(axes, element);
 495                     break;
 496                 }
 497                 case kIOHIDElementTypeInput_Misc:
 498                 {
 499                     uint32_t usage = IOHIDElementGetUsage( element );
 500                     switch(usage)
 501                     {
 502                         case kHIDUsage_GD_Hatswitch:
 503                         {
 504                             CFArrayAppendValue(povs, element);
 505                             break;
 506                         }
 507                         case kHIDUsage_GD_Slider:
 508                             sliders ++;
 509                             if (sliders > 2)
 510                                 break;
 511                             /* fallthrough, sliders are axis */
 512                         case kHIDUsage_GD_X:
 513                         case kHIDUsage_GD_Y:
 514                         case kHIDUsage_GD_Z:
 515                         case kHIDUsage_GD_Rx:
 516                         case kHIDUsage_GD_Ry:
 517                         case kHIDUsage_GD_Rz:
 518                         {
 519                             axis_map[CFArrayGetCount(axes)]=usage;
 520                             CFArrayAppendValue(axes, element);
 521                             break;
 522                         }
 523                         default:
 524                             FIXME("Unhandled usage %i\n",usage);
 525                     }
 526                     break;
 527                 }
 528                 default:
 529                     FIXME("Unhandled type %i\n",type);
 530             }
 531         }
 532
 533         /* Sort buttons into correct order */
 534         CFArraySortValues(buttons, CFRangeMake(0, CFArrayGetCount(buttons)), button_usage_comparator, NULL);
 535
 536         device->generic.devcaps.dwAxes = CFArrayGetCount(axes);
 537         device->generic.devcaps.dwButtons = CFArrayGetCount(buttons);
 538         device->generic.devcaps.dwPOVs = CFArrayGetCount(povs);
 539
 540         /* build our element array in the order that dinput expects */
 541         CFArrayAppendArray(axes, povs, CFRangeMake(0, device->generic.devcaps.dwPOVs));
 542         CFArrayAppendArray(axes, buttons, CFRangeMake(0, device->generic.devcaps.dwButtons));
 543         device->elements = axes;
 544         axes = NULL;
 545
 546         CFRelease(povs);
 547         CFRelease(buttons);
 548         CFRelease(elements);
 549     }
 550     else
 551     {
 552         device->generic.devcaps.dwAxes = 0;
 553         device->generic.devcaps.dwButtons = 0;
 554         device->generic.devcaps.dwPOVs = 0;
 555     }
 556 }
 557
 558 static void get_osx_device_elements_props(JoystickImpl *device)
 559 {
 560     if (device->elements)
 561     {
 562         CFIndex idx, cnt = CFArrayGetCount( device->elements );
 563
 564         for ( idx = 0; idx < cnt; idx++ )
 565         {
 566             IOHIDElementRef element = ( IOHIDElementRef ) CFArrayGetValueAtIndex( device->elements, idx );
 567
 568             device->generic.props[idx].lDevMin = IOHIDElementGetLogicalMin(element);
 569             device->generic.props[idx].lDevMax = IOHIDElementGetLogicalMax(element);
 570             device->generic.props[idx].lMin =  0;
 571             device->generic.props[idx].lMax =  0xffff;
 572             device->generic.props[idx].lDeadZone = 0;
 573             device->generic.props[idx].lSaturation = 0;
 574         }
 575     }
 576 }
 577
 578 static void poll_osx_device_state(LPDIRECTINPUTDEVICE8A iface)
 579 {
 580     JoystickImpl *device = impl_from_IDirectInputDevice8A(iface);
 581     IOHIDElementRef device_main_element;
 582     IOHIDDeviceRef hid_device;
 583
 584     TRACE("polling device %i\n",device->id);
 585
 586     if (!device_main_elements || device->id >= CFArrayGetCount(device_main_elements))
 587         return;
 588
 589     device_main_element = (IOHIDElementRef) CFArrayGetValueAtIndex(device_main_elements, device->id);
 590     hid_device = IOHIDElementGetDevice(device_main_element);
 591
 592     if (!hid_device)
 593         return;
 594
 595     if (device->elements)
 596     {
 597         int button_idx = 0;
 598         int pov_idx = 0;
 599         int slider_idx = 0;
 600         int inst_id;
 601         CFIndex idx, cnt = CFArrayGetCount( device->elements );
 602
 603         for ( idx = 0; idx < cnt; idx++ )
 604         {
 605             IOHIDValueRef valueRef;
 606             int val, oldVal, newVal;
 607             IOHIDElementRef element = ( IOHIDElementRef ) CFArrayGetValueAtIndex( device->elements, idx );
 608             int type = IOHIDElementGetType( element );
 609
 610             switch(type)
 611             {
 612                 case kIOHIDElementTypeInput_Button:
 613                     if(button_idx < 128)
 614                     {
 615                         IOHIDDeviceGetValue(hid_device, element, &valueRef);
 616                         val = IOHIDValueGetIntegerValue(valueRef);
 617                         newVal = val ? 0x80 : 0x0;
 618                         oldVal = device->generic.js.rgbButtons[button_idx];
 619                         device->generic.js.rgbButtons[button_idx] = newVal;
 620                         if (oldVal != newVal)
 621                         {
 622                             inst_id = DIDFT_MAKEINSTANCE(button_idx) | DIDFT_PSHBUTTON;
 623                             queue_event(iface,inst_id,newVal,GetCurrentTime(),device->generic.base.dinput->evsequence++);
 624                         }
 625                         button_idx ++;
 626                     }
 627                     break;
 628                 case kIOHIDElementTypeInput_Misc:
 629                 {
 630                     uint32_t usage = IOHIDElementGetUsage( element );
 631                     switch(usage)
 632                     {
 633                         case kHIDUsage_GD_Hatswitch:
 634                         {
 635                             IOHIDDeviceGetValue(hid_device, element, &valueRef);
 636                             val = IOHIDValueGetIntegerValue(valueRef);
 637                             oldVal = device->generic.js.rgdwPOV[pov_idx];
 638                             if (val >= 8)
 639                                 newVal = -1;
 640                             else
 641                                 newVal = val * 4500;
 642                             device->generic.js.rgdwPOV[pov_idx] = newVal;
 643                             if (oldVal != newVal)
 644                             {
 645                                 inst_id = DIDFT_MAKEINSTANCE(pov_idx) | DIDFT_POV;
 646                                 queue_event(iface,inst_id,newVal,GetCurrentTime(),device->generic.base.dinput->evsequence++);
 647                             }
 648                             pov_idx ++;
 649                             break;
 650                         }
 651                         case kHIDUsage_GD_X:
 652                         case kHIDUsage_GD_Y:
 653                         case kHIDUsage_GD_Z:
 654                         case kHIDUsage_GD_Rx:
 655                         case kHIDUsage_GD_Ry:
 656                         case kHIDUsage_GD_Rz:
 657                         case kHIDUsage_GD_Slider:
 658                         {
 659                             int wine_obj = -1;
 660
 661                             IOHIDDeviceGetValue(hid_device, element, &valueRef);
 662                             val = IOHIDValueGetIntegerValue(valueRef);
 663                             newVal = joystick_map_axis(&device->generic.props[idx], val);
 664                             switch (usage)
 665                             {
 666                             case kHIDUsage_GD_X:
 667                                 wine_obj = 0;
 668                                 oldVal = device->generic.js.lX;
 669                                 device->generic.js.lX = newVal;
 670                                 break;
 671                             case kHIDUsage_GD_Y:
 672                                 wine_obj = 1;
 673                                 oldVal = device->generic.js.lY;
 674                                 device->generic.js.lY = newVal;
 675                                 break;
 676                             case kHIDUsage_GD_Z:
 677                                 wine_obj = 2;
 678                                 oldVal = device->generic.js.lZ;
 679                                 device->generic.js.lZ = newVal;
 680                                 break;
 681                             case kHIDUsage_GD_Rx:
 682                                 wine_obj = 3;
 683                                 oldVal = device->generic.js.lRx;
 684                                 device->generic.js.lRx = newVal;
 685                                 break;
 686                             case kHIDUsage_GD_Ry:
 687                                 wine_obj = 4;
 688                                 oldVal = device->generic.js.lRy;
 689                                 device->generic.js.lRy = newVal;
 690                                 break;
 691                             case kHIDUsage_GD_Rz:
 692                                 wine_obj = 5;
 693                                 oldVal = device->generic.js.lRz;
 694                                 device->generic.js.lRz = newVal;
 695                                 break;
 696                             case kHIDUsage_GD_Slider:
 697                                 wine_obj = 6 + slider_idx;
 698                                 oldVal = device->generic.js.rglSlider[slider_idx];
 699                                 device->generic.js.rglSlider[slider_idx] = newVal;
 700                                 slider_idx ++;
 701                                 break;
 702                             }
 703                             if ((wine_obj != -1) &&
 704                                  (oldVal != newVal))
 705                             {
 706                                 inst_id = DIDFT_MAKEINSTANCE(wine_obj) | DIDFT_ABSAXIS;
 707                                 queue_event(iface,inst_id,newVal,GetCurrentTime(),device->generic.base.dinput->evsequence++);
 708                             }
 709
 710                             break;
 711                         }
 712                         default:
 713                             FIXME("unhandled usage %i\n",usage);
 714                     }
 715                     break;
 716                 }
 717                 default:
 718                     FIXME("Unhandled type %i\n",type);
 719             }
 720         }
 721     }
 722 }
 723
 724 static INT find_joystick_devices(void)
 725 {
 726     static INT joystick_devices_count = -1;
 727
 728     if (joystick_devices_count != -1) return joystick_devices_count;
 729
 730     joystick_devices_count = find_osx_devices();
 731
 732     return  joystick_devices_count;
 733 }
 734
 735 static HRESULT joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id)
 736 {
 737     if (id >= find_joystick_devices()) return E_FAIL;
 738
 739     if ((dwDevType == 0) ||
 740     ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
 741     (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800)))
 742     {
 743         if (dwFlags & DIEDFL_FORCEFEEDBACK) {
 744             IOHIDDeviceRef device = get_device_ref(id);
 745             if(!device)
 746                 return S_FALSE;
 747             if(get_ff(device, NULL) != S_OK)
 748                 return S_FALSE;
 749         }
 750         /* Return joystick */
 751         lpddi->guidInstance = DInput_Wine_OsX_Joystick_GUID;
 752         lpddi->guidInstance.Data3 = id;
 753         lpddi->guidProduct = DInput_Wine_OsX_Joystick_GUID;
 754         /* we only support traditional joysticks for now */
 755         if (version >= 0x0800)
 756             lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 757         else
 758             lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 759         sprintf(lpddi->tszInstanceName, "Joystick %d", id);
 760
 761         /* get the device name */
 762         get_osx_device_name(id, lpddi->tszProductName, MAX_PATH);
 763
 764         lpddi->guidFFDriver = GUID_NULL;
 765         return S_OK;
 766     }
 767
 768     return S_FALSE;
 769 }
 770
 771 static HRESULT joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEW lpddi, DWORD version, int id)
 772 {
 773     char name[MAX_PATH];
 774     char friendly[32];
 775
 776     if (id >= find_joystick_devices()) return E_FAIL;
 777
 778     if ((dwDevType == 0) ||
 779     ((dwDevType == DIDEVTYPE_JOYSTICK) && (version > 0x0300 && version < 0x0800)) ||
 780     (((dwDevType == DI8DEVCLASS_GAMECTRL) || (dwDevType == DI8DEVTYPE_JOYSTICK)) && (version >= 0x0800))) {
 781         if (dwFlags & DIEDFL_FORCEFEEDBACK) {
 782             IOHIDDeviceRef device = get_device_ref(id);
 783             if(!device)
 784                 return S_FALSE;
 785             if(get_ff(device, NULL) != S_OK)
 786                 return S_FALSE;
 787         }
 788         /* Return joystick */
 789         lpddi->guidInstance = DInput_Wine_OsX_Joystick_GUID;
 790         lpddi->guidInstance.Data3 = id;
 791         lpddi->guidProduct = DInput_Wine_OsX_Joystick_GUID;
 792         /* we only support traditional joysticks for now */
 793         if (version >= 0x0800)
 794             lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
 795         else
 796             lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
 797         sprintf(friendly, "Joystick %d", id);
 798         MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH);
 799         /* get the device name */
 800         get_osx_device_name(id, name, MAX_PATH);
 801
 802         MultiByteToWideChar(CP_ACP, 0, name, -1, lpddi->tszProductName, MAX_PATH);
 803         lpddi->guidFFDriver = GUID_NULL;
 804         return S_OK;
 805     }
 806
 807     return S_FALSE;
 808 }
 809
 810 static const char *osx_ff_axis_name(UInt8 axis)
 811 {
 812     static char ret[6];
 813     switch(axis){
 814     case FFJOFS_X:
 815         return "FFJOFS_X";
 816     case FFJOFS_Y:
 817         return "FFJOFS_Y";
 818     case FFJOFS_Z:
 819         return "FFJOFS_Z";
 820     }
 821     sprintf(ret, "%u", (unsigned int)axis);
 822     return ret;
 823 }
 824
 825 static BOOL osx_axis_has_ff(FFCAPABILITIES *ffcaps, UInt8 axis)
 826 {
 827     int i;
 828     for(i = 0; i < ffcaps->numFfAxes; ++i)
 829         if(ffcaps->ffAxes[i] == axis)
 830             return TRUE;
 831     return FALSE;
 832 }
 833
 834 static HRESULT alloc_device(REFGUID rguid, IDirectInputImpl *dinput,
 835                             JoystickImpl **pdev, unsigned short index)
 836 {
 837     DWORD i;
 838     IOHIDDeviceRef device;
 839     JoystickImpl* newDevice;
 840     char name[MAX_PATH];
 841     HRESULT hr;
 842     LPDIDATAFORMAT df = NULL;
 843     int idx = 0;
 844     int axis_map[8]; /* max axes */
 845     int slider_count = 0;
 846     FFCAPABILITIES ffcaps;
 847
 848     TRACE("%s %p %p %hu\n", debugstr_guid(rguid), dinput, pdev, index);
 849
 850     newDevice = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(JoystickImpl));
 851     if (newDevice == 0) {
 852         WARN("out of memory\n");
 853         *pdev = 0;
 854         return DIERR_OUTOFMEMORY;
 855     }
 856
 857     newDevice->id = index;
 858
 859     newDevice->generic.guidInstance = DInput_Wine_OsX_Joystick_GUID;
 860     newDevice->generic.guidInstance.Data3 = index;
 861     newDevice->generic.guidProduct = DInput_Wine_OsX_Joystick_GUID;
 862     newDevice->generic.joy_polldev = poll_osx_device_state;
 863
 864     /* get the device name */
 865     get_osx_device_name(index, name, MAX_PATH);
 866     TRACE("Name %s\n",name);
 867
 868     /* copy the device name */
 869     newDevice->generic.name = HeapAlloc(GetProcessHeap(),0,strlen(name) + 1);
 870     strcpy(newDevice->generic.name, name);
 871
 872     list_init(&newDevice->effects);
 873     device = get_device_ref(index);
 874     if(get_ff(device, &newDevice->ff) == S_OK){
 875         newDevice->generic.devcaps.dwFlags |= DIDC_FORCEFEEDBACK;
 876
 877         hr = FFDeviceGetForceFeedbackCapabilities(newDevice->ff, &ffcaps);
 878         if(SUCCEEDED(hr)){
 879             TRACE("FF Capabilities:\n");
 880             TRACE("\tsupportedEffects: 0x%x\n", (unsigned int)ffcaps.supportedEffects);
 881             TRACE("\temulatedEffects: 0x%x\n", (unsigned int)ffcaps.emulatedEffects);
 882             TRACE("\tsubType: 0x%x\n", (unsigned int)ffcaps.subType);
 883             TRACE("\tnumFfAxes: %u\n", (unsigned int)ffcaps.numFfAxes);
 884             TRACE("\tffAxes: [");
 885             for(i = 0; i < ffcaps.numFfAxes; ++i){
 886                 TRACE("%s", osx_ff_axis_name(ffcaps.ffAxes[i]));
 887                 if(i < ffcaps.numFfAxes - 1)
 888                     TRACE(", ");
 889             }
 890             TRACE("]\n");
 891             TRACE("\tstorageCapacity: %u\n", (unsigned int)ffcaps.storageCapacity);
 892             TRACE("\tplaybackCapacity: %u\n", (unsigned int)ffcaps.playbackCapacity);
 893         }
 894
 895         hr = FFDeviceSendForceFeedbackCommand(newDevice->ff, FFSFFC_RESET);
 896         if(FAILED(hr))
 897             WARN("FFDeviceSendForceFeedbackCommand(FFSFFC_RESET) failed: %08x\n", hr);
 898
 899         hr = FFDeviceSendForceFeedbackCommand(newDevice->ff, FFSFFC_SETACTUATORSON);
 900         if(FAILED(hr))
 901             WARN("FFDeviceSendForceFeedbackCommand(FFSFFC_SETACTUATORSON) failed: %08x\n", hr);
 902     }
 903
 904     memset(axis_map, 0, sizeof(axis_map));
 905     get_osx_device_elements(newDevice, axis_map);
 906
 907     TRACE("%i axes %i buttons %i povs\n",newDevice->generic.devcaps.dwAxes,newDevice->generic.devcaps.dwButtons,newDevice->generic.devcaps.dwPOVs);
 908
 909     if (newDevice->generic.devcaps.dwButtons > 128)
 910     {
 911         WARN("Can't support %d buttons. Clamping down to 128\n", newDevice->generic.devcaps.dwButtons);
 912         newDevice->generic.devcaps.dwButtons = 128;
 913     }
 914
 915     newDevice->generic.base.IDirectInputDevice8A_iface.lpVtbl = &JoystickAvt;
 916     newDevice->generic.base.IDirectInputDevice8W_iface.lpVtbl = &JoystickWvt;
 917     newDevice->generic.base.ref = 1;
 918     newDevice->generic.base.dinput = dinput;
 919     newDevice->generic.base.guid = *rguid;
 920     InitializeCriticalSection(&newDevice->generic.base.crit);
 921     newDevice->generic.base.crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": JoystickImpl*->generic.base.crit");
 922
 923     /* Create copy of default data format */
 924     if (!(df = HeapAlloc(GetProcessHeap(), 0, c_dfDIJoystick2.dwSize))) goto FAILED;
 925     memcpy(df, &c_dfDIJoystick2, c_dfDIJoystick2.dwSize);
 926
 927     df->dwNumObjs = newDevice->generic.devcaps.dwAxes + newDevice->generic.devcaps.dwPOVs + newDevice->generic.devcaps.dwButtons;
 928     if (!(df->rgodf = HeapAlloc(GetProcessHeap(), 0, df->dwNumObjs * df->dwObjSize))) goto FAILED;
 929
 930     for (i = 0; i < newDevice->generic.devcaps.dwAxes; i++)
 931     {
 932         int wine_obj = -1;
 933         BOOL has_ff  = FALSE;
 934         switch (axis_map[i])
 935         {
 936             case kHIDUsage_GD_X:
 937                 wine_obj = 0;
 938                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_X);
 939                 break;
 940             case kHIDUsage_GD_Y:
 941                 wine_obj = 1;
 942                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_Y);
 943                 break;
 944             case kHIDUsage_GD_Z:
 945                 wine_obj = 2;
 946                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_Z);
 947                 break;
 948             case kHIDUsage_GD_Rx:
 949                 wine_obj = 3;
 950                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_RX);
 951                 break;
 952             case kHIDUsage_GD_Ry:
 953                 wine_obj = 4;
 954                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_RY);
 955                 break;
 956             case kHIDUsage_GD_Rz:
 957                 wine_obj = 5;
 958                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_RZ);
 959                 break;
 960             case kHIDUsage_GD_Slider:
 961                 wine_obj = 6 + slider_count;
 962                 has_ff = (newDevice->ff != 0) && osx_axis_has_ff(&ffcaps, FFJOFS_SLIDER(slider_count));
 963                 slider_count++;
 964                 break;
 965         }
 966         if (wine_obj < 0 ) continue;
 967
 968         memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[wine_obj], df->dwObjSize);
 969         df->rgodf[idx].dwType = DIDFT_MAKEINSTANCE(wine_obj) | DIDFT_ABSAXIS;
 970         if(has_ff)
 971             df->rgodf[idx].dwFlags |= DIDOI_FFACTUATOR;
 972         ++idx;
 973     }
 974
 975     for (i = 0; i < newDevice->generic.devcaps.dwPOVs; i++)
 976     {
 977         memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + 8], df->dwObjSize);
 978         df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_POV;
 979     }
 980
 981     for (i = 0; i < newDevice->generic.devcaps.dwButtons; i++)
 982     {
 983         memcpy(&df->rgodf[idx], &c_dfDIJoystick2.rgodf[i + 12], df->dwObjSize);
 984         df->rgodf[idx  ].pguid = &GUID_Button;
 985         df->rgodf[idx++].dwType = DIDFT_MAKEINSTANCE(i) | DIDFT_PSHBUTTON;
 986     }
 987     newDevice->generic.base.data_format.wine_df = df;
 988
 989     /* initialize default properties */
 990     get_osx_device_elements_props(newDevice);
 991
 992     IDirectInput_AddRef(&newDevice->generic.base.dinput->IDirectInput7A_iface);
 993
 994     EnterCriticalSection(&dinput->crit);
 995     list_add_tail(&dinput->devices_list, &newDevice->generic.base.entry);
 996     LeaveCriticalSection(&dinput->crit);
 997
 998     newDevice->generic.devcaps.dwSize = sizeof(newDevice->generic.devcaps);
 999     newDevice->generic.devcaps.dwFlags |= DIDC_ATTACHED;
1000     if (newDevice->generic.base.dinput->dwVersion >= 0x0800)
1001         newDevice->generic.devcaps.dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8);
1002     else
1003         newDevice->generic.devcaps.dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8);
1004     newDevice->generic.devcaps.dwFFSamplePeriod = 0;
1005     newDevice->generic.devcaps.dwFFMinTimeResolution = 0;
1006     newDevice->generic.devcaps.dwFirmwareRevision = 0;
1007     newDevice->generic.devcaps.dwHardwareRevision = 0;
1008     newDevice->generic.devcaps.dwFFDriverVersion = 0;
1009
1010     if (TRACE_ON(dinput)) {
1011         _dump_DIDATAFORMAT(newDevice->generic.base.data_format.wine_df);
1012         _dump_DIDEVCAPS(&newDevice->generic.devcaps);
1013     }
1014
1015     *pdev = newDevice;
1016
1017     return DI_OK;
1018
1019 FAILED:
1020     hr = DIERR_OUTOFMEMORY;
1021     if (df) HeapFree(GetProcessHeap(), 0, df->rgodf);
1022     HeapFree(GetProcessHeap(), 0, df);
1023     release_DataFormat(&newDevice->generic.base.data_format);
1024     HeapFree(GetProcessHeap(),0,newDevice->generic.name);
1025     HeapFree(GetProcessHeap(),0,newDevice);
1026     *pdev = 0;
1027
1028     return hr;
1029 }
1030
1031 /******************************************************************************
1032   *     get_joystick_index : Get the joystick index from a given GUID
1033   */
1034 static unsigned short get_joystick_index(REFGUID guid)
1035 {
1036     GUID wine_joystick = DInput_Wine_OsX_Joystick_GUID;
1037     GUID dev_guid = *guid;
1038
1039     wine_joystick.Data3 = 0;
1040     dev_guid.Data3 = 0;
1041
1042     /* for the standard joystick GUID use index 0 */
1043     if(IsEqualGUID(&GUID_Joystick,guid)) return 0;
1044
1045     /* for the wine joystick GUIDs use the index stored in Data3 */
1046     if(IsEqualGUID(&wine_joystick, &dev_guid)) return guid->Data3;
1047
1048     return 0xffff;
1049 }
1050
1051 static HRESULT joydev_create_device(IDirectInputImpl *dinput, REFGUID rguid, REFIID riid, LPVOID *pdev, int unicode)
1052 {
1053     unsigned short index;
1054     int joystick_devices_count;
1055
1056     TRACE("%p %s %s %p %i\n", dinput, debugstr_guid(rguid), debugstr_guid(riid), pdev, unicode);
1057     *pdev = NULL;
1058
1059     if ((joystick_devices_count = find_joystick_devices()) == 0)
1060         return DIERR_DEVICENOTREG;
1061
1062     if ((index = get_joystick_index(rguid)) < 0xffff &&
1063         joystick_devices_count && index < joystick_devices_count)
1064     {
1065         JoystickImpl *This;
1066         HRESULT hr;
1067
1068         if (riid == NULL)
1069             ;/* nothing */
1070         else if (IsEqualGUID(&IID_IDirectInputDeviceA,  riid) ||
1071                  IsEqualGUID(&IID_IDirectInputDevice2A, riid) ||
1072                  IsEqualGUID(&IID_IDirectInputDevice7A, riid) ||
1073                  IsEqualGUID(&IID_IDirectInputDevice8A, riid))
1074         {
1075             unicode = 0;
1076         }
1077         else if (IsEqualGUID(&IID_IDirectInputDeviceW,  riid) ||
1078                  IsEqualGUID(&IID_IDirectInputDevice2W, riid) ||
1079                  IsEqualGUID(&IID_IDirectInputDevice7W, riid) ||
1080                  IsEqualGUID(&IID_IDirectInputDevice8W, riid))
1081         {
1082             unicode = 1;
1083         }
1084         else
1085         {
1086             WARN("no interface\n");
1087             return DIERR_NOINTERFACE;
1088         }
1089
1090         hr = alloc_device(rguid, dinput, &This, index);
1091         if (!This) return hr;
1092
1093         if (unicode)
1094             *pdev = &This->generic.base.IDirectInputDevice8W_iface;
1095         else
1096             *pdev = &This->generic.base.IDirectInputDevice8A_iface;
1097         return hr;
1098     }
1099
1100     return DIERR_DEVICENOTREG;
1101 }
1102
1103 static HRESULT osx_set_autocenter(JoystickImpl *This,
1104         const DIPROPDWORD *header)
1105 {
1106     UInt32 v;
1107     HRESULT hr;
1108     if(!This->ff)
1109         return DIERR_UNSUPPORTED;
1110     v = header->dwData;
1111     hr = osx_to_win32_hresult(FFDeviceSetForceFeedbackProperty(This->ff, FFPROP_AUTOCENTER, &v));
1112     TRACE("returning: %08x\n", hr);
1113     return hr;
1114 }
1115
1116 static HRESULT osx_set_ffgain(JoystickImpl *This, const DIPROPDWORD *header)
1117 {
1118     UInt32 v;
1119     HRESULT hr;
1120     if(!This->ff)
1121         return DIERR_UNSUPPORTED;
1122     v = header->dwData;
1123     hr = osx_to_win32_hresult(FFDeviceSetForceFeedbackProperty(This->ff, FFPROP_FFGAIN, &v));
1124     TRACE("returning: %08x\n", hr);
1125     return hr;
1126 }
1127
1128 static HRESULT WINAPI JoystickWImpl_SetProperty(IDirectInputDevice8W *iface,
1129         const GUID *prop, const DIPROPHEADER *header)
1130 {
1131     JoystickImpl *This = impl_from_IDirectInputDevice8W(iface);
1132
1133     TRACE("%p %s %p\n", This, debugstr_guid(prop), header);
1134
1135     switch(LOWORD(prop))
1136     {
1137     case (DWORD_PTR)DIPROP_AUTOCENTER:
1138         return osx_set_autocenter(This, (const DIPROPDWORD *)header);
1139     case (DWORD_PTR)DIPROP_FFGAIN:
1140         return osx_set_ffgain(This, (const DIPROPDWORD *)header);
1141     }
1142
1143     return JoystickWGenericImpl_SetProperty(iface, prop, header);
1144 }
1145
1146 static HRESULT WINAPI JoystickAImpl_SetProperty(IDirectInputDevice8A *iface,
1147         const GUID *prop, const DIPROPHEADER *header)
1148 {
1149     JoystickImpl *This = impl_from_IDirectInputDevice8A(iface);
1150
1151     TRACE("%p %s %p\n", This, debugstr_guid(prop), header);
1152
1153     switch(LOWORD(prop))
1154     {
1155     case (DWORD_PTR)DIPROP_AUTOCENTER:
1156         return osx_set_autocenter(This, (const DIPROPDWORD *)header);
1157     case (DWORD_PTR)DIPROP_FFGAIN:
1158         return osx_set_ffgain(This, (const DIPROPDWORD *)header);
1159     }
1160
1161     return JoystickAGenericImpl_SetProperty(iface, prop, header);
1162 }
1163
1164 static CFUUIDRef effect_win_to_mac(const GUID *effect)
1165 {
1166 #define DO_MAP(X) \
1167     if(IsEqualGUID(&GUID_##X, effect)) \
1168         return kFFEffectType_##X##_ID;
1169     DO_MAP(ConstantForce)
1170     DO_MAP(RampForce)
1171     DO_MAP(Square)
1172     DO_MAP(Sine)
1173     DO_MAP(Triangle)
1174     DO_MAP(SawtoothUp)
1175     DO_MAP(SawtoothDown)
1176     DO_MAP(Spring)
1177     DO_MAP(Damper)
1178     DO_MAP(Inertia)
1179     DO_MAP(Friction)
1180     DO_MAP(CustomForce)
1181 #undef DO_MAP
1182     WARN("Unknown effect GUID! %s\n", debugstr_guid(effect));
1183     return 0;
1184 }
1185
1186 static HRESULT WINAPI JoystickWImpl_CreateEffect(IDirectInputDevice8W *iface,
1187         const GUID *type, const DIEFFECT *params, IDirectInputEffect **out,
1188         IUnknown *outer)
1189 {
1190     JoystickImpl *This = impl_from_IDirectInputDevice8W(iface);
1191     EffectImpl *effect;
1192     HRESULT hr;
1193
1194     TRACE("%p %s %p %p %p\n", iface, debugstr_guid(type), params, out, outer);
1195     dump_DIEFFECT(params, type, 0);
1196
1197     if(!This->ff){
1198         TRACE("No force feedback support\n");
1199         *out = NULL;
1200         return S_OK;
1201     }
1202
1203     if(outer)
1204         WARN("aggregation not implemented\n");
1205
1206     effect = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
1207     effect->IDirectInputEffect_iface.lpVtbl = &EffectVtbl;
1208     effect->ref = 1;
1209     effect->guid = *type;
1210     effect->device = This;
1211
1212     /* Mac's FFEFFECT and Win's DIEFFECT are binary identical. */
1213     hr = osx_to_win32_hresult(FFDeviceCreateEffect(This->ff,
1214                 effect_win_to_mac(type), (FFEFFECT*)params, &effect->effect));
1215     if(FAILED(hr)){
1216         WARN("FFDeviceCreateEffect failed: %08x\n", hr);
1217         HeapFree(GetProcessHeap(), 0, effect);
1218         return hr;
1219     }
1220
1221     list_add_tail(&This->effects, &effect->entry);
1222     *out = &effect->IDirectInputEffect_iface;
1223
1224     TRACE("allocated effect: %p\n", effect);
1225
1226     return S_OK;
1227 }
1228
1229 static HRESULT WINAPI JoystickAImpl_CreateEffect(IDirectInputDevice8A *iface,
1230         const GUID *type, const DIEFFECT *params, IDirectInputEffect **out,
1231         IUnknown *outer)
1232 {
1233     JoystickImpl *This = impl_from_IDirectInputDevice8A(iface);
1234
1235     TRACE("%p %s %p %p %p\n", iface, debugstr_guid(type), params, out, outer);
1236
1237     return JoystickWImpl_CreateEffect(&This->generic.base.IDirectInputDevice8W_iface,
1238             type, params, out, outer);
1239 }
1240
1241 static HRESULT WINAPI JoystickWImpl_SendForceFeedbackCommand(IDirectInputDevice8W *iface,
1242         DWORD flags)
1243 {
1244     JoystickImpl *This = impl_from_IDirectInputDevice8W(iface);
1245     HRESULT hr;
1246
1247     TRACE("%p 0x%x\n", This, flags);
1248
1249     if(!This->ff)
1250         return DI_NOEFFECT;
1251
1252     hr = osx_to_win32_hresult(FFDeviceSendForceFeedbackCommand(This->ff, flags));
1253     if(FAILED(hr)){
1254         WARN("FFDeviceSendForceFeedbackCommand failed: %08x\n", hr);
1255         return hr;
1256     }
1257
1258     return S_OK;
1259 }
1260
1261 static HRESULT WINAPI JoystickAImpl_SendForceFeedbackCommand(IDirectInputDevice8A *iface,
1262         DWORD flags)
1263 {
1264     JoystickImpl *This = impl_from_IDirectInputDevice8A(iface);
1265
1266     TRACE("%p 0x%x\n", This, flags);
1267
1268     return JoystickWImpl_SendForceFeedbackCommand(&This->generic.base.IDirectInputDevice8W_iface, flags);
1269 }
1270
1271 const struct dinput_device joystick_osx_device = {
1272   "Wine OS X joystick driver",
1273   joydev_enum_deviceA,
1274   joydev_enum_deviceW,
1275   joydev_create_device
1276 };
1277
1278 static const IDirectInputDevice8AVtbl JoystickAvt =
1279 {
1280     IDirectInputDevice2AImpl_QueryInterface,
1281     IDirectInputDevice2AImpl_AddRef,
1282     IDirectInputDevice2AImpl_Release,
1283     JoystickAGenericImpl_GetCapabilities,
1284     IDirectInputDevice2AImpl_EnumObjects,
1285     JoystickAGenericImpl_GetProperty,
1286     JoystickAImpl_SetProperty,
1287     IDirectInputDevice2AImpl_Acquire,
1288     IDirectInputDevice2AImpl_Unacquire,
1289     JoystickAGenericImpl_GetDeviceState,
1290     IDirectInputDevice2AImpl_GetDeviceData,
1291     IDirectInputDevice2AImpl_SetDataFormat,
1292     IDirectInputDevice2AImpl_SetEventNotification,
1293     IDirectInputDevice2AImpl_SetCooperativeLevel,
1294     JoystickAGenericImpl_GetObjectInfo,
1295     JoystickAGenericImpl_GetDeviceInfo,
1296     IDirectInputDevice2AImpl_RunControlPanel,
1297     IDirectInputDevice2AImpl_Initialize,
1298     JoystickAImpl_CreateEffect,
1299     IDirectInputDevice2AImpl_EnumEffects,
1300     IDirectInputDevice2AImpl_GetEffectInfo,
1301     IDirectInputDevice2AImpl_GetForceFeedbackState,
1302     JoystickAImpl_SendForceFeedbackCommand,
1303     IDirectInputDevice2AImpl_EnumCreatedEffectObjects,
1304     IDirectInputDevice2AImpl_Escape,
1305     JoystickAGenericImpl_Poll,
1306     IDirectInputDevice2AImpl_SendDeviceData,
1307     IDirectInputDevice7AImpl_EnumEffectsInFile,
1308     IDirectInputDevice7AImpl_WriteEffectToFile,
1309     JoystickAGenericImpl_BuildActionMap,
1310     JoystickAGenericImpl_SetActionMap,
1311     IDirectInputDevice8AImpl_GetImageInfo
1312 };
1313
1314 static const IDirectInputDevice8WVtbl JoystickWvt =
1315 {
1316     IDirectInputDevice2WImpl_QueryInterface,
1317     IDirectInputDevice2WImpl_AddRef,
1318     IDirectInputDevice2WImpl_Release,
1319     JoystickWGenericImpl_GetCapabilities,
1320     IDirectInputDevice2WImpl_EnumObjects,
1321     JoystickWGenericImpl_GetProperty,
1322     JoystickWImpl_SetProperty,
1323     IDirectInputDevice2WImpl_Acquire,
1324     IDirectInputDevice2WImpl_Unacquire,
1325     JoystickWGenericImpl_GetDeviceState,
1326     IDirectInputDevice2WImpl_GetDeviceData,
1327     IDirectInputDevice2WImpl_SetDataFormat,
1328     IDirectInputDevice2WImpl_SetEventNotification,
1329     IDirectInputDevice2WImpl_SetCooperativeLevel,
1330     JoystickWGenericImpl_GetObjectInfo,
1331     JoystickWGenericImpl_GetDeviceInfo,
1332     IDirectInputDevice2WImpl_RunControlPanel,
1333     IDirectInputDevice2WImpl_Initialize,
1334     JoystickWImpl_CreateEffect,
1335     IDirectInputDevice2WImpl_EnumEffects,
1336     IDirectInputDevice2WImpl_GetEffectInfo,
1337     IDirectInputDevice2WImpl_GetForceFeedbackState,
1338     JoystickWImpl_SendForceFeedbackCommand,
1339     IDirectInputDevice2WImpl_EnumCreatedEffectObjects,
1340     IDirectInputDevice2WImpl_Escape,
1341     JoystickWGenericImpl_Poll,
1342     IDirectInputDevice2WImpl_SendDeviceData,
1343     IDirectInputDevice7WImpl_EnumEffectsInFile,
1344     IDirectInputDevice7WImpl_WriteEffectToFile,
1345     JoystickWGenericImpl_BuildActionMap,
1346     JoystickWGenericImpl_SetActionMap,
1347     IDirectInputDevice8WImpl_GetImageInfo
1348 };
1349
1350 static HRESULT WINAPI effect_QueryInterface(IDirectInputEffect *iface,
1351         const GUID *guid, void **out)
1352 {
1353     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1354
1355     TRACE("%p %s %p\n", This, debugstr_guid(guid), out);
1356
1357     if(IsEqualIID(guid, &IID_IDirectInputEffect)){
1358         *out = iface;
1359         IDirectInputEffect_AddRef(iface);
1360         return S_OK;
1361     }
1362
1363     return E_NOINTERFACE;
1364 }
1365
1366 static ULONG WINAPI effect_AddRef(IDirectInputEffect *iface)
1367 {
1368     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1369     ULONG ref = InterlockedIncrement(&This->ref);
1370     TRACE("%p, ref is now: %u\n", This, ref);
1371     return ref;
1372 }
1373
1374 static ULONG WINAPI effect_Release(IDirectInputEffect *iface)
1375 {
1376     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1377     ULONG ref = InterlockedDecrement(&This->ref);
1378     TRACE("%p, ref is now: %u\n", This, ref);
1379
1380     if(!ref){
1381         list_remove(&This->entry);
1382         FFDeviceReleaseEffect(This->device->ff, This->effect);
1383         HeapFree(GetProcessHeap(), 0, This);
1384     }
1385
1386     return ref;
1387 }
1388
1389 static HRESULT WINAPI effect_Initialize(IDirectInputEffect *iface, HINSTANCE hinst,
1390         DWORD version, const GUID *guid)
1391 {
1392     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1393     TRACE("%p %p 0x%x, %s\n", This, hinst, version, debugstr_guid(guid));
1394     return S_OK;
1395 }
1396
1397 static HRESULT WINAPI effect_GetEffectGuid(IDirectInputEffect *iface, GUID *out)
1398 {
1399     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1400     TRACE("%p %p\n", This, out);
1401     *out = This->guid;
1402     return S_OK;
1403 }
1404
1405 static HRESULT WINAPI effect_GetParameters(IDirectInputEffect *iface,
1406         DIEFFECT *effect, DWORD flags)
1407 {
1408     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1409     TRACE("%p %p 0x%x\n", This, effect, flags);
1410     return osx_to_win32_hresult(FFEffectGetParameters(This->effect, (FFEFFECT*)effect, flags));
1411 }
1412
1413 static HRESULT WINAPI effect_SetParameters(IDirectInputEffect *iface,
1414         const DIEFFECT *effect, DWORD flags)
1415 {
1416     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1417     TRACE("%p %p 0x%x\n", This, effect, flags);
1418     dump_DIEFFECT(effect, &This->guid, flags);
1419     return osx_to_win32_hresult(FFEffectSetParameters(This->effect, (FFEFFECT*)effect, flags));
1420 }
1421
1422 static HRESULT WINAPI effect_Start(IDirectInputEffect *iface, DWORD iterations,
1423         DWORD flags)
1424 {
1425     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1426     TRACE("%p 0x%x 0x%x\n", This, iterations, flags);
1427     return osx_to_win32_hresult(FFEffectStart(This->effect, iterations, flags));
1428 }
1429
1430 static HRESULT WINAPI effect_Stop(IDirectInputEffect *iface)
1431 {
1432     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1433     TRACE("%p\n", This);
1434     return osx_to_win32_hresult(FFEffectStop(This->effect));
1435 }
1436
1437 static HRESULT WINAPI effect_GetEffectStatus(IDirectInputEffect *iface, DWORD *flags)
1438 {
1439     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1440     TRACE("%p %p\n", This, flags);
1441     return osx_to_win32_hresult(FFEffectGetEffectStatus(This->effect, (UInt32*)flags));
1442 }
1443
1444 static HRESULT WINAPI effect_Download(IDirectInputEffect *iface)
1445 {
1446     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1447     TRACE("%p\n", This);
1448     return osx_to_win32_hresult(FFEffectDownload(This->effect));
1449 }
1450
1451 static HRESULT WINAPI effect_Unload(IDirectInputEffect *iface)
1452 {
1453     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1454     TRACE("%p\n", This);
1455     return osx_to_win32_hresult(FFEffectUnload(This->effect));
1456 }
1457
1458 static HRESULT WINAPI effect_Escape(IDirectInputEffect *iface, DIEFFESCAPE *escape)
1459 {
1460     EffectImpl *This = impl_from_IDirectInputEffect(iface);
1461     TRACE("%p %p\n", This, escape);
1462     return osx_to_win32_hresult(FFEffectEscape(This->effect, (FFEFFESCAPE*)escape));
1463 }
1464
1465 static const IDirectInputEffectVtbl EffectVtbl = {
1466     effect_QueryInterface,
1467     effect_AddRef,
1468     effect_Release,
1469     effect_Initialize,
1470     effect_GetEffectGuid,
1471     effect_GetParameters,
1472     effect_SetParameters,
1473     effect_Start,
1474     effect_Stop,
1475     effect_GetEffectStatus,
1476     effect_Download,
1477     effect_Unload,
1478     effect_Escape
1479 };
1480
1481 #else /* HAVE_IOHIDMANAGERCREATE */
1482
1483 const struct dinput_device joystick_osx_device = {
1484   "Wine OS X joystick driver",
1485   NULL,
1486   NULL,
1487   NULL
1488 };
1489
1490 #endif /* HAVE_IOHIDMANAGERCREATE */