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