reactos/dll/win32/winmm/joystick.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * joystick functions
   4  *
   5  * Copyright 1997 Andreas Mohr
   6  *           2000 Wolfgang Schwotzer
   7  *                Eric Pouech
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <config.h>
  25
  26 #ifdef HAVE_UNISTD_H
  27 # include <unistd.h>
  28 #endif
  29 //#include <stdarg.h>
  30 //#include <stdio.h>
  31 #include <stdlib.h>
  32 //#include <string.h>
  33 //#include <fcntl.h>
  34 #ifdef HAVE_SYS_IOCTL_H
  35 #include <sys/ioctl.h>
  36 #endif
  37
  38 #include "winemm.h"
  39 //#include "windef.h"
  40 //#include "winbase.h"
  41 //#include "mmsystem.h"
  42 //#include "wingdi.h"
  43 #include <winuser.h>
  44 #include <winnls.h>
  45
  46 //#include "mmddk.h"
  47
  48 #include <wine/debug.h>
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  51
  52 #define MAXJOYSTICK (JOYSTICKID2 + 30)
  53 #define JOY_PERIOD_MIN  (10)    /* min Capture time period */
  54 #define JOY_PERIOD_MAX  (1000)  /* max Capture time period */
  55
  56 typedef struct tagWINE_JOYSTICK {
  57     JOYINFO     ji;
  58     HWND        hCapture;
  59     UINT        wTimer;
  60     DWORD       threshold;
  61     BOOL        bChanged;
  62     HDRVR       hDriver;
  63 } WINE_JOYSTICK;
  64
  65 static  WINE_JOYSTICK   JOY_Sticks[MAXJOYSTICK];
  66
  67 /**************************************************************************
  68  *                              JOY_LoadDriver          [internal]
  69  */
  70 static  BOOL JOY_LoadDriver(DWORD dwJoyID)
  71 {
  72     if (dwJoyID >= MAXJOYSTICK)
  73         return FALSE;
  74     if (JOY_Sticks[dwJoyID].hDriver)
  75         return TRUE;
  76
  77     JOY_Sticks[dwJoyID].hDriver = OpenDriverA("winejoystick.drv", 0, dwJoyID);
  78     return (JOY_Sticks[dwJoyID].hDriver != 0);
  79 }
  80
  81 /**************************************************************************
  82  *                              JOY_Timer               [internal]
  83  */
  84 static  void    CALLBACK        JOY_Timer(HWND hWnd, UINT wMsg, UINT_PTR wTimer, DWORD dwTime)
  85 {
  86     int                 i;
  87     WINE_JOYSTICK*      joy;
  88     JOYINFO             ji;
  89     LONG                pos;
  90     unsigned            buttonChange;
  91
  92     for (i = 0; i < MAXJOYSTICK; i++) {
  93         joy = &JOY_Sticks[i];
  94
  95         if (joy->hCapture != hWnd) continue;
  96
  97         joyGetPos(i, &ji);
  98         pos = MAKELONG(ji.wXpos, ji.wYpos);
  99
 100         if (!joy->bChanged ||
 101             abs(joy->ji.wXpos - ji.wXpos) > joy->threshold ||
 102             abs(joy->ji.wYpos - ji.wYpos) > joy->threshold) {
 103             SendMessageA(joy->hCapture, MM_JOY1MOVE + i, ji.wButtons, pos);
 104             joy->ji.wXpos = ji.wXpos;
 105             joy->ji.wYpos = ji.wYpos;
 106         }
 107         if (!joy->bChanged ||
 108             abs(joy->ji.wZpos - ji.wZpos) > joy->threshold) {
 109             SendMessageA(joy->hCapture, MM_JOY1ZMOVE + i, ji.wButtons, pos);
 110             joy->ji.wZpos = ji.wZpos;
 111         }
 112         if ((buttonChange = joy->ji.wButtons ^ ji.wButtons) != 0) {
 113             if (ji.wButtons & buttonChange)
 114                 SendMessageA(joy->hCapture, MM_JOY1BUTTONDOWN + i,
 115                              (buttonChange << 8) | (ji.wButtons & buttonChange), pos);
 116             if (joy->ji.wButtons & buttonChange)
 117                 SendMessageA(joy->hCapture, MM_JOY1BUTTONUP + i,
 118                              (buttonChange << 8) | (joy->ji.wButtons & buttonChange), pos);
 119             joy->ji.wButtons = ji.wButtons;
 120         }
 121     }
 122 }
 123
 124 /**************************************************************************
 125  *                              joyConfigChanged        [WINMM.@]
 126  */
 127 MMRESULT WINAPI joyConfigChanged(DWORD flags)
 128 {
 129     FIXME("(%x) - stub\n", flags);
 130
 131     if (flags)
 132         return JOYERR_PARMS;
 133
 134     return JOYERR_NOERROR;
 135 }
 136
 137 /**************************************************************************
 138  *                              joyGetNumDevs           [WINMM.@]
 139  */
 140 UINT WINAPI joyGetNumDevs(void)
 141 {
 142     UINT        ret = 0;
 143     int         i;
 144
 145     for (i = 0; i < MAXJOYSTICK; i++) {
 146         if (JOY_LoadDriver(i)) {
 147             ret += SendDriverMessage(JOY_Sticks[i].hDriver, JDD_GETNUMDEVS, 0, 0);
 148         }
 149     }
 150     return ret;
 151 }
 152
 153 /**************************************************************************
 154  *                              joyGetDevCapsW          [WINMM.@]
 155  */
 156 MMRESULT WINAPI joyGetDevCapsW(UINT_PTR wID, LPJOYCAPSW lpCaps, UINT wSize)
 157 {
 158     if (wID >= MAXJOYSTICK)     return JOYERR_PARMS;
 159     if (!JOY_LoadDriver(wID))   return MMSYSERR_NODRIVER;
 160
 161     lpCaps->wPeriodMin = JOY_PERIOD_MIN; /* FIXME */
 162     lpCaps->wPeriodMax = JOY_PERIOD_MAX; /* FIXME (same as MS Joystick Driver) */
 163
 164     return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETDEVCAPS, (LPARAM)lpCaps, wSize);
 165 }
 166
 167 /**************************************************************************
 168  *                              joyGetDevCapsA          [WINMM.@]
 169  */
 170 MMRESULT WINAPI joyGetDevCapsA(UINT_PTR wID, LPJOYCAPSA lpCaps, UINT wSize)
 171 {
 172     JOYCAPSW    jcw;
 173     MMRESULT    ret;
 174
 175     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
 176
 177     ret = joyGetDevCapsW(wID, &jcw, sizeof(jcw));
 178
 179     if (ret == JOYERR_NOERROR)
 180     {
 181         lpCaps->wMid = jcw.wMid;
 182         lpCaps->wPid = jcw.wPid;
 183         WideCharToMultiByte( CP_ACP, 0, jcw.szPname, -1, lpCaps->szPname,
 184                              sizeof(lpCaps->szPname), NULL, NULL );
 185         lpCaps->wXmin = jcw.wXmin;
 186         lpCaps->wXmax = jcw.wXmax;
 187         lpCaps->wYmin = jcw.wYmin;
 188         lpCaps->wYmax = jcw.wYmax;
 189         lpCaps->wZmin = jcw.wZmin;
 190         lpCaps->wZmax = jcw.wZmax;
 191         lpCaps->wNumButtons = jcw.wNumButtons;
 192         lpCaps->wPeriodMin = jcw.wPeriodMin;
 193         lpCaps->wPeriodMax = jcw.wPeriodMax;
 194
 195         if (wSize >= sizeof(JOYCAPSA)) { /* Win95 extensions ? */
 196             lpCaps->wRmin = jcw.wRmin;
 197             lpCaps->wRmax = jcw.wRmax;
 198             lpCaps->wUmin = jcw.wUmin;
 199             lpCaps->wUmax = jcw.wUmax;
 200             lpCaps->wVmin = jcw.wVmin;
 201             lpCaps->wVmax = jcw.wVmax;
 202             lpCaps->wCaps = jcw.wCaps;
 203             lpCaps->wMaxAxes = jcw.wMaxAxes;
 204             lpCaps->wNumAxes = jcw.wNumAxes;
 205             lpCaps->wMaxButtons = jcw.wMaxButtons;
 206             WideCharToMultiByte( CP_ACP, 0, jcw.szRegKey, -1, lpCaps->szRegKey,
 207                                  sizeof(lpCaps->szRegKey), NULL, NULL );
 208             WideCharToMultiByte( CP_ACP, 0, jcw.szOEMVxD, -1, lpCaps->szOEMVxD,
 209                                  sizeof(lpCaps->szOEMVxD), NULL, NULL );
 210         }
 211     }
 212
 213     return ret;
 214 }
 215
 216 /**************************************************************************
 217  *                              joyGetPosEx             [WINMM.@]
 218  */
 219 MMRESULT WINAPI joyGetPosEx(UINT wID, LPJOYINFOEX lpInfo)
 220 {
 221     TRACE("(%d, %p);\n", wID, lpInfo);
 222
 223     if (wID >= MAXJOYSTICK)     return JOYERR_PARMS;
 224     if (!JOY_LoadDriver(wID))   return MMSYSERR_NODRIVER;
 225
 226     lpInfo->dwXpos = 0;
 227     lpInfo->dwYpos = 0;
 228     lpInfo->dwZpos = 0;
 229     lpInfo->dwRpos = 0;
 230     lpInfo->dwUpos = 0;
 231     lpInfo->dwVpos = 0;
 232     lpInfo->dwButtons = 0;
 233     lpInfo->dwButtonNumber = 0;
 234     lpInfo->dwPOV = 0;
 235     lpInfo->dwReserved1 = 0;
 236     lpInfo->dwReserved2 = 0;
 237
 238     return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOSEX, (LPARAM)lpInfo, 0);
 239 }
 240
 241 /**************************************************************************
 242  *                              joyGetPos               [WINMM.@]
 243  */
 244 MMRESULT WINAPI joyGetPos(UINT wID, LPJOYINFO lpInfo)
 245 {
 246     TRACE("(%d, %p);\n", wID, lpInfo);
 247
 248     if (wID >= MAXJOYSTICK)     return JOYERR_PARMS;
 249     if (!JOY_LoadDriver(wID))   return MMSYSERR_NODRIVER;
 250
 251     lpInfo->wXpos = 0;
 252     lpInfo->wYpos = 0;
 253     lpInfo->wZpos = 0;
 254     lpInfo->wButtons = 0;
 255
 256     return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOS, (LPARAM)lpInfo, 0);
 257 }
 258
 259 /**************************************************************************
 260  *                              joyGetThreshold         [WINMM.@]
 261  */
 262 MMRESULT WINAPI joyGetThreshold(UINT wID, LPUINT lpThreshold)
 263 {
 264     TRACE("(%04X, %p);\n", wID, lpThreshold);
 265
 266     if (wID >= MAXJOYSTICK)     return JOYERR_PARMS;
 267
 268     *lpThreshold = JOY_Sticks[wID].threshold;
 269     return JOYERR_NOERROR;
 270 }
 271
 272 /**************************************************************************
 273  *                              joyReleaseCapture       [WINMM.@]
 274  */
 275 MMRESULT WINAPI joyReleaseCapture(UINT wID)
 276 {
 277     TRACE("(%04X);\n", wID);
 278
 279     if (wID >= MAXJOYSTICK)             return JOYERR_PARMS;
 280     if (!JOY_LoadDriver(wID))           return MMSYSERR_NODRIVER;
 281     if (!JOY_Sticks[wID].hCapture)      return JOYERR_NOCANDO;
 282
 283     KillTimer(JOY_Sticks[wID].hCapture, JOY_Sticks[wID].wTimer);
 284     JOY_Sticks[wID].hCapture = 0;
 285     JOY_Sticks[wID].wTimer = 0;
 286
 287     return JOYERR_NOERROR;
 288 }
 289
 290 /**************************************************************************
 291  *                              joySetCapture           [WINMM.@]
 292  */
 293 MMRESULT WINAPI joySetCapture(HWND hWnd, UINT wID, UINT wPeriod, BOOL bChanged)
 294 {
 295     TRACE("(%p, %04X, %d, %d);\n",  hWnd, wID, wPeriod, bChanged);
 296
 297     if (wID >= MAXJOYSTICK || hWnd == 0) return JOYERR_PARMS;
 298     if (wPeriod<JOY_PERIOD_MIN || wPeriod>JOY_PERIOD_MAX) return JOYERR_PARMS;
 299     if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
 300
 301     if (JOY_Sticks[wID].hCapture || !IsWindow(hWnd))
 302         return JOYERR_NOCANDO; /* FIXME: what should be returned ? */
 303
 304     if (joyGetPos(wID, &JOY_Sticks[wID].ji) != JOYERR_NOERROR)
 305         return JOYERR_UNPLUGGED;
 306
 307     if ((JOY_Sticks[wID].wTimer = SetTimer(hWnd, 0, wPeriod, JOY_Timer)) == 0)
 308         return JOYERR_NOCANDO;
 309
 310     JOY_Sticks[wID].hCapture = hWnd;
 311     JOY_Sticks[wID].bChanged = bChanged;
 312
 313     return JOYERR_NOERROR;
 314 }
 315
 316 /**************************************************************************
 317  *                              joySetThreshold         [WINMM.@]
 318  */
 319 MMRESULT WINAPI joySetThreshold(UINT wID, UINT wThreshold)
 320 {
 321     TRACE("(%04X, %d);\n", wID, wThreshold);
 322
 323     if (wID >= MAXJOYSTICK) return MMSYSERR_INVALPARAM;
 324
 325     JOY_Sticks[wID].threshold = wThreshold;
 326
 327     return JOYERR_NOERROR;
 328 }