git.oblomov.eu Git - wine/blob - dlls/dinput/joystick.c

   1 /*  DirectInput Generic Joystick device
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998,1999 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  * Copyright 2009 Aric Stewart, CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 /*
  24  * To Do:
  25  *      dead zone
  26  *      force feedback
  27  */
  28
  29 #include "joystick_private.h"
  30 #include "wine/debug.h"
  31
  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 }