dlls/xinput1_3/xinput_main.c

   1 /*
   2  * The Wine project - Xinput Joystick Library
   3  * Copyright 2008 Andrew Fenn
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include "wine/debug.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29
  30 #include "xinput.h"
  31 #include "xinput_private.h"
  32
  33 /* Not defined in the headers, used only by XInputGetStateEx */
  34 #define XINPUT_GAMEPAD_GUIDE 0x0400
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(xinput);
  37
  38 xinput_controller controllers[XUSER_MAX_COUNT];
  39
  40 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
  41 {
  42     switch(reason)
  43     {
  44         case DLL_PROCESS_ATTACH:
  45             DisableThreadLibraryCalls(inst);
  46             break;
  47         case DLL_PROCESS_DETACH:
  48             if (reserved) break;
  49             HID_destroy_gamepads(controllers);
  50             break;
  51     }
  52     return TRUE;
  53 }
  54
  55 void WINAPI DECLSPEC_HOTPATCH XInputEnable(BOOL enable)
  56 {
  57     int index;
  58
  59     TRACE("(enable %d)\n", enable);
  60
  61     /* Setting to false will stop messages from XInputSetState being sent
  62     to the controllers. Setting to true will send the last vibration
  63     value (sent to XInputSetState) to the controller and allow messages to
  64     be sent */
  65     HID_find_gamepads(controllers);
  66
  67     for (index = 0; index < XUSER_MAX_COUNT; index ++)
  68     {
  69         if (!controllers[index].connected) continue;
  70         HID_enable(&controllers[index], enable);
  71     }
  72 }
  73
  74 DWORD WINAPI XInputSetState(DWORD index, XINPUT_VIBRATION* vibration)
  75 {
  76     TRACE("(index %u, vibration %p)\n", index, vibration);
  77
  78     HID_find_gamepads(controllers);
  79
  80     if (index >= XUSER_MAX_COUNT)
  81         return ERROR_BAD_ARGUMENTS;
  82     if (!controllers[index].connected)
  83         return ERROR_DEVICE_NOT_CONNECTED;
  84
  85     return HID_set_state(&controllers[index], vibration);
  86 }
  87
  88 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetState(DWORD index, XINPUT_STATE* state)
  89 {
  90     DWORD ret;
  91
  92     TRACE("(index %u, state %p)!\n", index, state);
  93
  94     ret = XInputGetStateEx(index, state);
  95     if (ret != ERROR_SUCCESS)
  96         return ret;
  97
  98     /* The main difference between this and the Ex version is the media guide button */
  99     state->Gamepad.wButtons &= ~XINPUT_GAMEPAD_GUIDE;
 100
 101     return ERROR_SUCCESS;
 102 }
 103
 104 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetStateEx(DWORD index, XINPUT_STATE* state)
 105 {
 106     TRACE("(index %u, state %p)!\n", index, state);
 107
 108     HID_find_gamepads(controllers);
 109
 110     if (index >= XUSER_MAX_COUNT)
 111         return ERROR_BAD_ARGUMENTS;
 112     if (!controllers[index].connected)
 113         return ERROR_DEVICE_NOT_CONNECTED;
 114
 115     HID_update_state(&controllers[index]);
 116     memcpy(state, &controllers[index].state, sizeof(XINPUT_STATE));
 117
 118     return ERROR_SUCCESS;
 119 }
 120
 121 DWORD WINAPI XInputGetKeystroke(DWORD index, DWORD reserved, PXINPUT_KEYSTROKE keystroke)
 122 {
 123     static int warn_once;
 124
 125     if (!warn_once++)
 126         FIXME("(index %u, reserved %u, keystroke %p) Stub!\n", index, reserved, keystroke);
 127
 128     if (index >= XUSER_MAX_COUNT)
 129         return ERROR_BAD_ARGUMENTS;
 130     if (!controllers[index].connected)
 131         return ERROR_DEVICE_NOT_CONNECTED;
 132
 133     return ERROR_NOT_SUPPORTED;
 134 }
 135
 136 DWORD WINAPI XInputGetCapabilities(DWORD index, DWORD flags, XINPUT_CAPABILITIES* capabilities)
 137 {
 138     TRACE("(index %u, flags 0x%x, capabilities %p)\n", index, flags, capabilities);
 139
 140     HID_find_gamepads(controllers);
 141
 142     if (index >= XUSER_MAX_COUNT)
 143         return ERROR_BAD_ARGUMENTS;
 144     if (!controllers[index].connected)
 145         return ERROR_DEVICE_NOT_CONNECTED;
 146     if (flags & XINPUT_FLAG_GAMEPAD && controllers[index].caps.SubType != XINPUT_DEVSUBTYPE_GAMEPAD)
 147         return ERROR_DEVICE_NOT_CONNECTED;
 148
 149     memcpy(capabilities, &controllers[index].caps, sizeof(*capabilities));
 150
 151     return ERROR_SUCCESS;
 152 }
 153
 154 DWORD WINAPI XInputGetDSoundAudioDeviceGuids(DWORD index, GUID* render_guid, GUID* capture_guid)
 155 {
 156     FIXME("(index %u, render guid %p, capture guid %p) Stub!\n", index, render_guid, capture_guid);
 157
 158     if (index >= XUSER_MAX_COUNT)
 159         return ERROR_BAD_ARGUMENTS;
 160     if (!controllers[index].connected)
 161         return ERROR_DEVICE_NOT_CONNECTED;
 162
 163     return ERROR_NOT_SUPPORTED;
 164 }
 165
 166 DWORD WINAPI XInputGetBatteryInformation(DWORD index, BYTE type, XINPUT_BATTERY_INFORMATION* battery)
 167 {
 168     static int once;
 169
 170     if (!once++)
 171         FIXME("(index %u, type %u, battery %p) Stub!\n", index, type, battery);
 172
 173     if (index >= XUSER_MAX_COUNT)
 174         return ERROR_BAD_ARGUMENTS;
 175     if (!controllers[index].connected)
 176         return ERROR_DEVICE_NOT_CONNECTED;
 177
 178     return ERROR_NOT_SUPPORTED;
 179 }