git.oblomov.eu Git - wine/blob - dlls/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 }