static void test_EnumDevices(void)
{
IDirectInput8A *pDI;
HRESULT hr;
struct enum_devices_test enum_test, enum_test_return;
hr = DirectInput8Create(hInstance, DIRECTINPUT_VERSION, &IID_IDirectInput8A, (void **)&pDI, NULL);
if (FAILED(hr))
{
win_skip("Failed to instantiate a IDirectInputA instance: 0x%08x\n", hr);
return;
}
hr = IDirectInput8_EnumDevices(pDI, 0, NULL, NULL, 0);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
hr = IDirectInput8_EnumDevices(pDI, 0, NULL, NULL, ~0u);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
/* Test crashes on Wine. */
if (0)
{
hr = IDirectInput8_EnumDevices(pDI, 0, enum_devices_callback, NULL, ~0u);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
}
hr = IDirectInput8_EnumDevices(pDI, 0xdeadbeef, NULL, NULL, 0);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
hr = IDirectInput8_EnumDevices(pDI, 0xdeadbeef, NULL, NULL, ~0u);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
hr = IDirectInput8_EnumDevices(pDI, 0xdeadbeef, enum_devices_callback, NULL, 0);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
hr = IDirectInput8_EnumDevices(pDI, 0xdeadbeef, enum_devices_callback, NULL, ~0u);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
enum_test.device_count = 0;
enum_test.return_value = DIENUM_CONTINUE;
hr = IDirectInput8_EnumDevices(pDI, 0, enum_devices_callback, &enum_test, 0);
ok(hr == DI_OK, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
ok(enum_test.device_count != 0, "Device count is %u\n", enum_test.device_count);
/* Enumeration only stops with an explicit DIENUM_STOP. */
enum_test_return.device_count = 0;
enum_test_return.return_value = 42;
hr = IDirectInput8_EnumDevices(pDI, 0, enum_devices_callback, &enum_test_return, 0);
ok(hr == DI_OK, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
ok(enum_test_return.device_count == enum_test.device_count,
"Device count is %u vs. %u\n", enum_test_return.device_count, enum_test.device_count);
enum_test.device_count = 0;
enum_test.return_value = DIENUM_STOP;
hr = IDirectInput8_EnumDevices(pDI, 0, enum_devices_callback, &enum_test, 0);
ok(hr == DI_OK, "IDirectInput8_EnumDevices returned 0x%08x\n", hr);
ok(enum_test.device_count == 1, "Device count is %u\n", enum_test.device_count);
IDirectInput8_Release(pDI);
}
void PERDXListDevices(HWND control, int emulatetype)
{
LPDIRECTINPUT8 lpDI8temp = NULL;
if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8temp, NULL)))
return;
numguids = 0;
SendMessage(control, CB_RESETCONTENT, 0, 0);
SendMessage(control, CB_ADDSTRING, 0, (LPARAM)_16("None"));
switch(emulatetype)
{
case EMUTYPE_STANDARDPAD:
case EMUTYPE_ANALOGPAD:
IDirectInput8_EnumDevices(lpDI8temp, DI8DEVCLASS_ALL, EnumPeripheralsCallbackGamepad,
(LPVOID)control, DIEDFL_ATTACHEDONLY);
break;
case EMUTYPE_STUNNER:
case EMUTYPE_MOUSE:
IDirectInput8_EnumDevices(lpDI8temp, DI8DEVCLASS_ALL, EnumPeripheralsCallbackMouse,
(LPVOID)control, DIEDFL_ATTACHEDONLY);
break;
case EMUTYPE_KEYBOARD:
IDirectInput8_EnumDevices(lpDI8temp, DI8DEVCLASS_ALL, EnumPeripheralsCallbackKeyboard,
(LPVOID)control, DIEDFL_ATTACHEDONLY);
break;
default: break;
}
IDirectInput8_Release(lpDI8temp);
}
/***********************************************************************
* initialize_joysticks [internal]
*/
static void initialize_joysticks(struct JoystickData *data)
{
data->num_joysticks = 0;
data->cur_joystick = 0;
IDirectInput8_EnumDevices(data->di, DI8DEVCLASS_GAMECTRL, enum_callback, data, DIEDFL_ATTACHEDONLY);
data->joysticks = HeapAlloc(GetProcessHeap(), 0, sizeof(struct Joystick) * data->num_joysticks);
/* Get all the joysticks */
IDirectInput8_EnumDevices(data->di, DI8DEVCLASS_GAMECTRL, enum_callback, data, DIEDFL_ATTACHEDONLY);
}
static bool joydx_scan(bool configure)
{
HRESULT hr;
unsigned i;
/* Clear mark bits. */
for (i = 0; i < MAX_JOYSTICKS; i++)
joydx_joystick[i].marked = false;
/* enumerate the joysticks attached to the system */
hr = IDirectInput8_EnumDevices(joystick_dinput, DI8DEVCLASS_GAMECTRL,
joystick_enum_callback, NULL, DIEDFL_ATTACHEDONLY);
if (FAILED(hr)) {
/* XXX will this ruin everything? */
IDirectInput8_Release(joystick_dinput);
joystick_dinput = NULL;
return false;
}
/* Schedule unmarked structures to be inactivated. */
for (i = 0; i < MAX_JOYSTICKS; i++) {
ALLEGRO_JOYSTICK_DIRECTX *joy = &joydx_joystick[i];
if (joy->config_state == STATE_ALIVE && !joy->marked) {
ALLEGRO_DEBUG("Joystick %s to be inactivated\n", joydx_guid_string(joy));
joy->config_state = STATE_DYING;
config_needs_merging = true;
}
}
if (config_needs_merging && configure)
joydx_generate_configure_event();
return config_needs_merging;
}
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrev, LPSTR szCmdLine, int nShow)
{
/* Structure with the data and settings for the application */
/* data is: hwnd, lpdi, joy[], num_joy, cur_joy, chosen_joy, poll_time, axes_max, axes_min, buffered */
struct JoystickData data = { NULL, NULL, NULL, 0, 0, 0, 0, 1000, -1000, FALSE };
HRESULT hr;
hr = DirectInput8Create(GetModuleHandleA(NULL), DIRECTINPUT_VERSION, &IID_IDirectInput8A, (void**) &data.di, NULL);
if (FAILED(hr))
{
printf("Failed to initialize DirectInput: 0x%08x\n", hr);
return 1;
}
/* First count how many joysticks are there */
hr = IDirectInput8_EnumDevices(data.di, DI8DEVCLASS_GAMECTRL, EnumCallback, &data, DIEDFL_FORCEFEEDBACK);
data.joysticks = malloc(sizeof(struct Joystick) * data.num_joysticks);
/* Get all the joysticks */
hr = IDirectInput8_EnumDevices(data.di, DI8DEVCLASS_GAMECTRL, EnumCallback, &data, DIEDFL_FORCEFEEDBACK);
printf("Found %d force feedback enabled joysticks.\n", data.num_joysticks);
/* Default case just lists the joysticks */
int i = 0;
for (i=0; i < data.num_joysticks; i++)
printf("%d: %s\n", i, data.joysticks[i].instance.tszInstanceName);
if (data.num_joysticks > 0)
{
struct Joystick *joystick = &data.joysticks[0];
printf("Enumerating effects\n");
IDirectInputDevice2_EnumEffects(joystick->device, EffectsCallback, (void*) joystick, 0);
joystick->effects = malloc(sizeof(struct Effect) * joystick->num_effects);
joystick->cur_effect = 0;
IDirectInputDevice2_EnumEffects(joystick->device, EffectsCallback, (void*) joystick, 0);
hr = IDirectInputEffect_Start(joystick->effects[1].effect, 1, 0);
Sleep(1000);
}
return 0;
}
static bool dinput_joypad_init(void)
{
if (!dinput_init_context())
return false;
RARCH_LOG("Enumerating DInput joypads ...\n");
IDirectInput8_EnumDevices(g_ctx, DI8DEVCLASS_GAMECTRL,
enum_joypad_cb, NULL, DIEDFL_ATTACHEDONLY);
RARCH_LOG("Done enumerating DInput joypads ...\n");
return true;
}
void
SDL_DINPUT_JoystickDetect(JoyStick_DeviceData **pContext)
{
IDirectInput8_EnumDevices(dinput, DI8DEVCLASS_GAMECTRL, EnumJoysticksCallback, pContext, DIEDFL_ATTACHEDONLY);
if (SDL_RawDevList) {
SDL_free(SDL_RawDevList); /* in case we used this in DirectInput detection */
SDL_RawDevList = NULL;
}
SDL_RawDevListCount = 0;
}
int
SDL_DINPUT_HapticInit(void)
{
HRESULT ret;
HINSTANCE instance;
if (dinput != NULL) { /* Already open. */
return SDL_SetError("Haptic: SubSystem already open.");
}
ret = WIN_CoInitialize();
if (FAILED(ret)) {
return DI_SetError("Coinitialize", ret);
}
coinitialized = SDL_TRUE;
ret = CoCreateInstance(&CLSID_DirectInput8, NULL, CLSCTX_INPROC_SERVER,
&IID_IDirectInput8, (LPVOID)& dinput);
if (FAILED(ret)) {
SDL_SYS_HapticQuit();
return DI_SetError("CoCreateInstance", ret);
}
/* Because we used CoCreateInstance, we need to Initialize it, first. */
instance = GetModuleHandle(NULL);
if (instance == NULL) {
SDL_SYS_HapticQuit();
return SDL_SetError("GetModuleHandle() failed with error code %lu.",
GetLastError());
}
ret = IDirectInput8_Initialize(dinput, instance, DIRECTINPUT_VERSION);
if (FAILED(ret)) {
SDL_SYS_HapticQuit();
return DI_SetError("Initializing DirectInput device", ret);
}
/* Look for haptic devices. */
ret = IDirectInput8_EnumDevices(dinput,
0,
EnumHapticsCallback,
NULL,
DIEDFL_FORCEFEEDBACK |
DIEDFL_ATTACHEDONLY);
if (FAILED(ret)) {
SDL_SYS_HapticQuit();
return DI_SetError("Enumerating DirectInput devices", ret);
}
return 0;
}
int PERDXInit(void)
{
char tempstr[512];
HRESULT ret;
int user_index=0;
u32 i;
if (PERCORE_INITIALIZED)
return 0;
if (FAILED((ret = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8, NULL)) ))
{
sprintf(tempstr, "Input. DirectInput8Create error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
YabSetError(YAB_ERR_CANNOTINIT, tempstr);
return -1;
}
#ifdef HAVE_XINPUT
SetupForIsXInputDevice();
#endif
num_devices = 0;
IDirectInput8_EnumDevices(lpDI8, DI8DEVCLASS_ALL, EnumPeripheralsCallback,
&user_index, DIEDFL_ATTACHEDONLY);
#ifdef HAVE_XINPUT
CleanupForIsXInputDevice();
#endif
for (i = 0; i < num_devices; i++)
{
if (!dev_list[i].is_xinput_device)
{
if( FAILED( ret = IDirectInputDevice8_SetDataFormat(dev_list[i].lpDIDevice, &c_dfDIJoystick2 ) ) )
return -1;
// Set the cooperative level to let DInput know how this device should
// interact with the system and with other DInput applications.
if( FAILED( ret = IDirectInputDevice8_SetCooperativeLevel( dev_list[i].lpDIDevice, DXGetWindow(),
DISCL_NONEXCLUSIVE | DISCL_BACKGROUND
/* DISCL_EXCLUSIVE |
DISCL_FOREGROUND */ ) ) )
return -1;
}
}
PerPortReset();
//LoadDefaultPort1A();
PERCORE_INITIALIZED = 1;
return 0;
}
static bool dinput_joypad_init(void)
{
if (!dinput_init_context())
return false;
for (unsigned i = 0; i < MAX_PLAYERS; ++i)
{
g_xbox_pad_indexes[i] = -1;
g_pads[i].joy_name = NULL;
}
RARCH_LOG("Enumerating DInput joypads ...\n");
IDirectInput8_EnumDevices(g_ctx, DI8DEVCLASS_GAMECTRL,
enum_joypad_cb, NULL, DIEDFL_ATTACHEDONLY);
RARCH_LOG("Done enumerating DInput joypads ...\n");
return true;
}
int open_joystick(char *joystick_device, GdkWindow *window)
{
HINSTANCE hi = 0;
HRESULT hr = 0;
HWND hwin = 0;
struct DEVINFO devinfo = {0};
/* create interface */
hi = GetModuleHandle(NULL);
hr = DirectInput8Create(hi, DIRECTINPUT_VERSION, &IID_IDirectInput8, (VOID**)&dinput, NULL);
if (FAILED(hr))
return -1;
/* look for a joystick */
hr = IDirectInput8_EnumDevices(dinput, DI8DEVCLASS_GAMECTRL, EnumDevCallback, &devinfo, DIEDFL_ATTACHEDONLY);
if(FAILED(hr))
return -1;
/* obtain joystick interface */
hr = IDirectInput8_CreateDevice(dinput, &devinfo.deviceID, &joystick, NULL);
if(FAILED(hr))
return -1;
/* set data format to "simple joystick" */
hr = IDirectInputDevice2_SetDataFormat(joystick, &c_dfDIJoystick2);
if(FAILED(hr))
return -1;
/* set the cooperative level */
#ifdef __WIN32__
hwin = GDK_WINDOW_HWND(window);
#endif
hr = IDirectInputDevice2_SetCooperativeLevel(joystick, hwin, DISCL_EXCLUSIVE | DISCL_FOREGROUND);
if(FAILED(hr))
return -1;
/* enumerate axes, buttons, povs */
hr = IDirectInputDevice2_EnumObjects(joystick, EnumObjectsCallback, NULL, DIDFT_ALL);
if(FAILED(hr))
return -1;
return 0;
}
int refresh_gamepads(HWND hwnd)
{
int test=FALSE;
int i;
LPDIRECTINPUT8 dinp;
SendMessage(hwnd,CB_RESETCONTENT,0,0);
if(test){
DIDEVICEINSTANCE di;
sprintf(di.tszInstanceName,"adaptoid");
for(i=0;i<4;i++){
di.guidInstance.Data1=rand();
enum_gamepads(&di,hwnd);
}
printf("press key\n");
// getkey();
}
else
if(DirectInput8Create(GetModuleHandle(0),DIRECTINPUT_VERSION,&IID_IDirectInput8,(void *)&dinp,0)==DI_OK){
IDirectInput8_EnumDevices(dinp, DI8DEVCLASS_GAMECTRL, enum_gamepads,
hwnd, DIEDFL_ATTACHEDONLY);
}
SendMessage(hwnd,CB_SETCURSEL,0,0);
return TRUE;
}
static bool dinput_joypad_init(void *data)
{
unsigned i;
(void)data;
if (!dinput_init_context())
return false;
g_last_xinput_pad_idx = 0;
for (i = 0; i < MAX_USERS; ++i)
{
g_xinput_pad_indexes[i] = -1;
g_pads[i].joy_name = NULL;
g_pads[i].joy_friendly_name = NULL;
}
RARCH_LOG("Enumerating DInput joypads ...\n");
IDirectInput8_EnumDevices(g_dinput_ctx, DI8DEVCLASS_GAMECTRL,
enum_joypad_cb, NULL, DIEDFL_ATTACHEDONLY);
RARCH_LOG("Done enumerating DInput joypads ...\n");
return true;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrev, LPSTR szCmdLine,
int nShow)
{
/* Structure with the data and settings for the application */
/* data is: hwnd, lpdi, joy[], num_joy, cur_joy, chosen_joy, poll_time, axes_max, axes_min, buffered */
struct JoystickData data =
{ NULL, NULL, NULL, 0, 0, 0, 0, 1000, -1000, FALSE };
HRESULT hr;
hr = DirectInput8Create(GetModuleHandleA(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8A, (void **)&data.di, NULL);
if (FAILED(hr)) {
printf("Failed to initialize DirectInput: 0x%08x\n", hr);
return 1;
}
/* First count how many joysticks are there */
hr = IDirectInput8_EnumDevices(data.di, DI8DEVCLASS_GAMECTRL,
EnumCallback, &data, DIEDFL_ATTACHEDONLY);
data.joysticks = malloc(sizeof(struct Joystick) * data.num_joysticks);
/* Get all the joysticks */
hr = IDirectInput8_EnumDevices(data.di, DI8DEVCLASS_GAMECTRL,
EnumCallback, &data, DIEDFL_ATTACHEDONLY);
/* Get settings from the command line */
ProcessCmdLine(&data, szCmdLine);
/* Apply settings for all joysticks */
for (data.cur_joystick = 0; data.cur_joystick < data.num_joysticks;
data.cur_joystick++) {
IDirectInputDevice8_EnumObjects(data.joysticks[data.cur_joystick].
device, EnumObjectsCallback, &data,
DIDFT_AXIS | DIDFT_BUTTON);
}
printf("Found %d joysticks.\n", data.num_joysticks);
/* Default case just lists the joysticks */
if (data.poll_time == 0) {
int i = 0;
for (i = 0; i < data.num_joysticks; i++)
printf("%d: %s\n", i, data.joysticks[i].instance.tszInstanceName);
}
else {
/* If we'll poll the joystick for input */
if (data.num_joysticks > 0) {
if (data.chosen_joystick >= data.num_joysticks
|| data.chosen_joystick < 0) {
printf("Joystick '%d' is not connected\n",
data.chosen_joystick);
exit(1);
}
WaitForInput(&data);
}
}
return 0;
}
static void test_preinitialization(void)
{
static const struct
{
REFGUID rguid;
BOOL pdev;
HRESULT expected_hr;
} create_device_tests[] =
{
{NULL, FALSE, E_POINTER},
{NULL, TRUE, E_POINTER},
{&GUID_Unknown, FALSE, E_POINTER},
{&GUID_Unknown, TRUE, DIERR_NOTINITIALIZED},
{&GUID_SysMouse, FALSE, E_POINTER},
{&GUID_SysMouse, TRUE, DIERR_NOTINITIALIZED},
};
static const struct
{
DWORD dwDevType;
LPDIENUMDEVICESCALLBACKA lpCallback;
DWORD dwFlags;
HRESULT expected_hr;
int todo;
} enum_devices_tests[] =
{
{0, NULL, 0, DIERR_INVALIDPARAM},
{0, NULL, ~0u, DIERR_INVALIDPARAM},
{0, dummy_callback, 0, DIERR_NOTINITIALIZED},
{0, dummy_callback, ~0u, DIERR_INVALIDPARAM},
{0xdeadbeef, NULL, 0, DIERR_INVALIDPARAM},
{0xdeadbeef, NULL, ~0u, DIERR_INVALIDPARAM},
{0xdeadbeef, dummy_callback, 0, DIERR_INVALIDPARAM},
{0xdeadbeef, dummy_callback, ~0u, DIERR_INVALIDPARAM},
};
IDirectInput8A *pDI;
HRESULT hr;
int i;
IDirectInputDevice8A *pDID;
hr = CoCreateInstance(&CLSID_DirectInput8, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectInput8A, (void **)&pDI);
if (FAILED(hr))
{
skip("Failed to instantiate a IDirectInputA instance: 0x%08x\n", hr);
return;
}
for (i = 0; i < ARRAY_SIZE(create_device_tests); i++)
{
if (create_device_tests[i].pdev) pDID = (void *)0xdeadbeef;
hr = IDirectInput8_CreateDevice(pDI, create_device_tests[i].rguid,
create_device_tests[i].pdev ? &pDID : NULL,
NULL);
ok(hr == create_device_tests[i].expected_hr, "[%d] IDirectInput8_CreateDevice returned 0x%08x\n", i, hr);
if (create_device_tests[i].pdev)
ok(pDID == NULL, "[%d] Output interface pointer is %p\n", i, pDID);
}
for (i = 0; i < ARRAY_SIZE(enum_devices_tests); i++)
{
hr = IDirectInput8_EnumDevices(pDI, enum_devices_tests[i].dwDevType,
enum_devices_tests[i].lpCallback,
NULL,
enum_devices_tests[i].dwFlags);
todo_wine_if(enum_devices_tests[i].todo)
ok(hr == enum_devices_tests[i].expected_hr, "[%d] IDirectInput8_EnumDevice returned 0x%08x\n", i, hr);
}
hr = IDirectInput8_GetDeviceStatus(pDI, NULL);
ok(hr == E_POINTER, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_GetDeviceStatus(pDI, &GUID_Unknown);
ok(hr == DIERR_NOTINITIALIZED, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_GetDeviceStatus(pDI, &GUID_SysMouse);
ok(hr == DIERR_NOTINITIALIZED, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_RunControlPanel(pDI, NULL, 0);
ok(hr == DIERR_NOTINITIALIZED, "IDirectInput8_RunControlPanel returned 0x%08x\n", hr);
hr = IDirectInput8_RunControlPanel(pDI, NULL, ~0u);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_RunControlPanel returned 0x%08x\n", hr);
hr = IDirectInput8_RunControlPanel(pDI, (HWND)0xdeadbeef, 0);
ok(hr == E_HANDLE, "IDirectInput8_RunControlPanel returned 0x%08x\n", hr);
hr = IDirectInput8_RunControlPanel(pDI, (HWND)0xdeadbeef, ~0u);
ok(hr == E_HANDLE, "IDirectInput8_RunControlPanel returned 0x%08x\n", hr);
IDirectInput8_Release(pDI);
}
int PERDXInit(void)
{
DIPROPDWORD dipdw;
char tempstr[512];
HRESULT ret;
memset(pad, 0, sizeof(pad));
memset(paddevice, 0, sizeof(paddevice));
if (FAILED((ret = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8, NULL)) ))
{
sprintf(tempstr, "DirectInput8Create error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
IDirectInput8_EnumDevices(lpDI8, DI8DEVCLASS_ALL, EnumPeripheralsCallback,
NULL, DIEDFL_ATTACHEDONLY);
if (FAILED((ret = IDirectInput8_CreateDevice(lpDI8, &GUID_SysKeyboard, &lpDIDevice[0],
NULL)) ))
{
sprintf(tempstr, "IDirectInput8_CreateDevice error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
if (FAILED((ret = IDirectInputDevice8_SetDataFormat(lpDIDevice[0], &c_dfDIKeyboard)) ))
{
sprintf(tempstr, "IDirectInputDevice8_SetDataFormat error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
if (FAILED((ret = IDirectInputDevice8_SetCooperativeLevel(lpDIDevice[0], DXGetWindow(),
DISCL_FOREGROUND | DISCL_NONEXCLUSIVE | DISCL_NOWINKEY)) ))
{
sprintf(tempstr, "IDirectInputDevice8_SetCooperativeLevel error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = 8; // should be enough
// Setup Buffered input
if (FAILED((ret = IDirectInputDevice8_SetProperty(lpDIDevice[0], DIPROP_BUFFERSIZE, &dipdw.diph)) ))
{
sprintf(tempstr, "IDirectInputDevice8_SetProperty error: %s - %s", DXGetErrorString8(ret), DXGetErrorDescription8(ret));
MessageBox (NULL, _16(tempstr), _16("Error"), MB_OK | MB_ICONINFORMATION);
return -1;
}
// Make sure Keyboard is acquired already
IDirectInputDevice8_Acquire(lpDIDevice[0]);
paddevice[0].lpDIDevice = lpDIDevice[0];
paddevice[0].type = TYPE_KEYBOARD;
paddevice[0].emulatetype = 1;
PerPortReset();
LoadDefaultPort1A();
return 0;
}
/*
* Initializes the haptic subsystem.
*/
int
SDL_SYS_HapticInit(void)
{
const char *env = SDL_GetHint(SDL_HINT_XINPUT_ENABLED);
HRESULT ret;
HINSTANCE instance;
if (dinput != NULL) { /* Already open. */
return SDL_SetError("Haptic: SubSystem already open.");
}
/* Clear all the memory. */
SDL_memset(SDL_hapticlist, 0, sizeof(SDL_hapticlist));
SDL_numhaptics = 0;
ret = WIN_CoInitialize();
if (FAILED(ret)) {
return DI_SetError("Coinitialize", ret);
}
coinitialized = SDL_TRUE;
ret = CoCreateInstance(&CLSID_DirectInput8, NULL, CLSCTX_INPROC_SERVER,
&IID_IDirectInput8, (LPVOID) & dinput);
if (FAILED(ret)) {
SDL_SYS_HapticQuit();
return DI_SetError("CoCreateInstance", ret);
}
/* Because we used CoCreateInstance, we need to Initialize it, first. */
instance = GetModuleHandle(NULL);
if (instance == NULL) {
SDL_SYS_HapticQuit();
return SDL_SetError("GetModuleHandle() failed with error code %d.",
GetLastError());
}
ret = IDirectInput8_Initialize(dinput, instance, DIRECTINPUT_VERSION);
if (FAILED(ret)) {
SDL_SYS_HapticQuit();
return DI_SetError("Initializing DirectInput device", ret);
}
/* Look for haptic devices. */
ret = IDirectInput8_EnumDevices(dinput,
0,
EnumHapticsCallback,
NULL,
DIEDFL_FORCEFEEDBACK |
DIEDFL_ATTACHEDONLY);
if (FAILED(ret)) {
SDL_SYS_HapticQuit();
return DI_SetError("Enumerating DirectInput devices", ret);
}
if (!env || SDL_atoi(env)) {
loaded_xinput = (WIN_LoadXInputDLL() == 0);
}
if (loaded_xinput) {
DWORD i;
const SDL_bool bIs14OrLater = (SDL_XInputVersion >= ((1<<16)|4));
for (i = 0; (i < SDL_XINPUT_MAX_DEVICES) && (SDL_numhaptics < MAX_HAPTICS); i++) {
XINPUT_CAPABILITIES caps;
if (XINPUTGETCAPABILITIES(i, XINPUT_FLAG_GAMEPAD, &caps) == ERROR_SUCCESS) {
if ((!bIs14OrLater) || (caps.Flags & XINPUT_CAPS_FFB_SUPPORTED)) {
/* !!! FIXME: I'm not bothering to query for a real name right now. */
char buf[64];
SDL_snprintf(buf, sizeof (buf), "XInput Controller #%u", i+1);
SDL_hapticlist[SDL_numhaptics].name = SDL_strdup(buf);
SDL_hapticlist[SDL_numhaptics].bXInputHaptic = 1;
SDL_hapticlist[SDL_numhaptics].userid = (Uint8) i;
SDL_numhaptics++;
}
}
}
}
return SDL_numhaptics;
}
