| /* |
| * Copyright (c) 2011 Lucas Fialho Zawacki |
| * Copyright (c) 2006 Vitaliy Margolen |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #define DIRECTINPUT_VERSION 0x0800 |
| |
| #define COBJMACROS |
| #include <windows.h> |
| |
| #include "wine/test.h" |
| #include "windef.h" |
| #include "dinput.h" |
| |
| struct enum_data { |
| IDirectInput8A *pDI; |
| DIACTIONFORMATA *lpdiaf; |
| IDirectInputDevice8A *keyboard; |
| IDirectInputDevice8A *mouse; |
| const char* username; |
| int ndevices; |
| }; |
| |
| /* Dummy GUID */ |
| static const GUID ACTION_MAPPING_GUID = { 0x1, 0x2, 0x3, { 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb } }; |
| |
| enum { |
| DITEST_AXIS, |
| DITEST_BUTTON, |
| DITEST_KEYBOARDSPACE, |
| DITEST_MOUSEBUTTON0, |
| DITEST_YAXIS |
| }; |
| |
| static DIACTIONA actionMapping[]= |
| { |
| /* axis */ |
| { 0, 0x01008A01 /* DIAXIS_DRIVINGR_STEER */, 0, { "Steer.\0" } }, |
| /* button */ |
| { 1, 0x01000C01 /* DIBUTTON_DRIVINGR_SHIFTUP */, 0, { "Upshift.\0" } }, |
| /* keyboard key */ |
| { 2, DIKEYBOARD_SPACE, 0, { "Missile.\0" } }, |
| /* mouse button */ |
| { 3, DIMOUSE_BUTTON0, 0, { "Select\0" } }, |
| /* mouse axis */ |
| { 4, DIMOUSE_YAXIS, 0, { "Y Axis\0" } } |
| }; |
| /* By placing the memory pointed to by lptszActionName right before memory with PAGE_NOACCESS |
| * one can find out that the regular ansi string termination is not respected by EnumDevicesBySemantics. |
| * Adding a double termination, making it a valid wide string termination, made the test succeed. |
| * Therefore it looks like ansi version of EnumDevicesBySemantics forwards the string to |
| * the wide variant without conversation. */ |
| |
| static void flush_events(void) |
| { |
| int diff = 200; |
| int min_timeout = 100; |
| DWORD time = GetTickCount() + diff; |
| |
| while (diff > 0) |
| { |
| if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT) |
| break; |
| diff = time - GetTickCount(); |
| min_timeout = 50; |
| } |
| } |
| |
| static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWORD event, DWORD expected) |
| { |
| HRESULT hr; |
| DIDEVICEOBJECTDATA obj_data; |
| DWORD data_size = 1; |
| int i; |
| |
| hr = IDirectInputDevice8_Acquire(lpdid); |
| ok (SUCCEEDED(hr), "Failed to acquire device hr=%08x\n", hr); |
| |
| if (event_type == INPUT_KEYBOARD) |
| keybd_event( event, DIK_SPACE, 0, 0); |
| |
| if (event_type == INPUT_MOUSE) |
| mouse_event( event, 0, 0, 0, 0); |
| |
| flush_events(); |
| IDirectInputDevice8_Poll(lpdid); |
| hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); |
| |
| if (data_size != 1) |
| { |
| win_skip("We're not able to inject input into Windows dinput8 with events\n"); |
| IDirectInputDevice_Unacquire(lpdid); |
| return; |
| } |
| |
| ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%d\n", obj_data.uAppData, expected); |
| |
| /* Check for buffer owerflow */ |
| for (i = 0; i < 17; i++) |
| if (event_type == INPUT_KEYBOARD) |
| { |
| keybd_event( VK_SPACE, DIK_SPACE, 0, 0); |
| keybd_event( VK_SPACE, DIK_SPACE, KEYEVENTF_KEYUP, 0); |
| } |
| else if (event_type == INPUT_MOUSE) |
| { |
| mouse_event(MOUSEEVENTF_LEFTDOWN, 1, 1, 0, 0); |
| mouse_event(MOUSEEVENTF_LEFTUP, 1, 1, 0, 0); |
| } |
| |
| flush_events(); |
| IDirectInputDevice8_Poll(lpdid); |
| |
| data_size = 1; |
| hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); |
| ok(hr == DI_BUFFEROVERFLOW, "GetDeviceData() failed: %08x\n", hr); |
| data_size = 1; |
| hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); |
| ok(hr == DI_OK && data_size == 1, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size); |
| |
| IDirectInputDevice_Unacquire(lpdid); |
| } |
| |
| static void test_build_action_map(IDirectInputDevice8A *lpdid, DIACTIONFORMATA *lpdiaf, |
| int action_index, DWORD expected_type, DWORD expected_inst) |
| { |
| HRESULT hr; |
| DIACTIONA *actions; |
| DWORD instance, type, how; |
| GUID assigned_to; |
| DIDEVICEINSTANCEA ddi; |
| |
| ddi.dwSize = sizeof(ddi); |
| IDirectInputDevice_GetDeviceInfo(lpdid, &ddi); |
| |
| hr = IDirectInputDevice8_BuildActionMap(lpdid, lpdiaf, NULL, DIDBAM_HWDEFAULTS); |
| ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr); |
| |
| actions = lpdiaf->rgoAction; |
| instance = DIDFT_GETINSTANCE(actions[action_index].dwObjID); |
| type = DIDFT_GETTYPE(actions[action_index].dwObjID); |
| how = actions[action_index].dwHow; |
| assigned_to = actions[action_index].guidInstance; |
| |
| ok (how == DIAH_USERCONFIG || how == DIAH_DEFAULT, "Action was not set dwHow=%08x\n", how); |
| ok (instance == expected_inst, "Action not mapped correctly instance=%08x expected=%08x\n", instance, expected_inst); |
| ok (type == expected_type, "Action type not mapped correctly type=%08x expected=%08x\n", type, expected_type); |
| ok (IsEqualGUID(&assigned_to, &ddi.guidInstance), "Action and device GUID do not match action=%d\n", action_index); |
| } |
| |
| static BOOL CALLBACK enumeration_callback(const DIDEVICEINSTANCEA *lpddi, IDirectInputDevice8A *lpdid, |
| DWORD dwFlags, DWORD dwRemaining, LPVOID pvRef) |
| { |
| HRESULT hr; |
| DIPROPDWORD dp; |
| DIPROPRANGE dpr; |
| DIPROPSTRING dps; |
| WCHAR usernameW[MAX_PATH]; |
| DWORD username_size = MAX_PATH; |
| struct enum_data *data = pvRef; |
| DWORD cnt; |
| DIDEVICEOBJECTDATA buffer[5]; |
| IDirectInputDevice8A *lpdid2; |
| |
| if (!data) return DIENUM_CONTINUE; |
| |
| data->ndevices++; |
| |
| /* Convert username to WCHAR */ |
| if (data->username != NULL) |
| { |
| username_size = MultiByteToWideChar(CP_ACP, 0, data->username, -1, usernameW, 0); |
| MultiByteToWideChar(CP_ACP, 0, data->username, -1, usernameW, username_size); |
| } |
| else |
| GetUserNameW(usernameW, &username_size); |
| |
| /* collect the mouse and keyboard */ |
| if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysKeyboard)) |
| { |
| IDirectInputDevice_AddRef(lpdid); |
| data->keyboard = lpdid; |
| |
| ok (dwFlags & DIEDBS_MAPPEDPRI1, "Keyboard should be mapped as pri1 dwFlags=%08x\n", dwFlags); |
| } |
| |
| if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysMouse)) |
| { |
| IDirectInputDevice_AddRef(lpdid); |
| data->mouse = lpdid; |
| |
| ok (dwFlags & DIEDBS_MAPPEDPRI1, "Mouse should be mapped as pri1 dwFlags=%08x\n", dwFlags); |
| } |
| |
| /* Creating second device object to check if it has the same username */ |
| hr = IDirectInput_CreateDevice(data->pDI, &lpddi->guidInstance, &lpdid2, NULL); |
| ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x\n", hr); |
| |
| /* Building and setting an action map */ |
| /* It should not use any pre-stored mappings so we use DIDBAM_HWDEFAULTS */ |
| hr = IDirectInputDevice8_BuildActionMap(lpdid, data->lpdiaf, NULL, DIDBAM_HWDEFAULTS); |
| ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr); |
| |
| /* Device has no data format and thus can't be acquired */ |
| hr = IDirectInputDevice8_Acquire(lpdid); |
| ok (hr == DIERR_INVALIDPARAM, "Device was acquired before SetActionMap hr=%08x\n", hr); |
| |
| hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, data->username, 0); |
| ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr); |
| |
| /* Some joysticks may have no suitable actions and thus should not be tested */ |
| if (hr == DI_NOEFFECT) return DIENUM_CONTINUE; |
| |
| /* Test username after SetActionMap */ |
| dps.diph.dwSize = sizeof(dps); |
| dps.diph.dwHeaderSize = sizeof(DIPROPHEADER); |
| dps.diph.dwObj = 0; |
| dps.diph.dwHow = DIPH_DEVICE; |
| dps.wsz[0] = '\0'; |
| |
| hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_USERNAME, &dps.diph); |
| ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr); |
| ok (!lstrcmpW(usernameW, dps.wsz), "Username not set correctly expected=%s, got=%s\n", wine_dbgstr_w(usernameW), wine_dbgstr_w(dps.wsz)); |
| |
| dps.wsz[0] = '\0'; |
| hr = IDirectInputDevice_GetProperty(lpdid2, DIPROP_USERNAME, &dps.diph); |
| ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr); |
| ok (!lstrcmpW(usernameW, dps.wsz), "Username not set correctly expected=%s, got=%s\n", wine_dbgstr_w(usernameW), wine_dbgstr_w(dps.wsz)); |
| |
| /* Test buffer size */ |
| memset(&dp, 0, sizeof(dp)); |
| dp.diph.dwSize = sizeof(dp); |
| dp.diph.dwHeaderSize = sizeof(DIPROPHEADER); |
| dp.diph.dwHow = DIPH_DEVICE; |
| |
| hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_BUFFERSIZE, &dp.diph); |
| ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr); |
| ok (dp.dwData == data->lpdiaf->dwBufferSize, "SetActionMap must set the buffer, buffersize=%d\n", dp.dwData); |
| |
| cnt = 1; |
| hr = IDirectInputDevice_GetDeviceData(lpdid, sizeof(buffer[0]), buffer, &cnt, 0); |
| ok(hr == DIERR_NOTACQUIRED, "GetDeviceData() failed hr=%08x\n", hr); |
| |
| /* Test axis range */ |
| memset(&dpr, 0, sizeof(dpr)); |
| dpr.diph.dwSize = sizeof(dpr); |
| dpr.diph.dwHeaderSize = sizeof(DIPROPHEADER); |
| dpr.diph.dwHow = DIPH_DEVICE; |
| |
| hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_RANGE, &dpr.diph); |
| /* Only test if device supports the range property */ |
| if (SUCCEEDED(hr)) |
| { |
| ok (dpr.lMin == data->lpdiaf->lAxisMin, "SetActionMap must set the min axis range expected=%d got=%d\n", data->lpdiaf->lAxisMin, dpr.lMin); |
| ok (dpr.lMax == data->lpdiaf->lAxisMax, "SetActionMap must set the max axis range expected=%d got=%d\n", data->lpdiaf->lAxisMax, dpr.lMax); |
| } |
| |
| /* SetActionMap has set the data format so now it should work */ |
| hr = IDirectInputDevice8_Acquire(lpdid); |
| ok (SUCCEEDED(hr), "Acquire failed hr=%08x\n", hr); |
| |
| cnt = 1; |
| hr = IDirectInputDevice_GetDeviceData(lpdid, sizeof(buffer[0]), buffer, &cnt, 0); |
| ok(hr == DI_OK, "GetDeviceData() failed hr=%08x\n", hr); |
| |
| /* SetActionMap should not work on an acquired device */ |
| hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, NULL, 0); |
| ok (hr == DIERR_ACQUIRED, "SetActionMap succeeded with an acquired device hr=%08x\n", hr); |
| |
| return DIENUM_CONTINUE; |
| } |
| |
| static void test_action_mapping(void) |
| { |
| HRESULT hr; |
| HINSTANCE hinst = GetModuleHandleA(NULL); |
| IDirectInput8A *pDI = NULL; |
| DIACTIONFORMATA af; |
| DIPROPSTRING dps; |
| struct enum_data data = {pDI, &af, NULL, NULL, NULL, 0}; |
| HWND hwnd; |
| |
| hr = CoCreateInstance(&CLSID_DirectInput8, 0, CLSCTX_INPROC_SERVER, &IID_IDirectInput8A, (LPVOID*)&pDI); |
| if (hr == DIERR_OLDDIRECTINPUTVERSION || |
| hr == DIERR_BETADIRECTINPUTVERSION || |
| hr == REGDB_E_CLASSNOTREG) |
| { |
| win_skip("ActionMapping requires dinput8\n"); |
| return; |
| } |
| ok(SUCCEEDED(hr), "DirectInput8 Create failed: hr=%08x\n", hr); |
| if (FAILED(hr)) return; |
| |
| hr = IDirectInput8_Initialize(pDI,hinst, DIRECTINPUT_VERSION); |
| if (hr == DIERR_OLDDIRECTINPUTVERSION || hr == DIERR_BETADIRECTINPUTVERSION) |
| { |
| win_skip("ActionMapping requires dinput8\n"); |
| return; |
| } |
| ok(SUCCEEDED(hr), "DirectInput8 Initialize failed: hr=%08x\n", hr); |
| if (FAILED(hr)) return; |
| |
| memset (&af, 0, sizeof(af)); |
| af.dwSize = sizeof(af); |
| af.dwActionSize = sizeof(DIACTIONA); |
| af.dwDataSize = 4 * sizeof(actionMapping) / sizeof(actionMapping[0]); |
| af.dwNumActions = sizeof(actionMapping) / sizeof(actionMapping[0]); |
| af.rgoAction = actionMapping; |
| af.guidActionMap = ACTION_MAPPING_GUID; |
| af.dwGenre = 0x01000000; /* DIVIRTUAL_DRIVING_RACE */ |
| af.dwBufferSize = 32; |
| |
| /* This enumeration builds and sets the action map for all devices */ |
| data.pDI = pDI; |
| hr = IDirectInput8_EnumDevicesBySemantics(pDI, 0, &af, enumeration_callback, &data, DIEDBSFL_ATTACHEDONLY); |
| ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr); |
| |
| /* Repeat tests with a non NULL user */ |
| data.username = "Ninja Brian"; |
| hr = IDirectInput8_EnumDevicesBySemantics(pDI, NULL, &af, enumeration_callback, &data, DIEDBSFL_ATTACHEDONLY); |
| ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr); |
| |
| hwnd = CreateWindowExA(WS_EX_TOPMOST, "static", "dinput", |
| WS_POPUP | WS_VISIBLE, 0, 0, 100, 100, NULL, NULL, NULL, NULL); |
| ok(hwnd != NULL, "failed to create window\n"); |
| SetCursorPos(50, 50); |
| |
| if (data.keyboard != NULL) |
| { |
| /* Test keyboard BuildActionMap */ |
| test_build_action_map(data.keyboard, data.lpdiaf, DITEST_KEYBOARDSPACE, DIDFT_PSHBUTTON, DIK_SPACE); |
| /* Test keyboard input */ |
| test_device_input(data.keyboard, INPUT_KEYBOARD, VK_SPACE, 2); |
| |
| /* Test BuildActionMap with no suitable actions for a device */ |
| IDirectInputDevice_Unacquire(data.keyboard); |
| af.dwDataSize = 4 * DITEST_KEYBOARDSPACE; |
| af.dwNumActions = DITEST_KEYBOARDSPACE; |
| |
| hr = IDirectInputDevice8_BuildActionMap(data.keyboard, data.lpdiaf, NULL, DIDBAM_HWDEFAULTS); |
| ok (hr == DI_NOEFFECT, "BuildActionMap should have no effect with no actions hr=%08x\n", hr); |
| |
| hr = IDirectInputDevice8_SetActionMap(data.keyboard, data.lpdiaf, NULL, 0); |
| ok (hr == DI_NOEFFECT, "SetActionMap should have no effect with no actions to map hr=%08x\n", hr); |
| |
| af.dwDataSize = 4 * sizeof(actionMapping) / sizeof(actionMapping[0]); |
| af.dwNumActions = sizeof(actionMapping) / sizeof(actionMapping[0]); |
| |
| /* test DIDSAM_NOUSER */ |
| dps.diph.dwSize = sizeof(dps); |
| dps.diph.dwHeaderSize = sizeof(DIPROPHEADER); |
| dps.diph.dwObj = 0; |
| dps.diph.dwHow = DIPH_DEVICE; |
| dps.wsz[0] = '\0'; |
| |
| hr = IDirectInputDevice_GetProperty(data.keyboard, DIPROP_USERNAME, &dps.diph); |
| ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr); |
| ok (dps.wsz[0] != 0, "Expected any username, got=%s\n", wine_dbgstr_w(dps.wsz)); |
| |
| hr = IDirectInputDevice8_SetActionMap(data.keyboard, data.lpdiaf, NULL, DIDSAM_NOUSER); |
| ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr); |
| |
| dps.diph.dwSize = sizeof(dps); |
| dps.diph.dwHeaderSize = sizeof(DIPROPHEADER); |
| dps.diph.dwObj = 0; |
| dps.diph.dwHow = DIPH_DEVICE; |
| dps.wsz[0] = '\0'; |
| |
| hr = IDirectInputDevice_GetProperty(data.keyboard, DIPROP_USERNAME, &dps.diph); |
| ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr); |
| ok (dps.wsz[0] == 0, "Expected empty username, got=%s\n", wine_dbgstr_w(dps.wsz)); |
| } |
| |
| if (data.mouse != NULL) |
| { |
| /* Test mouse BuildActionMap */ |
| test_build_action_map(data.mouse, data.lpdiaf, DITEST_MOUSEBUTTON0, DIDFT_PSHBUTTON, 0x03); |
| test_build_action_map(data.mouse, data.lpdiaf, DITEST_YAXIS, DIDFT_RELAXIS, 0x01); |
| |
| test_device_input(data.mouse, INPUT_MOUSE, MOUSEEVENTF_LEFTDOWN, 3); |
| } |
| |
| DestroyWindow(hwnd); |
| } |
| |
| static void test_save_settings(void) |
| { |
| HRESULT hr; |
| HINSTANCE hinst = GetModuleHandleA(NULL); |
| IDirectInput8A *pDI = NULL; |
| DIACTIONFORMATA af; |
| IDirectInputDevice8A *pKey; |
| |
| static const GUID mapping_guid = { 0xcafecafe, 0x2, 0x3, { 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb } }; |
| static const GUID other_guid = { 0xcafe, 0xcafe, 0x3, { 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb } }; |
| |
| static DIACTIONA actions[] = { |
| { 0, DIKEYBOARD_A , 0, { "Blam" } }, |
| { 1, DIKEYBOARD_B , 0, { "Kapow"} } |
| }; |
| static const DWORD results[] = { |
| DIDFT_MAKEINSTANCE(DIK_A) | DIDFT_PSHBUTTON, |
| DIDFT_MAKEINSTANCE(DIK_B) | DIDFT_PSHBUTTON |
| }; |
| static const DWORD other_results[] = { |
| DIDFT_MAKEINSTANCE(DIK_C) | DIDFT_PSHBUTTON, |
| DIDFT_MAKEINSTANCE(DIK_D) | DIDFT_PSHBUTTON |
| }; |
| |
| hr = CoCreateInstance(&CLSID_DirectInput8, 0, CLSCTX_INPROC_SERVER, &IID_IDirectInput8A, (LPVOID*)&pDI); |
| if (hr == DIERR_OLDDIRECTINPUTVERSION || |
| hr == DIERR_BETADIRECTINPUTVERSION || |
| hr == REGDB_E_CLASSNOTREG) |
| { |
| win_skip("ActionMapping requires dinput8\n"); |
| return; |
| } |
| ok (SUCCEEDED(hr), "DirectInput8 Create failed: hr=%08x\n", hr); |
| if (FAILED(hr)) return; |
| |
| hr = IDirectInput8_Initialize(pDI,hinst, DIRECTINPUT_VERSION); |
| if (hr == DIERR_OLDDIRECTINPUTVERSION || hr == DIERR_BETADIRECTINPUTVERSION) |
| { |
| win_skip("ActionMapping requires dinput8\n"); |
| return; |
| } |
| ok (SUCCEEDED(hr), "DirectInput8 Initialize failed: hr=%08x\n", hr); |
| if (FAILED(hr)) return; |
| |
| hr = IDirectInput_CreateDevice(pDI, &GUID_SysKeyboard, &pKey, NULL); |
| ok (SUCCEEDED(hr), "IDirectInput_Create device failed hr: 0x%08x\n", hr); |
| if (FAILED(hr)) return; |
| |
| memset (&af, 0, sizeof(af)); |
| af.dwSize = sizeof(af); |
| af.dwActionSize = sizeof(DIACTIONA); |
| af.dwDataSize = 4 * sizeof(actions) / sizeof(actions[0]); |
| af.dwNumActions = sizeof(actions) / sizeof(actions[0]); |
| af.rgoAction = actions; |
| af.guidActionMap = mapping_guid; |
| af.dwGenre = 0x01000000; /* DIVIRTUAL_DRIVING_RACE */ |
| af.dwBufferSize = 32; |
| |
| /* Easy case. Ask for default mapping, save, ask for previous map and read it back */ |
| hr = IDirectInputDevice8_BuildActionMap(pKey, &af, NULL, DIDBAM_HWDEFAULTS); |
| ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr); |
| |
| ok (results[0] == af.rgoAction[0].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", results[0], af.rgoAction[0].dwObjID); |
| |
| ok (results[1] == af.rgoAction[1].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", results[1], af.rgoAction[1].dwObjID); |
| |
| hr = IDirectInputDevice8_SetActionMap(pKey, &af, NULL, DIDSAM_FORCESAVE); |
| ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr); |
| |
| if (hr == DI_SETTINGSNOTSAVED) |
| { |
| skip ("Can't test saving settings if SetActionMap returns DI_SETTINGSNOTSAVED\n"); |
| return; |
| } |
| |
| af.rgoAction[0].dwObjID = 0; |
| af.rgoAction[1].dwObjID = 0; |
| memset(&af.rgoAction[0].guidInstance, 0, sizeof(GUID)); |
| memset(&af.rgoAction[1].guidInstance, 0, sizeof(GUID)); |
| |
| hr = IDirectInputDevice8_BuildActionMap(pKey, &af, NULL, 0); |
| ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr); |
| |
| ok (results[0] == af.rgoAction[0].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", results[0], af.rgoAction[0].dwObjID); |
| ok (IsEqualGUID(&GUID_SysKeyboard, &af.rgoAction[0].guidInstance), "Action should be mapped to keyboard\n"); |
| |
| ok (results[1] == af.rgoAction[1].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", results[1], af.rgoAction[1].dwObjID); |
| ok (IsEqualGUID(&GUID_SysKeyboard, &af.rgoAction[1].guidInstance), "Action should be mapped to keyboard\n"); |
| |
| /* Test that a different action map with no pre-stored settings, in spite of the flags, |
| does not try to load mappings and instead applies the default mapping */ |
| af.guidActionMap = other_guid; |
| |
| af.rgoAction[0].dwObjID = 0; |
| af.rgoAction[1].dwObjID = 0; |
| memset(&af.rgoAction[0].guidInstance, 0, sizeof(GUID)); |
| memset(&af.rgoAction[1].guidInstance, 0, sizeof(GUID)); |
| |
| hr = IDirectInputDevice8_BuildActionMap(pKey, &af, NULL, 0); |
| ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr); |
| |
| ok (results[0] == af.rgoAction[0].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", results[0], af.rgoAction[0].dwObjID); |
| ok (IsEqualGUID(&GUID_SysKeyboard, &af.rgoAction[0].guidInstance), "Action should be mapped to keyboard\n"); |
| |
| ok (results[1] == af.rgoAction[1].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", results[1], af.rgoAction[1].dwObjID); |
| ok (IsEqualGUID(&GUID_SysKeyboard, &af.rgoAction[1].guidInstance), "Action should be mapped to keyboard\n"); |
| |
| af.guidActionMap = mapping_guid; |
| /* Hard case. Customized mapping, save, ask for previous map and read it back */ |
| af.rgoAction[0].dwObjID = other_results[0]; |
| af.rgoAction[0].dwHow = DIAH_USERCONFIG; |
| af.rgoAction[0].guidInstance = GUID_SysKeyboard; |
| af.rgoAction[1].dwObjID = other_results[1]; |
| af.rgoAction[1].dwHow = DIAH_USERCONFIG; |
| af.rgoAction[1].guidInstance = GUID_SysKeyboard; |
| |
| hr = IDirectInputDevice8_SetActionMap(pKey, &af, NULL, DIDSAM_FORCESAVE); |
| ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr); |
| |
| if (hr == DI_SETTINGSNOTSAVED) |
| { |
| skip ("Can't test saving settings if SetActionMap returns DI_SETTINGSNOTSAVED\n"); |
| return; |
| } |
| |
| af.rgoAction[0].dwObjID = 0; |
| af.rgoAction[1].dwObjID = 0; |
| memset(&af.rgoAction[0].guidInstance, 0, sizeof(GUID)); |
| memset(&af.rgoAction[1].guidInstance, 0, sizeof(GUID)); |
| |
| hr = IDirectInputDevice8_BuildActionMap(pKey, &af, NULL, 0); |
| ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr); |
| |
| ok (other_results[0] == af.rgoAction[0].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", other_results[0], af.rgoAction[0].dwObjID); |
| ok (IsEqualGUID(&GUID_SysKeyboard, &af.rgoAction[0].guidInstance), "Action should be mapped to keyboard\n"); |
| |
| ok (other_results[1] == af.rgoAction[1].dwObjID, |
| "Mapped incorrectly expected: 0x%08x got: 0x%08x\n", other_results[1], af.rgoAction[1].dwObjID); |
| ok (IsEqualGUID(&GUID_SysKeyboard, &af.rgoAction[1].guidInstance), "Action should be mapped to keyboard\n"); |
| } |
| |
| START_TEST(device) |
| { |
| CoInitialize(NULL); |
| |
| test_action_mapping(); |
| test_save_settings(); |
| |
| CoUninitialize(); |
| } |