dinput8: Improve the behavior of DirectInput8Create.
[wine] / dlls / dinput8 / tests / device.c
1 /*
2  * Copyright (c) 2011 Lucas Fialho Zawacki
3  * Copyright (c) 2006 Vitaliy Margolen
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 #define DIRECTINPUT_VERSION 0x0800
21
22 #define COBJMACROS
23 #include <windows.h>
24
25 #include "wine/test.h"
26 #include "windef.h"
27 #include "dinput.h"
28
29 struct enum_data {
30     LPDIRECTINPUT8 pDI;
31     LPDIACTIONFORMAT lpdiaf;
32     LPDIRECTINPUTDEVICE8 keyboard;
33     LPDIRECTINPUTDEVICE8 mouse;
34     int ndevices;
35 };
36
37 /* Dummy GUID */
38 static const GUID ACTION_MAPPING_GUID = { 0x1, 0x2, 0x3, { 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb } };
39
40 enum {
41     DITEST_AXIS,
42     DITEST_BUTTON,
43     DITEST_KEYBOARDSPACE,
44     DITEST_MOUSEBUTTON0,
45     DITEST_YAXIS
46 };
47
48 static DIACTION actionMapping[]=
49 {
50   /* axis */
51   { 0, 0x01008A01 /* DIAXIS_DRIVINGR_STEER */ , 0, { "Steer" } },
52   /* button */
53   { 1, 0x01000C01 /* DIBUTTON_DRIVINGR_SHIFTUP */ , 0, { "Upshift" } },
54   /* keyboard key */
55   { 2, DIKEYBOARD_SPACE , 0, { "Missile" } },
56   /* mouse button */
57   { 3, DIMOUSE_BUTTON0, 0, { "Select" } },
58   /* mouse axis */
59   { 4, DIMOUSE_YAXIS, 0, { "Y Axis" } }
60 };
61
62 static void test_device_input(
63     LPDIRECTINPUTDEVICE8 lpdid,
64     DWORD event_type,
65     DWORD event,
66     DWORD expected
67 )
68 {
69     HRESULT hr;
70     DIDEVICEOBJECTDATA obj_data;
71     DWORD data_size = 1;
72
73     hr = IDirectInputDevice8_Acquire(lpdid);
74     ok (SUCCEEDED(hr), "Failed to acquire device hr=%08x\n", hr);
75
76     if (event_type == INPUT_KEYBOARD)
77         keybd_event( event, 0, 0, 0);
78
79     if (event_type == INPUT_MOUSE)
80         mouse_event( event, 0, 0, 0, 0);
81
82     IDirectInputDevice8_Poll(lpdid);
83     hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0);
84
85     if (data_size != 1)
86     {
87         win_skip("We're not able to inject input into Windows dinput8 with events\n");
88         return;
89     }
90
91     ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%d\n", obj_data.uAppData, expected);
92 }
93
94 static void test_build_action_map(
95     LPDIRECTINPUTDEVICE8 lpdid,
96     LPDIACTIONFORMAT lpdiaf,
97     int action_index,
98     DWORD expected_type,
99     DWORD expected_inst
100 )
101 {
102     HRESULT hr;
103     DIACTION *actions;
104     DWORD instance, type, how;
105     GUID assigned_to;
106     DIDEVICEINSTANCEA ddi;
107
108     ddi.dwSize = sizeof(ddi);
109     IDirectInputDevice_GetDeviceInfo(lpdid, &ddi);
110
111     hr = IDirectInputDevice8_BuildActionMap(lpdid, lpdiaf, NULL, DIDBAM_INITIALIZE);
112     ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr);
113
114     actions = lpdiaf->rgoAction;
115     instance = DIDFT_GETINSTANCE(actions[action_index].dwObjID);
116     type = DIDFT_GETTYPE(actions[action_index].dwObjID);
117     how = actions[action_index].dwHow;
118     assigned_to = actions[action_index].guidInstance;
119
120     ok (how == DIAH_USERCONFIG || how == DIAH_DEFAULT, "Action was not set dwHow=%08x\n", how);
121     ok (instance == expected_inst, "Action not mapped correctly instance=%08x expected=%08x\n", instance, expected_inst);
122     ok (type == expected_type, "Action type not mapped correctly type=%08x expected=%08x\n", type, expected_type);
123     ok (IsEqualGUID(&assigned_to, &ddi.guidInstance), "Action and device GUID do not match action=%d\n", action_index);
124 }
125
126 static BOOL CALLBACK enumeration_callback(
127     LPCDIDEVICEINSTANCE lpddi,
128     LPDIRECTINPUTDEVICE8 lpdid,
129     DWORD dwFlags,
130     DWORD dwRemaining,
131     LPVOID pvRef)
132 {
133     HRESULT hr;
134     DIPROPDWORD dp;
135     struct enum_data *data = pvRef;
136     if (!data) return DIENUM_CONTINUE;
137
138     data->ndevices++;
139
140     /* collect the mouse and keyboard */
141     if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysKeyboard))
142     {
143         IDirectInputDevice_AddRef(lpdid);
144         data->keyboard = lpdid;
145
146         ok (dwFlags & DIEDBS_MAPPEDPRI1, "Keyboard should be mapped as pri1 dwFlags=%08x\n", dwFlags);
147     }
148
149     if (IsEqualGUID(&lpddi->guidInstance, &GUID_SysMouse))
150     {
151         IDirectInputDevice_AddRef(lpdid);
152         data->mouse = lpdid;
153
154         ok (dwFlags & DIEDBS_MAPPEDPRI1, "Mouse should be mapped as pri1 dwFlags=%08x\n", dwFlags);
155     }
156
157     /* Building and setting an action map */
158     /* It should not use any pre-stored mappings so we use DIDBAM_INITIALIZE */
159     hr = IDirectInputDevice8_BuildActionMap(lpdid, data->lpdiaf, NULL, DIDBAM_INITIALIZE);
160     ok (SUCCEEDED(hr), "BuildActionMap failed hr=%08x\n", hr);
161
162     /* Device has no data format and thus can't be acquired */
163     hr = IDirectInputDevice8_Acquire(lpdid);
164     ok (hr == DIERR_INVALIDPARAM, "Device was acquired before SetActionMap hr=%08x\n", hr);
165
166     hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, NULL, 0);
167     ok (SUCCEEDED(hr), "SetActionMap failed hr=%08x\n", hr);
168
169     /* Test buffer size */
170     memset(&dp, 0, sizeof(dp));
171     dp.diph.dwSize = sizeof(dp);
172     dp.diph.dwHeaderSize = sizeof(DIPROPHEADER);
173     dp.diph.dwHow  = DIPH_DEVICE;
174
175     hr = IDirectInputDevice_GetProperty(lpdid, DIPROP_BUFFERSIZE, &dp.diph);
176     ok (SUCCEEDED(hr), "GetProperty failed hr=%08x\n", hr);
177     ok (dp.dwData == data->lpdiaf->dwBufferSize, "SetActionMap must set the buffer, buffersize=%d\n", dp.dwData);
178
179     /* SetActionMap has set the data format so now it should work */
180     hr = IDirectInputDevice8_Acquire(lpdid);
181     ok (SUCCEEDED(hr), "Acquire failed hr=%08x\n", hr);
182
183     /* SetActionMap should not work on an acquired device */
184     hr = IDirectInputDevice8_SetActionMap(lpdid, data->lpdiaf, NULL, 0);
185     ok (hr == DIERR_ACQUIRED, "SetActionMap succeeded with an acquired device hr=%08x\n", hr);
186
187     return DIENUM_CONTINUE;
188 }
189
190
191 static void test_action_mapping(void)
192 {
193     HRESULT hr;
194     HINSTANCE hinst = GetModuleHandle(NULL);
195     LPDIRECTINPUT8 pDI = NULL;
196     DIACTIONFORMAT af;
197     struct enum_data data = {pDI, &af, NULL, NULL, 0};
198
199     hr = CoCreateInstance(&CLSID_DirectInput8, 0, 1, &IID_IDirectInput8A, (LPVOID*)&pDI);
200     if (hr == DIERR_OLDDIRECTINPUTVERSION ||
201         hr == DIERR_BETADIRECTINPUTVERSION ||
202         hr == REGDB_E_CLASSNOTREG)
203     {
204         win_skip("ActionMapping requires dinput8\n");
205         return;
206     }
207     ok(SUCCEEDED(hr), "DirectInput8 Create failed: hr=%08x\n", hr);
208     if (FAILED(hr)) return;
209
210     hr = IDirectInput8_Initialize(pDI,hinst, DIRECTINPUT_VERSION);
211     if (hr == DIERR_OLDDIRECTINPUTVERSION || hr == DIERR_BETADIRECTINPUTVERSION)
212     {
213         win_skip("ActionMapping requires dinput8\n");
214         return;
215     }
216     ok(SUCCEEDED(hr), "DirectInput8 Initialize failed: hr=%08x\n", hr);
217     if (FAILED(hr)) return;
218
219     memset (&af, 0, sizeof(af));
220     af.dwSize = sizeof(af);
221     af.dwActionSize = sizeof(DIACTION);
222     af.dwDataSize = 4 * sizeof(actionMapping) / sizeof(actionMapping[0]);
223     af.dwNumActions = sizeof(actionMapping) / sizeof(actionMapping[0]);
224     af.rgoAction = actionMapping;
225     af.guidActionMap = ACTION_MAPPING_GUID;
226     af.dwGenre = 0x01000000; /* DIVIRTUAL_DRIVING_RACE */
227     af.dwBufferSize = 32;
228
229     hr = IDirectInput8_EnumDevicesBySemantics(pDI, 0, &af, enumeration_callback, &data, 0);
230     ok (SUCCEEDED(hr), "EnumDevicesBySemantics failed: hr=%08x\n", hr);
231     ok (data.ndevices > 0, "EnumDevicesBySemantics did not call the callback hr=%08x\n", hr);
232     ok (data.keyboard != NULL, "EnumDevicesBySemantics should enumerate the keyboard\n");
233     ok (data.mouse != NULL, "EnumDevicesBySemantics should enumerate the mouse\n");
234
235     if (data.keyboard != NULL)
236     {
237         /* Test keyboard BuildActionMap */
238         test_build_action_map(data.keyboard, data.lpdiaf, DITEST_KEYBOARDSPACE, DIDFT_PSHBUTTON, DIK_SPACE);
239         /* Test keyboard input */
240         test_device_input(data.keyboard, INPUT_KEYBOARD, VK_SPACE, 2);
241
242         /* Test BuildActionMap with no suitable actions for a device */
243         IDirectInputDevice_Unacquire(data.keyboard);
244         af.dwDataSize = 4 * DITEST_KEYBOARDSPACE;
245         af.dwNumActions = DITEST_KEYBOARDSPACE;
246
247         hr = IDirectInputDevice8_BuildActionMap(data.keyboard, data.lpdiaf, NULL, DIDBAM_INITIALIZE);
248         ok (hr == DI_NOEFFECT, "BuildActionMap should have no effect with no actions hr=%08x\n", hr);
249
250         hr = IDirectInputDevice8_SetActionMap(data.keyboard, data.lpdiaf, NULL, 0);
251         ok (hr == DI_NOEFFECT, "SetActionMap should have no effect with no actions to map hr=%08x\n", hr);
252
253         af.dwDataSize = 4 * sizeof(actionMapping) / sizeof(actionMapping[0]);
254         af.dwNumActions = sizeof(actionMapping) / sizeof(actionMapping[0]);
255     }
256
257     if (data.mouse != NULL)
258     {
259         /* Test mouse BuildActionMap */
260         test_build_action_map(data.mouse, data.lpdiaf, DITEST_MOUSEBUTTON0, DIDFT_PSHBUTTON, 0x03);
261         test_build_action_map(data.mouse, data.lpdiaf, DITEST_YAXIS, DIDFT_RELAXIS, 0x01);
262
263         test_device_input(data.mouse, INPUT_MOUSE, MOUSEEVENTF_LEFTDOWN, 3);
264     }
265
266     /* The call fails with a zeroed GUID */
267     memset(&af.guidActionMap, 0, sizeof(GUID));
268     hr = IDirectInput8_EnumDevicesBySemantics(pDI, 0, &af, enumeration_callback, 0, 0);
269     todo_wine ok(FAILED(hr), "EnumDevicesBySemantics succeeded with invalid GUID hr=%08x\n", hr);
270 }
271
272 START_TEST(device)
273 {
274     CoInitialize(NULL);
275
276     test_action_mapping();
277
278     CoUninitialize();
279 }