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
  32 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  33
  34 /******************************************************************************
  35   *     SetProperty : change input device properties
  36   */
  37 HRESULT WINAPI JoystickAGenericImpl_SetProperty(
  38     LPDIRECTINPUTDEVICE8A iface,
  39     REFGUID rguid,
  40     LPCDIPROPHEADER ph)
  41 {
  42     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
  43     DWORD i;
  44
  45     TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
  46
  47     if (ph == NULL) {
  48         WARN("invalid parameter: ph == NULL\n");
  49         return DIERR_INVALIDPARAM;
  50     }
  51
  52     if (TRACE_ON(dinput))
  53         _dump_DIPROPHEADER(ph);
  54
  55     if (!HIWORD(rguid)) {
  56         switch (LOWORD(rguid)) {
  57         case (DWORD_PTR)DIPROP_RANGE: {
  58             LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
  59             if (ph->dwHow == DIPH_DEVICE) {
  60                 TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
  61                 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
  62                     This->props[i].lMin = pr->lMin;
  63                     This->props[i].lMax = pr->lMax;
  64                 }
  65             } else {
  66                 int obj = find_property(&This->base.data_format, ph);
  67
  68                 TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
  69                 if (obj >= 0) {
  70                     This->props[obj].lMin = pr->lMin;
  71                     This->props[obj].lMax = pr->lMax;
  72                     return DI_OK;
  73                 }
  74             }
  75             break;
  76         }
  77         case (DWORD_PTR)DIPROP_DEADZONE: {
  78             LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
  79             if (ph->dwHow == DIPH_DEVICE) {
  80                 TRACE("deadzone(%d) all\n", pd->dwData);
  81                 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
  82                     This->props[i].lDeadZone  = pd->dwData;
  83             } else {
  84                 int obj = find_property(&This->base.data_format, ph);
  85
  86                 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
  87                 if (obj >= 0) {
  88                     This->props[obj].lDeadZone  = pd->dwData;
  89                     return DI_OK;
  90                 }
  91             }
  92             break;
  93         }
  94         case (DWORD_PTR)DIPROP_SATURATION: {
  95             LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
  96             if (ph->dwHow == DIPH_DEVICE) {
  97                 TRACE("saturation(%d) all\n", pd->dwData);
  98                 for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
  99                     This->props[i].lSaturation = pd->dwData;
 100             } else {
 101                 int obj = find_property(&This->base.data_format, ph);
 102
 103                 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
 104                 if (obj >= 0) {
 105                     This->props[obj].lSaturation = pd->dwData;
 106                     return DI_OK;
 107                 }
 108             }
 109             break;
 110         }
 111         default:
 112             return IDirectInputDevice2AImpl_SetProperty(iface, rguid, ph);
 113         }
 114     }
 115
 116     return DI_OK;
 117 }
 118
 119 void _dump_DIDEVCAPS(const DIDEVCAPS *lpDIDevCaps)
 120 {
 121     TRACE("dwSize: %d\n", lpDIDevCaps->dwSize);
 122     TRACE("dwFlags: %08x\n", lpDIDevCaps->dwFlags);
 123     TRACE("dwDevType: %08x %s\n", lpDIDevCaps->dwDevType,
 124           lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
 125           lpDIDevCaps->dwDevType == DIDEVTYPE_DEVICE ? "DIDEVTYPE_DEVICE" :
 126           lpDIDevCaps->dwDevType == DIDEVTYPE_MOUSE ? "DIDEVTYPE_MOUSE" :
 127           lpDIDevCaps->dwDevType == DIDEVTYPE_KEYBOARD ? "DIDEVTYPE_KEYBOARD" :
 128           lpDIDevCaps->dwDevType == DIDEVTYPE_JOYSTICK ? "DIDEVTYPE_JOYSTICK" :
 129           lpDIDevCaps->dwDevType == DIDEVTYPE_HID ? "DIDEVTYPE_HID" : "UNKNOWN");
 130     TRACE("dwAxes: %d\n", lpDIDevCaps->dwAxes);
 131     TRACE("dwButtons: %d\n", lpDIDevCaps->dwButtons);
 132     TRACE("dwPOVs: %d\n", lpDIDevCaps->dwPOVs);
 133     if (lpDIDevCaps->dwSize > sizeof(DIDEVCAPS_DX3)) {
 134         TRACE("dwFFSamplePeriod: %d\n", lpDIDevCaps->dwFFSamplePeriod);
 135         TRACE("dwFFMinTimeResolution: %d\n", lpDIDevCaps->dwFFMinTimeResolution);
 136         TRACE("dwFirmwareRevision: %d\n", lpDIDevCaps->dwFirmwareRevision);
 137         TRACE("dwHardwareRevision: %d\n", lpDIDevCaps->dwHardwareRevision);
 138         TRACE("dwFFDriverVersion: %d\n", lpDIDevCaps->dwFFDriverVersion);
 139     }
 140 }
 141
 142 HRESULT WINAPI JoystickAGenericImpl_GetCapabilities(
 143         LPDIRECTINPUTDEVICE8A iface,
 144         LPDIDEVCAPS lpDIDevCaps)
 145 {
 146     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 147     int size;
 148
 149     TRACE("%p->(%p)\n",iface,lpDIDevCaps);
 150
 151     if (lpDIDevCaps == NULL) {
 152         WARN("invalid pointer\n");
 153         return E_POINTER;
 154     }
 155
 156     size = lpDIDevCaps->dwSize;
 157
 158     if (!(size == sizeof(DIDEVCAPS) || size == sizeof(DIDEVCAPS_DX3))) {
 159         WARN("invalid parameter\n");
 160         return DIERR_INVALIDPARAM;
 161     }
 162
 163     CopyMemory(lpDIDevCaps, &This->devcaps, size);
 164     lpDIDevCaps->dwSize = size;
 165
 166     if (TRACE_ON(dinput))
 167         _dump_DIDEVCAPS(lpDIDevCaps);
 168
 169     return DI_OK;
 170 }
 171
 172 /******************************************************************************
 173   *     GetObjectInfo : get object info
 174   */
 175 HRESULT WINAPI JoystickWGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8W iface,
 176         LPDIDEVICEOBJECTINSTANCEW pdidoi, DWORD dwObj, DWORD dwHow)
 177 {
 178     static const WCHAR axisW[] = {'A','x','i','s',' ','%','d',0};
 179     static const WCHAR povW[] = {'P','O','V',' ','%','d',0};
 180     static const WCHAR buttonW[] = {'B','u','t','t','o','n',' ','%','d',0};
 181     HRESULT res;
 182
 183     res = IDirectInputDevice2WImpl_GetObjectInfo(iface, pdidoi, dwObj, dwHow);
 184     if (res != DI_OK) return res;
 185
 186     if      (pdidoi->dwType & DIDFT_AXIS)
 187         sprintfW(pdidoi->tszName, axisW, DIDFT_GETINSTANCE(pdidoi->dwType));
 188     else if (pdidoi->dwType & DIDFT_POV)
 189         sprintfW(pdidoi->tszName, povW, DIDFT_GETINSTANCE(pdidoi->dwType));
 190     else if (pdidoi->dwType & DIDFT_BUTTON)
 191         sprintfW(pdidoi->tszName, buttonW, DIDFT_GETINSTANCE(pdidoi->dwType));
 192
 193     _dump_OBJECTINSTANCEW(pdidoi);
 194     return res;
 195 }
 196
 197 HRESULT WINAPI JoystickAGenericImpl_GetObjectInfo(LPDIRECTINPUTDEVICE8A iface,
 198         LPDIDEVICEOBJECTINSTANCEA pdidoi, DWORD dwObj, DWORD dwHow)
 199 {
 200     HRESULT res;
 201     DIDEVICEOBJECTINSTANCEW didoiW;
 202     DWORD dwSize = pdidoi->dwSize;
 203
 204     didoiW.dwSize = sizeof(didoiW);
 205     res = JoystickWGenericImpl_GetObjectInfo((LPDIRECTINPUTDEVICE8W)iface, &didoiW, dwObj, dwHow);
 206     if (res != DI_OK) return res;
 207
 208     memset(pdidoi, 0, pdidoi->dwSize);
 209     memcpy(pdidoi, &didoiW, FIELD_OFFSET(DIDEVICEOBJECTINSTANCEW, tszName));
 210     pdidoi->dwSize = dwSize;
 211     WideCharToMultiByte(CP_ACP, 0, didoiW.tszName, -1, pdidoi->tszName,
 212                         sizeof(pdidoi->tszName), NULL, NULL);
 213
 214     return res;
 215 }
 216
 217 /******************************************************************************
 218   *     GetProperty : get input device properties
 219   */
 220 HRESULT WINAPI JoystickAGenericImpl_GetProperty(
 221     LPDIRECTINPUTDEVICE8A iface,
 222     REFGUID rguid,
 223     LPDIPROPHEADER pdiph)
 224 {
 225     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 226
 227     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
 228
 229     if (TRACE_ON(dinput))
 230         _dump_DIPROPHEADER(pdiph);
 231
 232     if (!HIWORD(rguid)) {
 233         switch (LOWORD(rguid)) {
 234         case (DWORD_PTR) DIPROP_RANGE: {
 235             LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
 236             int obj = find_property(&This->base.data_format, pdiph);
 237
 238             /* The app is querying the current range of the axis
 239              * return the lMin and lMax values */
 240             if (obj >= 0) {
 241                 pr->lMin = This->props[obj].lMin;
 242                 pr->lMax = This->props[obj].lMax;
 243                 TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
 244                 return DI_OK;
 245             }
 246             break;
 247         }
 248         case (DWORD_PTR) DIPROP_DEADZONE: {
 249             LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
 250             int obj = find_property(&This->base.data_format, pdiph);
 251
 252             if (obj >= 0) {
 253                 pd->dwData = This->props[obj].lDeadZone;
 254                 TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
 255                 return DI_OK;
 256             }
 257             break;
 258         }
 259         case (DWORD_PTR) DIPROP_SATURATION: {
 260             LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
 261             int obj = find_property(&This->base.data_format, pdiph);
 262
 263             if (obj >= 0) {
 264                 pd->dwData = This->props[obj].lSaturation;
 265                 TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
 266                 return DI_OK;
 267             }
 268             break;
 269         }
 270         default:
 271             return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
 272         }
 273     }
 274
 275     return DI_OK;
 276 }
 277
 278 /******************************************************************************
 279   *     GetDeviceInfo : get information about a device's identity
 280   */
 281 HRESULT WINAPI JoystickAGenericImpl_GetDeviceInfo(
 282     LPDIRECTINPUTDEVICE8A iface,
 283     LPDIDEVICEINSTANCEA pdidi)
 284 {
 285     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 286
 287     TRACE("(%p,%p)\n", iface, pdidi);
 288
 289     if (pdidi == NULL) {
 290         WARN("invalid pointer\n");
 291         return E_POINTER;
 292     }
 293
 294     if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3A)) &&
 295         (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA))) {
 296         WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
 297         return DIERR_INVALIDPARAM;
 298     }
 299
 300     /* Return joystick */
 301     pdidi->guidInstance = This->guidInstance;
 302     pdidi->guidProduct = This->guidProduct;
 303     /* we only support traditional joysticks for now */
 304     pdidi->dwDevType = This->devcaps.dwDevType;
 305     strcpy(pdidi->tszInstanceName, "Joystick");
 306     strcpy(pdidi->tszProductName, This->name);
 307     if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3A)) {
 308         pdidi->guidFFDriver = GUID_NULL;
 309         pdidi->wUsagePage = 0;
 310         pdidi->wUsage = 0;
 311     }
 312
 313     return DI_OK;
 314 }
 315
 316 /******************************************************************************
 317   *     GetDeviceInfo : get information about a device's identity
 318   */
 319 HRESULT WINAPI JoystickWGenericImpl_GetDeviceInfo(
 320     LPDIRECTINPUTDEVICE8W iface,
 321     LPDIDEVICEINSTANCEW pdidi)
 322 {
 323     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 324
 325     TRACE("(%p,%p)\n", iface, pdidi);
 326
 327     if ((pdidi->dwSize != sizeof(DIDEVICEINSTANCE_DX3W)) &&
 328         (pdidi->dwSize != sizeof(DIDEVICEINSTANCEW))) {
 329         WARN("invalid parameter: pdidi->dwSize = %d\n", pdidi->dwSize);
 330         return DIERR_INVALIDPARAM;
 331     }
 332
 333     /* Return joystick */
 334     pdidi->guidInstance = This->guidInstance;
 335     pdidi->guidProduct = This->guidProduct;
 336     /* we only support traditional joysticks for now */
 337     pdidi->dwDevType = This->devcaps.dwDevType;
 338     MultiByteToWideChar(CP_ACP, 0, "Joystick", -1, pdidi->tszInstanceName, MAX_PATH);
 339     MultiByteToWideChar(CP_ACP, 0, This->name, -1, pdidi->tszProductName, MAX_PATH);
 340     if (pdidi->dwSize > sizeof(DIDEVICEINSTANCE_DX3W)) {
 341         pdidi->guidFFDriver = GUID_NULL;
 342         pdidi->wUsagePage = 0;
 343         pdidi->wUsage = 0;
 344     }
 345
 346     return DI_OK;
 347 }
 348
 349 HRESULT WINAPI JoystickAGenericImpl_Poll(LPDIRECTINPUTDEVICE8A iface)
 350 {
 351     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 352
 353     TRACE("(%p)\n",This);
 354
 355     if (!This->base.acquired) {
 356         WARN("not acquired\n");
 357         return DIERR_NOTACQUIRED;
 358     }
 359
 360     This->joy_polldev(This);
 361     return DI_OK;
 362 }
 363
 364 /******************************************************************************
 365   *     GetDeviceState : returns the "state" of the joystick.
 366   *
 367   */
 368 HRESULT WINAPI JoystickAGenericImpl_GetDeviceState(
 369     LPDIRECTINPUTDEVICE8A iface,
 370     DWORD len,
 371     LPVOID ptr)
 372 {
 373     JoystickGenericImpl *This = (JoystickGenericImpl *)iface;
 374
 375     TRACE("(%p,0x%08x,%p)\n", This, len, ptr);
 376
 377     if (!This->base.acquired) {
 378         WARN("not acquired\n");
 379         return DIERR_NOTACQUIRED;
 380     }
 381
 382     /* update joystick state */
 383     This->joy_polldev(This);
 384
 385     /* convert and copy data to user supplied buffer */
 386     fill_DataFormat(ptr, len, &This->js, &This->base.data_format);
 387
 388     return DI_OK;
 389 }
 390
 391 /*
 392  * This maps the read value (from the input event) to a value in the
 393  * 'wanted' range.
 394  * Notes:
 395  *   Dead zone is in % multiplied by a 100 (range 0..10000)
 396  */
 397 LONG joystick_map_axis(ObjProps *props, int val)
 398 {
 399     LONG ret;
 400     LONG dead_zone = MulDiv( props->lDeadZone, props->lDevMax - props->lDevMin, 10000 );
 401     LONG dev_range = props->lDevMax - props->lDevMin - dead_zone;
 402
 403     /* Center input */
 404     val -= (props->lDevMin + props->lDevMax) / 2;
 405
 406     /* Remove dead zone */
 407     if (abs( val ) <= dead_zone / 2)
 408         val = 0;
 409     else
 410         val = val < 0 ? val + dead_zone / 2 : val - dead_zone / 2;
 411
 412     /* Scale and map the value from the device range into the required range */
 413     ret = MulDiv( val, props->lMax - props->lMin, dev_range ) +
 414           (props->lMin + props->lMax) / 2;
 415
 416     /* Clamp in case or rounding errors */
 417     if      (ret > props->lMax) ret = props->lMax;
 418     else if (ret < props->lMin) ret = props->lMin;
 419
 420     TRACE( "(%d <%d> %d) -> (%d <%d> %d): val=%d ret=%d\n",
 421            props->lDevMin, dead_zone, props->lDevMax,
 422            props->lMin, props->lDeadZone, props->lMax,
 423            val, ret );
 424
 425     return ret;
 426 }
 427
 428 /*
 429  * Maps POV x & y event values to a DX "clock" position:
 430  *         0
 431  *   31500    4500
 432  * 27000  -1    9000
 433  *   22500   13500
 434  *       18000
 435  */
 436 DWORD joystick_map_pov(POINTL *p)
 437 {
 438     if (p->x > 0)
 439         return p->y < 0 ?  4500 : !p->y ?  9000 : 13500;
 440     else if (p->x < 0)
 441         return p->y < 0 ? 31500 : !p->y ? 27000 : 22500;
 442     else
 443         return p->y < 0 ?     0 : !p->y ?    -1 : 18000;
 444 }