static void test_RunControlPanel(void)
{
IDirectInput8A *pDI;
HRESULT hr;
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;
}
if (winetest_interactive)
{
hr = IDirectInput8_RunControlPanel(pDI, NULL, 0);
ok(hr == S_OK, "IDirectInput8_RunControlPanel returned 0x%08x\n", hr);
hr = IDirectInput8_RunControlPanel(pDI, GetDesktopWindow(), 0);
ok(hr == S_OK, "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);
}
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);
}
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;
}
/*
* Clean up after system specific haptic stuff
*/
void
SDL_SYS_HapticQuit(void)
{
int i;
if (loaded_xinput) {
WIN_UnloadXInputDLL();
loaded_xinput = SDL_FALSE;
}
for (i = 0; i < SDL_arraysize(SDL_hapticlist); ++i) {
if (SDL_hapticlist[i].name) {
SDL_free(SDL_hapticlist[i].name);
SDL_hapticlist[i].name = NULL;
}
}
if (dinput != NULL) {
IDirectInput8_Release(dinput);
dinput = NULL;
}
if (coinitialized) {
WIN_CoUninitialize();
coinitialized = SDL_FALSE;
}
}
static void test_GetDeviceStatus(void)
{
IDirectInput8A *pDI;
HRESULT hr;
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_GetDeviceStatus(pDI, NULL);
todo_wine
ok(hr == E_POINTER, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_GetDeviceStatus(pDI, &GUID_Unknown);
todo_wine
ok(hr == DIERR_DEVICENOTREG, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_GetDeviceStatus(pDI, &GUID_SysMouse);
ok(hr == DI_OK, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
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);
}
void dinput_destroy_context(void)
{
if (!g_dinput_ctx)
return;
IDirectInput8_Release(g_dinput_ctx);
g_dinput_ctx = NULL;
}
static void dinput_destroy_context(void)
{
if (g_ctx)
{
IDirectInput8_Release(g_ctx);
g_ctx = NULL;
}
}
/* joydx_exit_joystick: [primary thread]
* Shuts down the DirectInput joystick devices.
*/
static void joydx_exit_joystick(void)
{
int i;
ALLEGRO_SYSTEM *system;
size_t j;
ALLEGRO_DEBUG("Entering joydx_exit_joystick\n");
ASSERT(joydx_thread);
/* stop the thread */
SetEvent(STOP_EVENT);
WaitForSingleObject(joydx_thread, INFINITE);
CloseHandle(joydx_thread);
joydx_thread = NULL;
/* free thread resources */
CloseHandle(STOP_EVENT);
STOP_EVENT = NULL;
DeleteCriticalSection(&joydx_thread_cs);
/* The toplevel display is assumed to have the input acquired. Release it. */
system = al_get_system_driver();
for (j = 0; j < _al_vector_size(&system->displays); j++) {
ALLEGRO_DISPLAY_WIN **pwin_disp = _al_vector_ref(&system->displays, j);
ALLEGRO_DISPLAY_WIN *win_disp = *pwin_disp;
if (win_disp->window == GetForegroundWindow()) {
ALLEGRO_DEBUG("Requesting window unacquire joystick devices\n");
_al_win_wnd_call_proc(win_disp->window,
_al_win_joystick_dinput_unacquire,
win_disp);
}
}
/* destroy the devices */
for (i = 0; i < MAX_JOYSTICKS; i++) {
joydx_inactivate_joy(&joydx_joystick[i]);
}
joydx_num_joysticks = 0;
for (i = 0; i < MAX_JOYSTICKS; i++) {
JOYSTICK_WAKER(i) = NULL;
}
/* destroy the DirectInput interface */
IDirectInput8_Release(joystick_dinput);
joystick_dinput = NULL;
/* release module handle */
FreeLibrary(_al_dinput_module);
_al_dinput_module = NULL;
ALLEGRO_DEBUG("Leaving joydx_exit_joystick\n");
}
/*********************************************************************
* CPlApplet (joy.cpl.@)
*
* Control Panel entry point
*
* PARAMS
* hWnd [I] Handle for the Control Panel Window
* command [I] CPL_* Command
* lParam1 [I] first extra Parameter
* lParam2 [I] second extra Parameter
*
* RETURNS
* Depends on the command
*
*/
LONG CALLBACK CPlApplet(HWND hwnd, UINT command, LPARAM lParam1, LPARAM lParam2)
{
static struct JoystickData data;
TRACE("(%p, %u, 0x%lx, 0x%lx)\n", hwnd, command, lParam1, lParam2);
switch (command)
{
case CPL_INIT:
{
HRESULT hr;
/* Initialize dinput */
hr = DirectInput8Create(GetModuleHandleW(NULL), DIRECTINPUT_VERSION, &IID_IDirectInput8W, (void**)&data.di, NULL);
if (FAILED(hr))
{
ERR("Failed to initialize DirectInput: 0x%08x\n", hr);
return FALSE;
}
/* Then get all the connected joysticks */
initialize_joysticks(&data);
return TRUE;
}
case CPL_GETCOUNT:
return 1;
case CPL_INQUIRE:
{
CPLINFO *appletInfo = (CPLINFO *) lParam2;
appletInfo->idIcon = ICO_MAIN;
appletInfo->idName = IDS_CPL_NAME;
appletInfo->idInfo = IDS_CPL_INFO;
appletInfo->lData = 0;
return TRUE;
}
case CPL_DBLCLK:
display_cpl_sheets(hwnd, &data);
break;
case CPL_STOP:
destroy_joysticks(&data);
/* And destroy dinput too */
IDirectInput8_Release(data.di);
break;
}
return FALSE;
}
void close_joystick()
{
if(joystick) {
IDirectInputDevice2_Unacquire(joystick);
joystick = NULL;
}
if (dinput) {
IDirectInput8_Release(dinput);
dinput = NULL;
}
}
void
SDL_DINPUT_JoystickQuit(void)
{
if (dinput != NULL) {
IDirectInput8_Release(dinput);
dinput = NULL;
}
if (coinitialized) {
WIN_CoUninitialize();
coinitialized = SDL_FALSE;
}
}
void PERDXDeInit(void)
{
u32 i;
for (i = 0; i < numdevices; i++)
{
if (lpDIDevice[i])
{
IDirectInputDevice8_Unacquire(lpDIDevice[i]);
IDirectInputDevice8_Release(lpDIDevice[i]);
lpDIDevice[i] = NULL;
}
}
if (lpDI8)
{
IDirectInput8_Release(lpDI8);
lpDI8 = NULL;
}
}
void PERDXDeInit(void)
{
u32 i;
for (i = 0; i < num_devices; i++)
{
if (dev_list[i].lpDIDevice)
{
IDirectInputDevice8_Unacquire(dev_list[i].lpDIDevice);
IDirectInputDevice8_Release(dev_list[i].lpDIDevice);
dev_list[i].lpDIDevice = NULL;
}
}
if (lpDI8)
{
IDirectInput8_Release(lpDI8);
lpDI8 = NULL;
}
PERCORE_INITIALIZED = 0;
}
static void test_CreateDevice(void)
{
IDirectInput8A *pDI;
HRESULT hr;
IDirectInputDevice8A *pDID;
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_CreateDevice(pDI, NULL, NULL, NULL);
ok(hr == E_POINTER, "IDirectInput8_CreateDevice returned 0x%08x\n", hr);
pDID = (void *)0xdeadbeef;
hr = IDirectInput8_CreateDevice(pDI, NULL, &pDID, NULL);
ok(hr == E_POINTER, "IDirectInput8_CreateDevice returned 0x%08x\n", hr);
ok(pDID == NULL, "Output interface pointer is %p\n", pDID);
hr = IDirectInput8_CreateDevice(pDI, &GUID_Unknown, NULL, NULL);
ok(hr == E_POINTER, "IDirectInput8_CreateDevice returned 0x%08x\n", hr);
pDID = (void *)0xdeadbeef;
hr = IDirectInput8_CreateDevice(pDI, &GUID_Unknown, &pDID, NULL);
ok(hr == DIERR_DEVICENOTREG, "IDirectInput8_CreateDevice returned 0x%08x\n", hr);
ok(pDID == NULL, "Output interface pointer is %p\n", pDID);
hr = IDirectInput8_CreateDevice(pDI, &GUID_SysMouse, NULL, NULL);
ok(hr == E_POINTER, "IDirectInput8_CreateDevice returned 0x%08x\n", hr);
hr = IDirectInput8_CreateDevice(pDI, &GUID_SysMouse, &pDID, NULL);
ok(hr == DI_OK, "IDirectInput8_CreateDevice returned 0x%08x\n", hr);
IDirectInputDevice_Release(pDID);
IDirectInput8_Release(pDI);
}
static void test_Initialize(void)
{
IDirectInput8A *pDI;
HRESULT hr;
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_Initialize(pDI, NULL, 0);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_Initialize returned 0x%08x\n", hr);
hr = IDirectInput8_Initialize(pDI, NULL, DIRECTINPUT_VERSION);
ok(hr == DIERR_INVALIDPARAM, "IDirectInput8_Initialize returned 0x%08x\n", hr);
hr = IDirectInput8_Initialize(pDI, hInstance, 0);
ok(hr == DIERR_NOTINITIALIZED, "IDirectInput8_Initialize returned 0x%08x\n", hr);
/* Invalid DirectInput versions less than DIRECTINPUT_VERSION yield DIERR_BETADIRECTINPUTVERSION. */
hr = IDirectInput8_Initialize(pDI, hInstance, DIRECTINPUT_VERSION - 1);
ok(hr == DIERR_BETADIRECTINPUTVERSION, "IDirectInput8_Initialize returned 0x%08x\n", hr);
/* Invalid DirectInput versions greater than DIRECTINPUT_VERSION yield DIERR_BETADIRECTINPUTVERSION. */
hr = IDirectInput8_Initialize(pDI, hInstance, DIRECTINPUT_VERSION + 1);
ok(hr == DIERR_OLDDIRECTINPUTVERSION, "IDirectInput8_Initialize returned 0x%08x\n", hr);
hr = IDirectInput8_Initialize(pDI, hInstance, DIRECTINPUT_VERSION);
ok(hr == DI_OK, "IDirectInput8_Initialize returned 0x%08x\n", hr);
/* Parameters are still validated after successful initialization. */
hr = IDirectInput8_Initialize(pDI, hInstance, 0);
ok(hr == DIERR_NOTINITIALIZED, "IDirectInput8_Initialize returned 0x%08x\n", hr);
IDirectInput8_Release(pDI);
}
static void test_QueryInterface(void)
{
static REFIID iid_list[] = {&IID_IUnknown, &IID_IDirectInput8A, &IID_IDirectInput8W, &IID_IDirectInputJoyConfig8};
static REFIID no_interface_list[] =
{
&IID_IDirectInputA,
&IID_IDirectInputW,
&IID_IDirectInput2A,
&IID_IDirectInput2W,
&IID_IDirectInput7A,
&IID_IDirectInput7W,
&IID_IDirectInputDeviceA,
&IID_IDirectInputDeviceW,
&IID_IDirectInputDevice2A,
&IID_IDirectInputDevice2W,
&IID_IDirectInputDevice7A,
&IID_IDirectInputDevice7W,
&IID_IDirectInputDevice8A,
&IID_IDirectInputDevice8W,
&IID_IDirectInputEffect,
};
IDirectInput8A *pDI;
HRESULT hr;
IUnknown *pUnk;
int i;
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_QueryInterface(pDI, NULL, NULL);
ok(hr == E_POINTER, "IDirectInput8_QueryInterface returned 0x%08x\n", hr);
pUnk = (void *)0xdeadbeef;
hr = IDirectInput8_QueryInterface(pDI, NULL, (void **)&pUnk);
ok(hr == E_POINTER, "IDirectInput8_QueryInterface returned 0x%08x\n", hr);
ok(pUnk == (void *)0xdeadbeef, "Output interface pointer is %p\n", pUnk);
hr = IDirectInput8_QueryInterface(pDI, &IID_IUnknown, NULL);
ok(hr == E_POINTER, "IDirectInput8_QueryInterface returned 0x%08x\n", hr);
for (i = 0; i < ARRAY_SIZE(iid_list); i++)
{
pUnk = NULL;
hr = IDirectInput8_QueryInterface(pDI, iid_list[i], (void **)&pUnk);
ok(hr == S_OK, "[%d] IDirectInput8_QueryInterface returned 0x%08x\n", i, hr);
ok(pUnk != NULL, "[%d] Output interface pointer is NULL\n", i);
if (pUnk)
{
int j;
for (j = 0; j < ARRAY_SIZE(iid_list); j++)
{
IUnknown *pUnk1 = NULL;
hr = IDirectInput8_QueryInterface(pUnk, iid_list[j], (void **)&pUnk1);
ok(hr == S_OK, "[%d] IDirectInput8_QueryInterface(pUnk) returned 0x%08x\n", j, hr);
ok(pUnk1 != NULL, "[%d] Output interface pointer is NULL\n", i);
if (pUnk1) IUnknown_Release(pUnk1);
}
IUnknown_Release(pUnk);
}
}
for (i = 0; i < ARRAY_SIZE(no_interface_list); i++)
{
pUnk = (void *)0xdeadbeef;
hr = IDirectInput8_QueryInterface(pDI, no_interface_list[i], (void **)&pUnk);
ok(hr == E_NOINTERFACE, "[%d] IDirectInput8_QueryInterface returned 0x%08x\n", i, hr);
ok(pUnk == NULL, "[%d] Output interface pointer is %p\n", i, pUnk);
}
IDirectInput8_Release(pDI);
}
/******************************************************************************
* DirectInput8Create (DINPUT8.@)
*/
HRESULT WINAPI DECLSPEC_HOTPATCH DirectInput8Create(HINSTANCE hinst, DWORD dwVersion, REFIID riid, LPVOID *ppDI, LPUNKNOWN punkOuter) {
IDirectInputA *pDI;
HRESULT hr, hrCo;
TRACE("hInst (%p), dwVersion: %d, riid (%s), punkOuter (%p)\n", hinst, dwVersion, debugstr_guid(riid), punkOuter);
if (!ppDI)
return E_POINTER;
if (!IsEqualGUID(&IID_IDirectInput8A, riid) &&
!IsEqualGUID(&IID_IDirectInput8W, riid) &&
!IsEqualGUID(&IID_IUnknown, riid))
{
*ppDI = NULL;
return DIERR_NOINTERFACE;
}
hrCo = CoInitialize(NULL);
hr = CoCreateInstance(&CLSID_DirectInput, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectInputA, (void **)&pDI);
/* Ensure balance of calls. */
if (SUCCEEDED(hrCo))
CoUninitialize();
if (FAILED(hr)) {
ERR("CoCreateInstance failed with hr = 0x%08x\n", hr);
return hr;
}
hr = IDirectInput_QueryInterface(pDI, riid, ppDI);
IDirectInput_Release(pDI);
if (FAILED(hr))
return hr;
/* When aggregation is used (punkOuter!=NULL) the application needs to manually call Initialize. */
if(punkOuter == NULL && IsEqualGUID(&IID_IDirectInput8A, riid)) {
IDirectInput8A *DI = *ppDI;
hr = IDirectInput8_Initialize(DI, hinst, dwVersion);
if (FAILED(hr))
{
IDirectInput8_Release(DI);
*ppDI = NULL;
return hr;
}
}
if(punkOuter == NULL && IsEqualGUID(&IID_IDirectInput8W, riid)) {
IDirectInput8W *DI = *ppDI;
hr = IDirectInput8_Initialize(DI, hinst, dwVersion);
if (FAILED(hr))
{
IDirectInput8_Release(DI);
*ppDI = NULL;
return hr;
}
}
return S_OK;
}
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);
}
static void test_EnumDevicesBySemantics(void)
{
IDirectInput8A *pDI;
HRESULT hr;
DIACTIONFORMATA diaf;
const GUID ACTION_MAPPING_GUID = { 0x1, 0x2, 0x3, { 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb } };
struct enum_semantics_test data = { 0, 0, FALSE, FALSE, &diaf, NULL };
int device_total = 0;
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;
}
memset (&diaf, 0, sizeof(diaf));
diaf.dwSize = sizeof(diaf);
diaf.dwActionSize = sizeof(DIACTIONA);
diaf.dwNumActions = ARRAY_SIZE(actionMapping);
diaf.dwDataSize = 4 * diaf.dwNumActions;
diaf.rgoAction = actionMapping;
diaf.guidActionMap = ACTION_MAPPING_GUID;
diaf.dwGenre = 0x01000000; /* DIVIRTUAL_DRIVING_RACE */
diaf.dwBufferSize = 32;
/* Test enumerating all attached and installed devices */
data.keyboard = FALSE;
data.mouse = FALSE;
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, enum_semantics_callback, &data, DIEDBSFL_ATTACHEDONLY);
ok (data.device_count > 0, "EnumDevicesBySemantics did not call the callback hr=%08x\n", hr);
ok (data.keyboard, "EnumDevicesBySemantics should enumerate the keyboard\n");
ok (data.mouse, "EnumDevicesBySemantics should enumerate the mouse\n");
/* Enumerate Force feedback devices. We should get no mouse nor keyboard */
data.keyboard = FALSE;
data.mouse = FALSE;
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, enum_semantics_callback, &data, DIEDBSFL_FORCEFEEDBACK);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (!data.keyboard, "Keyboard should not be enumerated when asking for forcefeedback\n");
ok (!data.mouse, "Mouse should not be enumerated when asking for forcefeedback\n");
/* Enumerate available devices. That is devices not owned by any user.
Before setting the action map for all devices we still have them available. */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, enum_semantics_callback, &data, DIEDBSFL_AVAILABLEDEVICES);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count > 0, "There should be devices available before action mapping available=%d\n", data.device_count);
/* Keep the device total */
device_total = data.device_count;
/* There should be no devices for any user. No device should be enumerated with DIEDBSFL_THISUSER.
MSDN defines that all unowned devices are also enumerated but this doesn't seem to be happening. */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, "Sh4d0w M4g3", &diaf, enum_semantics_callback, &data, DIEDBSFL_THISUSER);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count == 0, "No devices should be assigned for this user assigned=%d\n", data.device_count);
/* This enumeration builds and sets the action map for all devices with a NULL username */
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, set_action_map_callback, &data, DIEDBSFL_ATTACHEDONLY);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr);
/* After a successful action mapping we should have no devices available */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, enum_semantics_callback, &data, DIEDBSFL_AVAILABLEDEVICES);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count == 0, "No device should be available after action mapping available=%d\n", data.device_count);
/* Now we'll give all the devices to a specific user */
data.username = "******";
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, set_action_map_callback, &data, DIEDBSFL_ATTACHEDONLY);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr);
/* Testing with the default user, DIEDBSFL_THISUSER has no effect */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, enum_semantics_callback, &data, DIEDBSFL_THISUSER);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count == device_total, "THISUSER has no effect with NULL username owned=%d, expected=%d\n", data.device_count, device_total);
/* Using an empty user string is the same as passing NULL, DIEDBSFL_THISUSER has no effect */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, "", &diaf, enum_semantics_callback, &data, DIEDBSFL_THISUSER);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count == device_total, "THISUSER has no effect with \"\" as username owned=%d, expected=%d\n", data.device_count, device_total);
/* Testing with a user with no ownership of the devices */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, "Ninja Brian", &diaf, enum_semantics_callback, &data, DIEDBSFL_THISUSER);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count == 0, "This user should own no devices owned=%d\n", data.device_count);
/* Sh4d0w M4g3 has ownership of all devices */
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, "Sh4d0w M4g3", &diaf, enum_semantics_callback, &data, DIEDBSFL_THISUSER);
ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed hr=%08x\n", hr);
ok (data.device_count == device_total, "This user should own %d devices owned=%d\n", device_total, data.device_count);
/* The call fails with a zeroed GUID */
memset(&diaf.guidActionMap, 0, sizeof(GUID));
data.device_count = 0;
hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &diaf, enum_semantics_callback, NULL, 0);
todo_wine ok(FAILED(hr), "EnumDevicesBySemantics succeeded with invalid GUID hr=%08x\n", hr);
IDirectInput8_Release(pDI);
}
int PERDXFetchNextPress(HWND hWnd, u32 guidnum, char *buttonname)
{
LPDIRECTINPUT8 lpDI8temp = NULL;
LPDIRECTINPUTDEVICE8 lpDIDevicetemp;
DIDEVCAPS didc;
int buttonid=-1;
if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8temp, NULL)))
return -1;
if (FAILED(IDirectInput8_CreateDevice(lpDI8temp, &GUIDDevice[guidnum], &lpDIDevicetemp,
NULL)))
{
IDirectInput8_Release(lpDI8temp);
return -1;
}
didc.dwSize = sizeof(DIDEVCAPS);
if (FAILED(IDirectInputDevice8_GetCapabilities(lpDIDevicetemp, &didc)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevicetemp, &c_dfDIKeyboard)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevicetemp, &c_dfDIJoystick)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
if (FAILED(IDirectInputDevice8_SetDataFormat(lpDIDevicetemp, &c_dfDIMouse2)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
}
if (DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_BUTTONCONFIG), hWnd, (DLGPROC)ButtonConfigDlgProc, (LPARAM)lpDIDevicetemp) == TRUE)
{
// Figure out what kind of code to generate
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
memset(buttonname, 0, MAX_PATH);
buttonid = nextpress.dwOfs;
// This fixes some strange inconsistencies
if (buttonid == DIK_PAUSE)
buttonid = DIK_NUMLOCK;
else if (buttonid == DIK_NUMLOCK)
buttonid = DIK_PAUSE;
if (buttonid & 0x80)
buttonid += 0x80;
GetKeyNameTextA(buttonid << 16, buttonname, MAX_PATH);
buttonid = nextpress.dwOfs;
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
if (nextpress.dwOfs == DIJOFS_X)
{
if (nextpress.dwData <= 0x8000)
{
sprintf(buttonname, "Axis Left");
buttonid = 0x00;
}
else
{
sprintf(buttonname, "Axis Right");
buttonid = 0x01;
}
}
else if (nextpress.dwOfs == DIJOFS_Y)
{
if (nextpress.dwData <= 0x8000)
{
sprintf(buttonname, "Axis Up");
buttonid = 0x02;
}
else
{
sprintf(buttonname, "Axis Down");
buttonid = 0x03;
}
}
else if (nextpress.dwOfs == DIJOFS_POV(0))
{
if (nextpress.dwData < 9000)
{
sprintf(buttonname, "POV Up");
buttonid = 0x04;
}
else if (nextpress.dwData < 18000)
{
sprintf(buttonname, "POV Right");
buttonid = 0x05;
}
else if (nextpress.dwData < 27000)
{
sprintf(buttonname, "POV Down");
buttonid = 0x06;
}
else
{
sprintf(buttonname, "POV Left");
buttonid = 0x07;
}
}
else if (nextpress.dwOfs >= DIJOFS_BUTTON(0) && nextpress.dwOfs <= DIJOFS_BUTTON(127))
{
sprintf(buttonname, "Button %d", (int)(nextpress.dwOfs - 0x2F));
buttonid = nextpress.dwOfs;
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
buttonid = nextpress.dwOfs-DIMOFS_BUTTON0;
sprintf(buttonname, "Button %d", buttonid+1);
}
}
IDirectInputDevice8_Unacquire(lpDIDevicetemp);
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return buttonid;
}
int PERDXInitControlConfig(HWND hWnd, u8 padnum, int *controlmap, const char *inifilename)
{
char tempstr[MAX_PATH];
char string1[20];
GUID guid;
u32 i;
int idlist[] = { IDC_UPTEXT, IDC_RIGHTTEXT, IDC_DOWNTEXT, IDC_LEFTTEXT,
IDC_RTEXT, IDC_LTEXT, IDC_STARTTEXT,
IDC_ATEXT, IDC_BTEXT, IDC_CTEXT,
IDC_XTEXT, IDC_YTEXT, IDC_ZTEXT
};
sprintf(string1, "Peripheral%d%C", ((padnum/6)+1), 'A'+(padnum%6));
// Let's first fetch the guid of the device and see if we can get a match
if (GetPrivateProfileStringA(string1, "GUID", "", tempstr, MAX_PATH, inifilename) == 0)
{
if (padnum == 0)
{
// Let's use default values
SendDlgItemMessage(hWnd, IDC_DXDEVICECB, CB_SETCURSEL, 1, 0);
controlmap[0] = DIK_UP;
controlmap[1] = DIK_RIGHT;
controlmap[2] = DIK_DOWN;
controlmap[3] = DIK_LEFT;
controlmap[4] = DIK_Z;
controlmap[5] = DIK_X;
controlmap[6] = DIK_J;
controlmap[7] = DIK_K;
controlmap[8] = DIK_L;
controlmap[9] = DIK_M;
controlmap[10] = DIK_U;
controlmap[11] = DIK_I;
controlmap[12] = DIK_O;
for (i = 0; i < 13; i++)
{
ConvertKBIDToName(controlmap[i], tempstr);
SetDlgItemText(hWnd, idlist[i], _16(tempstr));
}
}
else
{
SendDlgItemMessage(hWnd, IDC_DXDEVICECB, CB_SETCURSEL, 0, 0);
return -1;
}
}
else
{
LPDIRECTINPUT8 lpDI8temp = NULL;
LPDIRECTINPUTDEVICE8 lpDIDevicetemp;
DIDEVCAPS didc;
int buttonid;
StringToGUID(tempstr, &guid);
// Let's find a match
for (i = 0; i < numguids; i++)
{
if (memcmp(&guid, &GUIDDevice[i], sizeof(GUID)) == 0)
{
SendDlgItemMessage(hWnd, IDC_DXDEVICECB, CB_SETCURSEL, i+1, 0);
break;
}
}
if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
&IID_IDirectInput8, (LPVOID *)&lpDI8temp, NULL)))
return -1;
if (FAILED(IDirectInput8_CreateDevice(lpDI8temp, &GUIDDevice[i], &lpDIDevicetemp,
NULL)))
{
IDirectInput8_Release(lpDI8temp);
return -1;
}
didc.dwSize = sizeof(DIDEVCAPS);
if (FAILED(IDirectInputDevice8_GetCapabilities(lpDIDevicetemp, &didc)))
{
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
return -1;
}
if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_KEYBOARD)
{
sprintf(string1, "Peripheral%d%C", ((padnum/6)+1), 'A'+(padnum%6));
for (i = 0; i < 13; i++)
{
buttonid = GetPrivateProfileIntA(string1, PerPadNames[i], 0, inifilename);
printf("%2d: %d\n", i, buttonid);
controlmap[i] = buttonid;
ConvertKBIDToName(buttonid, tempstr);
SetDlgItemText(hWnd, idlist[i], _16(tempstr));
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_GAMEPAD ||
GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_JOYSTICK)
{
sprintf(string1, "Peripheral%d%C", ((padnum/6)+1), 'A'+(padnum%6));
for (i = 0; i < 13; i++)
{
buttonid = GetPrivateProfileIntA(string1, PerPadNames[i], 0, inifilename);
controlmap[i] = buttonid;
ConvertJoyIDToName(buttonid, tempstr);
SetDlgItemText(hWnd, idlist[i], _16(tempstr));
}
}
else if (GET_DIDEVICE_TYPE(didc.dwDevType) == DI8DEVTYPE_MOUSE)
{
for (i = 0; i < 13; i++)
{
buttonid = GetPrivateProfileIntA(string1, PerPadNames[i], 0, inifilename);
controlmap[i] = buttonid;
ConvertMouseIDToName(buttonid, tempstr);
SetDlgItemText(hWnd, idlist[i], _16(tempstr));
}
}
IDirectInputDevice8_Release(lpDIDevicetemp);
IDirectInput8_Release(lpDI8temp);
}
return 0;
}
static void test_QueryInterface(void)
{
static REFIID iid_list[] = {&IID_IUnknown, &IID_IDirectInput8A, &IID_IDirectInput8W};
static const struct
{
REFIID riid;
int test_todo;
} no_interface_list[] =
{
{&IID_IDirectInputA, 1},
{&IID_IDirectInputW, 1},
{&IID_IDirectInput2A, 1},
{&IID_IDirectInput2W, 1},
{&IID_IDirectInput7A, 1},
{&IID_IDirectInput7W, 1},
{&IID_IDirectInputDeviceA},
{&IID_IDirectInputDeviceW},
{&IID_IDirectInputDevice2A},
{&IID_IDirectInputDevice2W},
{&IID_IDirectInputDevice7A},
{&IID_IDirectInputDevice7W},
{&IID_IDirectInputDevice8A},
{&IID_IDirectInputDevice8W},
{&IID_IDirectInputEffect},
};
IDirectInput8A *pDI;
HRESULT hr;
IUnknown *pUnk;
int i;
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_QueryInterface(pDI, NULL, NULL);
ok(hr == E_POINTER, "IDirectInput8_QueryInterface returned 0x%08x\n", hr);
pUnk = (void *)0xdeadbeef;
hr = IDirectInput8_QueryInterface(pDI, NULL, (void **)&pUnk);
ok(hr == E_POINTER, "IDirectInput8_QueryInterface returned 0x%08x\n", hr);
ok(pUnk == (void *)0xdeadbeef, "Output interface pointer is %p\n", pUnk);
hr = IDirectInput8_QueryInterface(pDI, &IID_IUnknown, NULL);
ok(hr == E_POINTER, "IDirectInput8_QueryInterface returned 0x%08x\n", hr);
for (i = 0; i < sizeof(iid_list)/sizeof(iid_list[0]); i++)
{
pUnk = NULL;
hr = IDirectInput8_QueryInterface(pDI, iid_list[i], (void **)&pUnk);
ok(hr == S_OK, "[%d] IDirectInput8_QueryInterface returned 0x%08x\n", i, hr);
ok(pUnk != NULL, "[%d] Output interface pointer is NULL\n", i);
if (pUnk) IUnknown_Release(pUnk);
}
for (i = 0; i < sizeof(no_interface_list)/sizeof(no_interface_list[0]); i++)
{
pUnk = (void *)0xdeadbeef;
hr = IDirectInput8_QueryInterface(pDI, no_interface_list[i].riid, (void **)&pUnk);
if (no_interface_list[i].test_todo)
{
todo_wine
ok(hr == E_NOINTERFACE, "[%d] IDirectInput8_QueryInterface returned 0x%08x\n", i, hr);
todo_wine
ok(pUnk == NULL, "[%d] Output interface pointer is %p\n", i, pUnk);
if (pUnk) IUnknown_Release(pUnk);
}
else
{
ok(hr == E_NOINTERFACE, "[%d] IDirectInput8_QueryInterface returned 0x%08x\n", i, hr);
ok(pUnk == NULL, "[%d] Output interface pointer is %p\n", i, pUnk);
}
}
IDirectInput8_Release(pDI);
}