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