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 /******************************************************************************
  36   *     SetProperty : change input device properties
  37   */
  38 HRESULT WINAPI JoystickAGenericImpl_SetProperty(
  39     LPDIRECTINPUTDEVICE8A iface,
  40     REFGUID rguid,
  41     LPCDIPROPHEADER ph)
  42 {
  43     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
  44     DWORD i;
  45
  46     TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
  47
  48     if (ph == NULL) {
  49         WARN("invalid parameter: ph == NULL\n");
  50         return DIERR_INVALIDPARAM;
  51     }
  52
  53     if (TRACE_ON(dinput))
  54         _dump_DIPROPHEADER(ph);
  55
  56     if (!HIWORD(rguid)) {
  57         switch (LOWORD(rguid)) {
  58         case (DWORD_PTR)DIPROP_RANGE: {
  59             LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
  60             if (ph->dwHow == DIPH_DEVICE) {
  61                 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
  62                 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
  63                     This->props[i].lMin = pr->lMin;
  64                     This->props[i].lMax = pr->lMax;
  65                 }
  66             } else {
  67                 int obj = find_property(&This->base.data_format, ph);
  68
  69                 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
  70                 if (obj >= 0) {
  71                     This->props[obj].lMin = pr->lMin;
  72                     This->props[obj].lMax = pr->lMax;
  73                     return DI_OK;
  74                 }
  75             }
  76             break;
  77         }
  78         case (DWORD_PTR)DIPROP_DEADZONE: {
  79             LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
  80             if (ph->dwHow == DIPH_DEVICE) {
  81                 TRACE("deadzone(%d) all\n", pd->dwData);
  82                 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
  83                     This->props[i].lDeadZone  = pd->dwData;
  84             } else {
  85                 int obj = find_property(&This->base.data_format, ph);
  86
  87                 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
  88                 if (obj >= 0) {
  89                     This->props[obj].lDeadZone  = pd->dwData;
  90                     return DI_OK;
  91                 }
  92             }
  93             break;
  94         }
  95         case (DWORD_PTR)DIPROP_SATURATION: {
  96             LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
  97             if (ph->dwHow == DIPH_DEVICE) {
  98                 TRACE("saturation(%d) all\n", pd->dwData);
  99                 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
 100                     This->props[i].lSaturation = pd->dwData;
 101             } else {
 102                 int obj = find_property(&This->base.data_format, ph);
 103
 104                 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
 105                 if (obj >= 0) {
 106                     This->props[obj].lSaturation = pd->dwData;
 107                     return DI_OK;
 108                 }
 109             }
 110             break;
 111         }
 112         default:
 113             return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
 114         }
 115     }
 116
 117     return DI_OK;
 118 }
 119
 120 void _dump_DIDEVCAPS(const DIDEVCAPS *lpDIDevCaps)
 121 {
 122     TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
 123     TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
 124     TRACE("dwDevType: %08x %s\n", lpDIDevCaps->dwDevType,
 125           lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
 126           lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
 127           lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
 128           lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
 129           lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
 130           lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
 131     TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
 132     TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
 133     TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
 134     if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
 135         TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
 136         TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
 137         TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
 138         TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
 139         TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
 140     }
 141 }
 142
 143 HRESULT WINAPI JoystickAGenericImpl_GetCapabilities(
 144         LPDIRECTINPUTDEVICE8A iface,
 145         LPDIDEVCAPS lpDIDevCaps)
 146 {
 147     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 148     int size;
 149
 150     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
 151
 152     if (lpDIDevCaps == NULL) {
 153         WARN("invalid pointer\n");
 154         return E_POINTER;
 155     }
 156
 157     size = lpDIDevCaps->dwSize;
 158
 159     if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
 160         WARN("invalid parameter\n");
 161         return DIERR_INVALIDPARAM;
 162     }
 163
 164     CopyMemory(lpDIDevCaps, &This->devcaps, size);
 165     lpDIDevCaps->dwSize = size;
 166
 167     if (TRACE_ON(dinput))
 168         _dump_DIDEVCAPS(lpDIDevCaps);
 169
 170     return DI_OK;
 171 }
 172
 173 /******************************************************************************
 174   *     GetObjectInfo : get object info
 175   */
 176 HRESULT WINAPI JoystickWGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
 177         LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
 178 {
 179     static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
 180     static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
 181     static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
 182     HRESULT res;
 183
 184     res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
 185     if (res != DI_OK) return res;
 186
 187     if      (pdidoi->dwType & DIDFT_AXIS)
 188         sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
 189     else if (pdidoi->dwType & DIDFT_POV)
 190         sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
 191     else if (pdidoi->dwType & DIDFT_BUTTON)
 192         sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
 193
 194     _dump_OBJECTINSTANCEW(pdidoi);
 195     return res;
 196 }
 197
 198 HRESULT WINAPI JoystickAGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
 199         LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
 200 {
 201     HRESULT res;
 202     DIDEVICEOBJECTINSTANCEW didoiW;
 203     DWORD dwSize = pdidoi->dwSize;
 204
 205     didoiW.dwSize = sizeof(didoiW);
 206     res = JoystickWGenericImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W)iface, &didoiW, dwObj, dwHow);
 207     if (res != DI_OK) return res;
 208
 209     memset(pdidoi, 0, pdidoi->dwSize);
 210     memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
 211     pdidoi->dwSize = dwSize;
 212     WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
 213                         sizeof(pdidoi->tszName), NULL, NULL);
 214
 215     return res;
 216 }
 217
 218 /******************************************************************************
 219   *     GetProperty : get input device properties
 220   */
 221 HRESULT WINAPI JoystickAGenericImpl_GetProperty(
 222     LPDIRECTINPUTDEVICE8A iface,
 223     REFGUID rguid,
 224     LPDIPROPHEADER pdiph)
 225 {
 226     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 227
 228     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
 229
 230     if (TRACE_ON(dinput))
 231         _dump_DIPROPHEADER(pdiph);
 232
 233     if (!HIWORD(rguid)) {
 234         switch (LOWORD(rguid)) {
 235         case (DWORD_PTR) DIPROP_RANGE: {
 236             LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
 237             int obj = find_property(&This->base.data_format, pdiph);
 238
 239             /* The app is querying the current range of the axis
 240              * return the lMin and lMax values */
 241             if (obj >= 0) {
 242                 pr->lMin = This->props[obj].lMin;
 243                 pr->lMax = This->props[obj].lMax;
 244                 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
 245                 return DI_OK;
 246             }
 247             break;
 248         }
 249         case (DWORD_PTR) DIPROP_DEADZONE: {
 250             LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
 251             int obj = find_property(&This->base.data_format, pdiph);
 252
 253             if (obj >= 0) {
 254                 pd->dwData = This->props[obj].lDeadZone;
 255                 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
 256                 return DI_OK;
 257             }
 258             break;
 259         }
 260         case (DWORD_PTR) DIPROP_SATURATION: {
 261             LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
 262             int obj = find_property(&This->base.data_format, pdiph);
 263
 264             if (obj >= 0) {
 265                 pd->dwData = This->props[obj].lSaturation;
 266                 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
 267                 return DI_OK;
 268             }
 269             break;
 270         }
 271         default:
 272             return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
 273         }
 274     }
 275
 276     return DI_OK;
 277 }
 278
 279 /******************************************************************************
 280   *     GetDeviceInfo : get information about a device's identity
 281   */
 282 HRESULT WINAPI JoystickAGenericImpl_GetDeviceInfo(
 283     LPDIRECTINPUTDEVICE8A iface,
 284     LPDIDEVICEINSTANCEA pdidi)
 285 {
 286     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 287
 288     TRACE("(%p,%p)\n", iface, pdidi);
 289
 290     if (pdidi == NULL) {
 291         WARN("invalid pointer\n");
 292         return E_POINTER;
 293     }
 294
 295     if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
 296         (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
 297         WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
 298         return DIERR_INVALIDPARAM;
 299     }
 300
 301     /* Return joystick */
 302     pdidi->guidInstance = This->guidInstance;
 303     pdidi->guidProduct = This->guidProduct;
 304     /* we only support traditional joysticks for now */
 305     pdidi->dwDevType = This->devcaps.dwDevType;
 306     strcpy(pdidi->tszInstanceName, "Joystick");
 307     strcpy(pdidi->tszProductName, This->name);
 308     if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
 309         pdidi->guidFFDriver = GUID_NULL;
 310         pdidi->wUsagePage = 0;
 311         pdidi->wUsage = 0;
 312     }
 313
 314     return DI_OK;
 315 }
 316
 317 /******************************************************************************
 318   *     GetDeviceInfo : get information about a device's identity
 319   */
 320 HRESULT WINAPI JoystickWGenericImpl_GetDeviceInfo(
 321     LPDIRECTINPUTDEVICE8W iface,
 322     LPDIDEVICEINSTANCEW pdidi)
 323 {
 324     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 325
 326     TRACE("(%p,%p)\n", iface, pdidi);
 327
 328     if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
 329         (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
 330         WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
 331         return DIERR_INVALIDPARAM;
 332     }
 333
 334     /* Return joystick */
 335     pdidi->guidInstance = This->guidInstance;
 336     pdidi->guidProduct = This->guidProduct;
 337     /* we only support traditional joysticks for now */
 338     pdidi->dwDevType = This->devcaps.dwDevType;
 339     MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
 340     MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
 341     if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
 342         pdidi->guidFFDriver = GUID_NULL;
 343         pdidi->wUsagePage = 0;
 344         pdidi->wUsage = 0;
 345     }
 346
 347     return DI_OK;
 348 }
 349
 350 HRESULT WINAPI JoystickAGenericImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
 351 {
 352     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 353
 354     TRACE("(%p)\n",This);
 355
 356     if (!This->base.acquired) {
 357         WARN("not acquired\n");
 358         return DIERR_NOTACQUIRED;
 359     }
 360
 361     This->joy_polldev(This);
 362     return DI_OK;
 363 }
 364
 365 /******************************************************************************
 366   *     GetDeviceState : returns the "state" of the joystick.
 367   *
 368   */
 369 HRESULT WINAPI JoystickAGenericImpl_GetDeviceState(
 370     LPDIRECTINPUTDEVICE8A iface,
 371     DWORD len,
 372     LPVOID ptr)
 373 {
 374     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 375
 376     TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
 377
 378     if (!This->base.acquired) {
 379         WARN("not acquired\n");
 380         return DIERR_NOTACQUIRED;
 381     }
 382
 383     /* update joystick state */
 384     This->joy_polldev(This);
 385
 386     /* convert and copy data to user supplied buffer */
 387     fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
 388
 389     return DI_OK;
 390 }
 391
 392 /*
 393  * This maps the read value (from the input event) to a value in the
 394  * 'wanted' range.
 395  * Notes:
 396  *   Dead zone is in % multiplied by a 100 (range 0..10000)
 397  */
 398 LONG joystick_map_axis(ObjProps *props, int val)
 399 {
 400     LONG ret;
 401     LONG dead_zone = MulDiv( props->lDeadZone, props->lDevMax - props->lDevMin, 10000 );
 402     LONG dev_range = props->lDevMax - props->lDevMin - dead_zone;
 403
 404     /* Center input */
 405     val -= (props->lDevMin + props->lDevMax) / 2;
 406
 407     /* Remove dead zone */
 408     if (abs( val ) <= dead_zone / 2)
 409         val = 0;
 410     else
 411         val = val < 0 ? val + dead_zone / 2 : val - dead_zone / 2;
 412
 413     /* Scale and map the value from the device range into the required range */
 414     ret = MulDiv( val, props->lMax - props->lMin, dev_range ) +
 415           (props->lMin + props->lMax) / 2;
 416
 417     /* Clamp in case or rounding errors */
 418     if      (ret > props->lMax) ret = props->lMax;
 419     else if (ret < props->lMin) ret = props->lMin;
 420
 421     TRACE( "(%d <%d> %d) -> (%d <%d> %d): val=%d ret=%d\n",
 422            props->lDevMin, dead_zone, props->lDevMax,
 423            props->lMin, props->lDeadZone, props->lMax,
 424            val, ret );
 425
 426     return ret;
 427 }
 428
 429 /*
 430  * Maps POV x & y event values to a DX "clock" position:
 431  *         0
 432  *   31500    4500
 433  * 27000  -1    9000
 434  *   22500   13500
 435  *       18000
 436  */
 437 DWORD joystick_map_pov(POINTL *p)
 438 {
 439     if (p->x > 0)
 440         return p->y < 0 ?  4500 : !p->y ?  9000 : 13500;
 441     else if (p->x < 0)
 442         return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
 443     else
 444         return p->y < 0 ?     0 : !p->y ?    -1 : 18000;
 445 }
 446
 447 /*
 448  * Setup the dinput options.
 449  */
 450
 451 HRESULT setup_dinput_options(JoystickGenericImpl *This, const int *default_axis_map)
 452 {
 453     char buffer[MAX_PATH+16];
 454     HKEY hkey, appkey;
 455     int tokens = 0;
 456     int axis = 0;
 457     int pov = 0;
 458
 459     get_app_key(&hkey, &appkey);
 460
 461     /* get options */
 462
 463     if (!get_config_key(hkey, appkey, "DefaultDeadZone", buffer, sizeof(buffer)))
 464     {
 465         This->deadzone = atoi(buffer);
 466         TRACE("setting default deadzone to: \"%s\" %d\n", buffer, This->deadzone);
 467     }
 468
 469     This->axis_map = HeapAlloc(GetProcessHeap(), 0, This->device_axis_count * sizeof(int));
 470     if (!This->axis_map) return DIERR_OUTOFMEMORY;
 471
 472     if (!get_config_key(hkey, appkey, This->name, buffer, sizeof(buffer)))
 473     {
 474         static const char *axis_names[] = {"X", "Y", "Z", "Rx", "Ry", "Rz",
 475                                            "Slider1", "Slider2",
 476                                            "POV1", "POV2", "POV3", "POV4"};
 477         const char *delim = ",";
 478         char * ptr;
 479         TRACE("\"%s\" = \"%s\"\n", This->name, buffer);
 480
 481         if ((ptr = strtok(buffer, delim)) != NULL)
 482         {
 483             do
 484             {
 485                 int i;
 486
 487                 for (i = 0; i < sizeof(axis_names) / sizeof(axis_names[0]); i++)
 488                 {
 489                     if (!strcmp(ptr, axis_names[i]))
 490                     {
 491                         if (!strncmp(ptr, "POV", 3))
 492                         {
 493                             if (pov >= 4)
 494                             {
 495                                 WARN("Only 4 POVs supported - ignoring extra\n");
 496                                 i = -1;
 497                             }
 498                             else
 499                             {
 500                                 /* Pov takes two axes */
 501                                 This->axis_map[tokens++] = i;
 502                                 pov++;
 503                             }
 504                         }
 505                         else
 506                         {
 507                             if (axis >= 8)
 508                             {
 509                                 FIXME("Only 8 Axes supported - ignoring extra\n");
 510                                 i = -1;
 511                             }
 512                             else
 513                                 axis++;
 514                         }
 515                         break;
 516                     }
 517                 }
 518
 519                 if (i == sizeof(axis_names) / sizeof(axis_names[0]))
 520                 {
 521                     ERR("invalid joystick axis type: \"%s\"\n", ptr);
 522                     i = -1;
 523                 }
 524
 525                 This->axis_map[tokens] = i;
 526                 tokens++;
 527             } while ((ptr = strtok(NULL, delim)) != NULL);
 528
 529             if (tokens != This->device_axis_count)
 530             {
 531                 ERR("not all joystick axes mapped: %d axes(%d,%d), %d arguments\n",
 532                     This->device_axis_count, axis, pov, tokens);
 533                 while (tokens < This->device_axis_count)
 534                 {
 535                     This->axis_map[tokens] = -1;
 536                     tokens++;
 537                 }
 538             }
 539         }
 540     }
 541     else
 542     {
 543         int i;
 544
 545         if (default_axis_map)
 546         {
 547             /* Use default mapping from the driver */
 548             for (i = 0; i < This->device_axis_count; i++)
 549             {
 550                 This->axis_map[i] = default_axis_map[i];
 551                 tokens = default_axis_map[i];
 552                 if (tokens < 0)
 553                     continue;
 554                 if (tokens < 8)
 555                     axis++;
 556                 else if (tokens < 15)
 557                 {
 558                     i++;
 559                     pov++;
 560                     This->axis_map[i] = default_axis_map[i];
 561                 }
 562             }
 563         }
 564         else
 565         {
 566             /* No config - set default mapping. */
 567             for (i = 0; i < This->device_axis_count; i++)
 568             {
 569                 if (i < 8)
 570                     This->axis_map[i] = axis++;
 571                 else if (i < 15)
 572                 {
 573                     This->axis_map[i++] = 8 + pov;
 574                     This->axis_map[i  ] = 8 + pov++;
 575                 }
 576                 else
 577                     This->axis_map[i] = -1;
 578             }
 579         }
 580     }
 581     This->devcaps.dwAxes = axis;
 582     This->devcaps.dwPOVs = pov;
 583
 584     if (appkey) RegCloseKey(appkey);
 585     if (hkey)   RegCloseKey(hkey);
 586
 587     return DI_OK;
 588 }