projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'ntfs_rebase'
[reactos.git] / modules / rostests / winetests / user32 / input.c
1 /* Test Key event to Key message translation
2 *
3 * Copyright 2003 Rein Klazes
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 /* test whether the right type of messages:
21 * WM_KEYUP/DOWN vs WM_SYSKEYUP/DOWN are sent in case of combined
22 * keystrokes.
23 *
24 * For instance <ALT>-X can be accomplished by
25 * the sequence ALT-KEY-DOWN, X-KEY-DOWN, ALT-KEY-UP, X-KEY-UP
26 * but also X-KEY-DOWN, ALT-KEY-DOWN, X-KEY-UP, ALT-KEY-UP
27 * Whether a KEY or a SYSKEY message is sent is not always clear, it is
28 * also not the same in WINNT as in WIN9X */
29
30 /* NOTE that there will be test failures under WIN9X
31 * No applications are known to me that rely on this
32 * so I don't fix it */
33
34 /* TODO:
35 * 1. extend it to the wm_command and wm_syscommand notifications
36 * 2. add some more tests with special cases like dead keys or right (alt) key
37 * 3. there is some adapted code from input.c in here. Should really
38 * make that code exactly the same.
39 * 4. resolve the win9x case when there is a need or the testing frame work
40 * offers a nice way.
41 * 5. The test app creates a window, the user should not take the focus
42 * away during its short existence. I could do something to prevent that
43 * if it is a problem.
44 *
45 */
46
47 #include "precomp.h"
48
49 /* globals */
50 static HWND hWndTest;
51 static LONG timetag = 0x10000000;
52
53 static struct {
54 LONG last_key_down;
55 LONG last_key_up;
56 LONG last_syskey_down;
57 LONG last_syskey_up;
58 LONG last_char;
59 LONG last_syschar;
60 LONG last_hook_down;
61 LONG last_hook_up;
62 LONG last_hook_syskey_down;
63 LONG last_hook_syskey_up;
64 BOOL expect_alt;
65 BOOL sendinput_broken;
66 } key_status;
67
68 static UINT (WINAPI *pSendInput) (UINT, INPUT*, size_t);
69 static int (WINAPI *pGetMouseMovePointsEx) (UINT, LPMOUSEMOVEPOINT, LPMOUSEMOVEPOINT, int, DWORD);
70 static UINT (WINAPI *pGetRawInputDeviceList) (PRAWINPUTDEVICELIST, PUINT, UINT);
71 static int (WINAPI *pGetWindowRgnBox)(HWND, LPRECT);
72
73 #define MAXKEYEVENTS 12
74 #define MAXKEYMESSAGES MAXKEYEVENTS /* assuming a key event generates one
75 and only one message */
76
77 /* keyboard message names, sorted as their value */
78 static const char *MSGNAME[]={"WM_KEYDOWN", "WM_KEYUP", "WM_CHAR","WM_DEADCHAR",
79 "WM_SYSKEYDOWN", "WM_SYSKEYUP", "WM_SYSCHAR", "WM_SYSDEADCHAR" ,"WM_KEYLAST"};
80
81 /* keyevents, add more as needed */
82 typedef enum KEVtag
83 { ALTDOWN = 1, ALTUP, XDOWN, XUP, SHIFTDOWN, SHIFTUP, CTRLDOWN, CTRLUP } KEV;
84 /* matching VK's */
85 static const int GETVKEY[]={0, VK_MENU, VK_MENU, 'X', 'X', VK_SHIFT, VK_SHIFT, VK_CONTROL, VK_CONTROL};
86 /* matching scan codes */
87 static const int GETSCAN[]={0, 0x38, 0x38, 0x2D, 0x2D, 0x2A, 0x2A, 0x1D, 0x1D };
88 /* matching updown events */
89 static const int GETFLAGS[]={0, 0, KEYEVENTF_KEYUP, 0, KEYEVENTF_KEYUP, 0, KEYEVENTF_KEYUP, 0, KEYEVENTF_KEYUP};
90 /* matching descriptions */
91 static const char *getdesc[]={"", "+alt","-alt","+X","-X","+shift","-shift","+ctrl","-ctrl"};
92
93 /* The MSVC headers ignore our NONAMELESSUNION requests so we have to define our own type */
94 typedef struct
95 {
96 DWORD type;
97 union
98 {
99 MOUSEINPUT mi;
100 KEYBDINPUT ki;
101 HARDWAREINPUT hi;
102 } u;
103 } TEST_INPUT;
104
105 #define ADDTOINPUTS(kev) \
106 inputs[evtctr].type = INPUT_KEYBOARD; \
107 ((TEST_INPUT*)inputs)[evtctr].u.ki.wVk = GETVKEY[ kev]; \
108 ((TEST_INPUT*)inputs)[evtctr].u.ki.wScan = GETSCAN[ kev]; \
109 ((TEST_INPUT*)inputs)[evtctr].u.ki.dwFlags = GETFLAGS[ kev]; \
110 ((TEST_INPUT*)inputs)[evtctr].u.ki.dwExtraInfo = 0; \
111 ((TEST_INPUT*)inputs)[evtctr].u.ki.time = ++timetag; \
112 if( kev) evtctr++;
113
114 typedef struct {
115 UINT message;
116 WPARAM wParam;
117 LPARAM lParam;
118 } KMSG;
119
120 /*******************************************
121 * add new test sets here
122 * the software will make all combinations of the
123 * keyevent defined here
124 */
125 static const struct {
126 int nrkev;
127 KEV keydwn[MAXKEYEVENTS];
128 KEV keyup[MAXKEYEVENTS];
129 } testkeyset[]= {
130 { 2, { ALTDOWN, XDOWN }, { ALTUP, XUP}},
131 { 3, { ALTDOWN, XDOWN , SHIFTDOWN}, { ALTUP, XUP, SHIFTUP}},
132 { 3, { ALTDOWN, XDOWN , CTRLDOWN}, { ALTUP, XUP, CTRLUP}},
133 { 3, { SHIFTDOWN, XDOWN , CTRLDOWN}, { SHIFTUP, XUP, CTRLUP}},
134 { 0 } /* mark the end */
135 };
136
137 /**********************adapted from input.c **********************************/
138
139 static BYTE InputKeyStateTable[256];
140 static BYTE AsyncKeyStateTable[256];
141 static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
142 or a WM_KEYUP message */
143
144 static void init_function_pointers(void)
145 {
146 HMODULE hdll = GetModuleHandleA("user32");
147
148 #define GET_PROC(func) \
149 p ## func = (void*)GetProcAddress(hdll, #func); \
150 if(!p ## func) \
151 trace("GetProcAddress(%s) failed\n", #func);
152
153 GET_PROC(SendInput)
154 GET_PROC(GetMouseMovePointsEx)
155 GET_PROC(GetRawInputDeviceList)
156 GET_PROC(GetWindowRgnBox)
157
158 #undef GET_PROC
159 }
160
161 static int KbdMessage( KEV kev, WPARAM *pwParam, LPARAM *plParam )
162 {
163 UINT message;
164 int VKey = GETVKEY[kev];
165 WORD flags;
166
167 flags = LOBYTE(GETSCAN[kev]);
168 if (GETFLAGS[kev] & KEYEVENTF_EXTENDEDKEY) flags |= KF_EXTENDED;
169
170 if (GETFLAGS[kev] & KEYEVENTF_KEYUP )
171 {
172 message = WM_KEYUP;
173 if( (InputKeyStateTable[VK_MENU] & 0x80) && (
174 (VKey == VK_MENU) || (VKey == VK_CONTROL) ||
175 !(InputKeyStateTable[VK_CONTROL] & 0x80))) {
176 if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
177 (VKey != VK_MENU)) /* <ALT>-down...<something else>-up */
178 message = WM_SYSKEYUP;
179 TrackSysKey = 0;
180 }
181 InputKeyStateTable[VKey] &= ~0x80;
182 flags |= KF_REPEAT | KF_UP;
183 }
184 else
185 {
186 if (InputKeyStateTable[VKey] & 0x80) flags |= KF_REPEAT;
187 if (!(InputKeyStateTable[VKey] & 0x80)) InputKeyStateTable[VKey] ^= 0x01;
188 InputKeyStateTable[VKey] |= 0x80;
189 AsyncKeyStateTable[VKey] |= 0x80;
190
191 message = WM_KEYDOWN;
192 if( (InputKeyStateTable[VK_MENU] & 0x80) &&
193 !(InputKeyStateTable[VK_CONTROL] & 0x80)) {
194 message = WM_SYSKEYDOWN;
195 TrackSysKey = VKey;
196 }
197 }
198
199 if (InputKeyStateTable[VK_MENU] & 0x80) flags |= KF_ALTDOWN;
200
201 if( plParam) *plParam = MAKELPARAM( 1, flags );
202 if( pwParam) *pwParam = VKey;
203 return message;
204 }
205
206 /****************************** end copy input.c ****************************/
207
208 /*
209 * . prepare the keyevents for SendInputs
210 * . calculate the "expected" messages
211 * . Send the events to our window
212 * . retrieve the messages from the input queue
213 * . verify
214 */
215 static BOOL do_test( HWND hwnd, int seqnr, const KEV td[] )
216 {
217 INPUT inputs[MAXKEYEVENTS];
218 KMSG expmsg[MAXKEYEVENTS];
219 MSG msg;
220 char buf[100];
221 UINT evtctr=0;
222 int kmctr, i;
223
224 buf[0]='\0';
225 TrackSysKey=0; /* see input.c */
226 for( i = 0; i < MAXKEYEVENTS; i++) {
227 ADDTOINPUTS(td[i])
228 strcat(buf, getdesc[td[i]]);
229 if(td[i])
230 expmsg[i].message = KbdMessage(td[i], &(expmsg[i].wParam), &(expmsg[i].lParam));
231 else
232 expmsg[i].message = 0;
233 }
234 for( kmctr = 0; kmctr < MAXKEYEVENTS && expmsg[kmctr].message; kmctr++)
235 ;
236 ok( evtctr <= MAXKEYEVENTS, "evtctr is above MAXKEYEVENTS\n" );
237 if( evtctr != pSendInput(evtctr, &inputs[0], sizeof(INPUT)))
238 ok (FALSE, "SendInput failed to send some events\n");
239 i = 0;
240 if (winetest_debug > 1)
241 trace("======== key stroke sequence #%d: %s =============\n",
242 seqnr + 1, buf);
243 while( PeekMessageA(&msg,hwnd,WM_KEYFIRST,WM_KEYLAST,PM_REMOVE) ) {
244 if (winetest_debug > 1)
245 trace("message[%d] %-15s wParam %04lx lParam %08lx time %x\n", i,
246 MSGNAME[msg.message - WM_KEYFIRST], msg.wParam, msg.lParam, msg.time);
247 if( i < kmctr ) {
248 ok( msg.message == expmsg[i].message &&
249 msg.wParam == expmsg[i].wParam &&
250 msg.lParam == expmsg[i].lParam,
251 "%u/%u: wrong message %x/%08lx/%08lx expected %s/%08lx/%08lx\n",
252 seqnr, i, msg.message, msg.wParam, msg.lParam,
253 MSGNAME[(expmsg[i]).message - WM_KEYFIRST], expmsg[i].wParam, expmsg[i].lParam );
254 }
255 i++;
256 }
257 if (winetest_debug > 1)
258 trace("%d messages retrieved\n", i);
259 if (!i && kmctr)
260 {
261 skip( "simulated keyboard input doesn't work\n" );
262 return FALSE;
263 }
264 ok( i == kmctr, "message count is wrong: got %d expected: %d\n", i, kmctr);
265 return TRUE;
266 }
267
268 /* test all combinations of the specified key events */
269 static BOOL TestASet( HWND hWnd, int nrkev, const KEV kevdwn[], const KEV kevup[] )
270 {
271 int i,j,k,l,m,n;
272 static int count=0;
273 KEV kbuf[MAXKEYEVENTS];
274 assert( nrkev==2 || nrkev==3);
275 for(i=0;i<MAXKEYEVENTS;i++) kbuf[i]=0;
276 /* two keys involved gives 4 test cases */
277 if(nrkev==2) {
278 for(i=0;i<nrkev;i++) {
279 for(j=0;j<nrkev;j++) {
280 kbuf[0] = kevdwn[i];
281 kbuf[1] = kevdwn[1-i];
282 kbuf[2] = kevup[j];
283 kbuf[3] = kevup[1-j];
284 if (!do_test( hWnd, count++, kbuf)) return FALSE;
285 }
286 }
287 }
288 /* three keys involved gives 36 test cases */
289 if(nrkev==3){
290 for(i=0;i<nrkev;i++){
291 for(j=0;j<nrkev;j++){
292 if(j==i) continue;
293 for(k=0;k<nrkev;k++){
294 if(k==i || k==j) continue;
295 for(l=0;l<nrkev;l++){
296 for(m=0;m<nrkev;m++){
297 if(m==l) continue;
298 for(n=0;n<nrkev;n++){
299 if(n==l ||n==m) continue;
300 kbuf[0] = kevdwn[i];
301 kbuf[1] = kevdwn[j];
302 kbuf[2] = kevdwn[k];
303 kbuf[3] = kevup[l];
304 kbuf[4] = kevup[m];
305 kbuf[5] = kevup[n];
306 if (!do_test( hWnd, count++, kbuf)) return FALSE;
307 }
308 }
309 }
310 }
311 }
312 }
313 }
314 return TRUE;
315 }
316
317 /* test each set specified in the global testkeyset array */
318 static void TestSysKeys( HWND hWnd)
319 {
320 int i;
321 for(i=0; testkeyset[i].nrkev;i++)
322 if (!TestASet( hWnd, testkeyset[i].nrkev, testkeyset[i].keydwn, testkeyset[i].keyup)) break;
323 }
324
325 static LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam,
326 LPARAM lParam )
327 {
328 return DefWindowProcA( hWnd, msg, wParam, lParam );
329 }
330
331 static void test_Input_whitebox(void)
332 {
333 MSG msg;
334 WNDCLASSA wclass;
335 HANDLE hInstance = GetModuleHandleA( NULL );
336
337 wclass.lpszClassName = "InputSysKeyTestClass";
338 wclass.style = CS_HREDRAW | CS_VREDRAW;
339 wclass.lpfnWndProc = WndProc;
340 wclass.hInstance = hInstance;
341 wclass.hIcon = LoadIconA( 0, (LPCSTR)IDI_APPLICATION );
342 wclass.hCursor = LoadCursorA( NULL, (LPCSTR)IDC_ARROW );
343 wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );
344 wclass.lpszMenuName = 0;
345 wclass.cbClsExtra = 0;
346 wclass.cbWndExtra = 0;
347 RegisterClassA( &wclass );
348 /* create the test window that will receive the keystrokes */
349 hWndTest = CreateWindowA( wclass.lpszClassName, "InputSysKeyTest",
350 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 100, 100,
351 NULL, NULL, hInstance, NULL);
352 assert( hWndTest );
353 ShowWindow( hWndTest, SW_SHOW);
354 SetWindowPos( hWndTest, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
355 SetForegroundWindow( hWndTest );
356 UpdateWindow( hWndTest);
357
358 /* flush pending messages */
359 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
360
361 SetFocus( hWndTest );
362 TestSysKeys( hWndTest );
363 DestroyWindow(hWndTest);
364 }
365
366 static inline BOOL is_keyboard_message( UINT message )
367 {
368 return (message >= WM_KEYFIRST && message <= WM_KEYLAST);
369 }
370
371 static inline BOOL is_mouse_message( UINT message )
372 {
373 return (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST);
374 }
375
376 /* try to make sure pending X events have been processed before continuing */
377 static void empty_message_queue(void)
378 {
379 MSG msg;
380 int diff = 200;
381 int min_timeout = 50;
382 DWORD time = GetTickCount() + diff;
383
384 while (diff > 0)
385 {
386 if (MsgWaitForMultipleObjects(0, NULL, FALSE, min_timeout, QS_ALLINPUT) == WAIT_TIMEOUT) break;
387 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
388 {
389 if (is_keyboard_message(msg.message) || is_mouse_message(msg.message))
390 ok(msg.time != 0, "message %#x has time set to 0\n", msg.message);
391
392 TranslateMessage(&msg);
393 DispatchMessageA(&msg);
394 }
395 diff = time - GetTickCount();
396 }
397 }
398
399 struct transition_s {
400 WORD wVk;
401 BYTE before_state;
402 BYTE optional;
403 };
404
405 typedef enum {
406 sent=0x1,
407 posted=0x2,
408 parent=0x4,
409 wparam=0x8,
410 lparam=0x10,
411 defwinproc=0x20,
412 beginpaint=0x40,
413 optional=0x80,
414 hook=0x100,
415 winevent_hook=0x200
416 } msg_flags_t;
417
418 struct message {
419 UINT message; /* the WM_* code */
420 msg_flags_t flags; /* message props */
421 WPARAM wParam; /* expected value of wParam */
422 LPARAM lParam; /* expected value of lParam */
423 };
424
425 static const struct sendinput_test_s {
426 WORD wVk;
427 DWORD dwFlags;
428 BOOL _todo_wine;
429 struct transition_s expected_transitions[MAXKEYEVENTS+1];
430 struct message expected_messages[MAXKEYMESSAGES+1];
431 } sendinput_test[] = {
432 /* test ALT+F */
433 /* 0 */
434 {VK_LMENU, 0, FALSE, {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {0}},
435 {{WM_SYSKEYDOWN, hook|wparam, VK_LMENU}, {WM_SYSKEYDOWN}, {0}}},
436 {'F', 0, FALSE, {{'F', 0x00}, {0}},
437 {{WM_SYSKEYDOWN, hook}, {WM_SYSKEYDOWN},
438 {WM_SYSCHAR},
439 {WM_SYSCOMMAND}, {0}}},
440 {'F', KEYEVENTF_KEYUP, FALSE, {{'F', 0x80}, {0}},
441 {{WM_SYSKEYUP, hook}, {WM_SYSKEYUP}, {0}}},
442 {VK_LMENU, KEYEVENTF_KEYUP, FALSE, {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {0}},
443 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
444
445 /* test CTRL+O */
446 /* 4 */
447 {VK_LCONTROL, 0, FALSE, {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}},
448 {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}},
449 {'O', 0, FALSE, {{'O', 0x00}, {0}},
450 {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {WM_CHAR}, {0}}},
451 {'O', KEYEVENTF_KEYUP, FALSE, {{'O', 0x80}, {0}},
452 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
453 {VK_LCONTROL, KEYEVENTF_KEYUP, FALSE, {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}},
454 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
455
456 /* test ALT+CTRL+X */
457 /* 8 */
458 {VK_LMENU, 0, FALSE, {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {0}},
459 {{WM_SYSKEYDOWN, hook}, {WM_SYSKEYDOWN}, {0}}},
460 {VK_LCONTROL, 0, FALSE, {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}},
461 {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}},
462 {'X', 0, FALSE, {{'X', 0x00}, {0}},
463 {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}},
464 {'X', KEYEVENTF_KEYUP, FALSE, {{'X', 0x80}, {0}},
465 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
466 {VK_LCONTROL, KEYEVENTF_KEYUP, FALSE, {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}},
467 {{WM_SYSKEYUP, hook}, {WM_SYSKEYUP}, {0}}},
468 {VK_LMENU, KEYEVENTF_KEYUP, FALSE, {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {0}},
469 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
470
471 /* test SHIFT+A */
472 /* 14 */
473 {VK_LSHIFT, 0, FALSE, {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00}, {0}},
474 {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {0}}},
475 {'A', 0, FALSE, {{'A', 0x00}, {0}},
476 {{WM_KEYDOWN, hook}, {WM_KEYDOWN}, {WM_CHAR}, {0}}},
477 {'A', KEYEVENTF_KEYUP, FALSE, {{'A', 0x80}, {0}},
478 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
479 {VK_LSHIFT, KEYEVENTF_KEYUP, FALSE, {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80}, {0}},
480 {{WM_KEYUP, hook}, {WM_KEYUP}, {0}}},
481 /* test L-SHIFT & R-SHIFT: */
482 /* RSHIFT == LSHIFT */
483 /* 18 */
484 {VK_RSHIFT, 0, FALSE,
485 /* recent windows versions (>= w2k3) correctly report an RSHIFT transition */
486 {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00, TRUE}, {VK_RSHIFT, 0x00, TRUE}, {0}},
487 {{WM_KEYDOWN, hook|wparam, VK_RSHIFT},
488 {WM_KEYDOWN}, {0}}},
489 {VK_RSHIFT, KEYEVENTF_KEYUP, FALSE,
490 {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80, TRUE}, {VK_RSHIFT, 0x80, TRUE}, {0}},
491 {{WM_KEYUP, hook, hook|wparam, VK_RSHIFT},
492 {WM_KEYUP}, {0}}},
493
494 /* LSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
495 /* 20 */
496 {VK_LSHIFT, KEYEVENTF_EXTENDEDKEY, FALSE,
497 {{VK_SHIFT, 0x00}, {VK_RSHIFT, 0x00}, {0}},
498 {{WM_KEYDOWN, hook|wparam|lparam, VK_LSHIFT, LLKHF_EXTENDED},
499 {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}},
500 {VK_LSHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
501 {{VK_SHIFT, 0x80}, {VK_RSHIFT, 0x80}, {0}},
502 {{WM_KEYUP, hook|wparam|lparam, VK_LSHIFT, LLKHF_UP|LLKHF_EXTENDED},
503 {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}},
504 /* RSHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
505 /* 22 */
506 {VK_RSHIFT, KEYEVENTF_EXTENDEDKEY, FALSE,
507 {{VK_SHIFT, 0x00}, {VK_RSHIFT, 0x00}, {0}},
508 {{WM_KEYDOWN, hook|wparam|lparam, VK_RSHIFT, LLKHF_EXTENDED},
509 {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}},
510 {VK_RSHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
511 {{VK_SHIFT, 0x80}, {VK_RSHIFT, 0x80}, {0}},
512 {{WM_KEYUP, hook|wparam|lparam, VK_RSHIFT, LLKHF_UP|LLKHF_EXTENDED},
513 {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}},
514
515 /* Note about wparam for hook with generic key (VK_SHIFT, VK_CONTROL, VK_MENU):
516 win2k - sends to hook whatever we generated here
517 winXP+ - Attempts to convert key to L/R key but not always correct
518 */
519 /* SHIFT == LSHIFT */
520 /* 24 */
521 {VK_SHIFT, 0, FALSE,
522 {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00}, {0}},
523 {{WM_KEYDOWN, hook/* |wparam */|lparam, VK_SHIFT, 0},
524 {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}},
525 {VK_SHIFT, KEYEVENTF_KEYUP, FALSE,
526 {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80}, {0}},
527 {{WM_KEYUP, hook/*|wparam*/|lparam, VK_SHIFT, LLKHF_UP},
528 {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}},
529 /* SHIFT | KEYEVENTF_EXTENDEDKEY == RSHIFT */
530 /* 26 */
531 {VK_SHIFT, KEYEVENTF_EXTENDEDKEY, FALSE,
532 {{VK_SHIFT, 0x00}, {VK_RSHIFT, 0x00}, {0}},
533 {{WM_KEYDOWN, hook/*|wparam*/|lparam, VK_SHIFT, LLKHF_EXTENDED},
534 {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}},
535 {VK_SHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
536 {{VK_SHIFT, 0x80}, {VK_RSHIFT, 0x80}, {0}},
537 {{WM_KEYUP, hook/*|wparam*/|lparam, VK_SHIFT, LLKHF_UP|LLKHF_EXTENDED},
538 {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}},
539
540 /* test L-CONTROL & R-CONTROL: */
541 /* RCONTROL == LCONTROL */
542 /* 28 */
543 {VK_RCONTROL, 0, FALSE,
544 {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}},
545 {{WM_KEYDOWN, hook|wparam, VK_RCONTROL},
546 {WM_KEYDOWN, wparam|lparam, VK_CONTROL, 0}, {0}}},
547 {VK_RCONTROL, KEYEVENTF_KEYUP, FALSE,
548 {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}},
549 {{WM_KEYUP, hook|wparam, VK_RCONTROL},
550 {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP}, {0}}},
551 /* LCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
552 /* 30 */
553 {VK_LCONTROL, KEYEVENTF_EXTENDEDKEY, FALSE,
554 {{VK_CONTROL, 0x00}, {VK_RCONTROL, 0x00}, {0}},
555 {{WM_KEYDOWN, hook|wparam|lparam, VK_LCONTROL, LLKHF_EXTENDED},
556 {WM_KEYDOWN, wparam|lparam, VK_CONTROL, KF_EXTENDED}, {0}}},
557 {VK_LCONTROL, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
558 {{VK_CONTROL, 0x80}, {VK_RCONTROL, 0x80}, {0}},
559 {{WM_KEYUP, hook|wparam|lparam, VK_LCONTROL, LLKHF_UP|LLKHF_EXTENDED},
560 {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP|KF_EXTENDED}, {0}}},
561 /* RCONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
562 /* 32 */
563 {VK_RCONTROL, KEYEVENTF_EXTENDEDKEY, FALSE,
564 {{VK_CONTROL, 0x00}, {VK_RCONTROL, 0x00}, {0}},
565 {{WM_KEYDOWN, hook|wparam|lparam, VK_RCONTROL, LLKHF_EXTENDED},
566 {WM_KEYDOWN, wparam|lparam, VK_CONTROL, KF_EXTENDED}, {0}}},
567 {VK_RCONTROL, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
568 {{VK_CONTROL, 0x80}, {VK_RCONTROL, 0x80}, {0}},
569 {{WM_KEYUP, hook|wparam|lparam, VK_RCONTROL, LLKHF_UP|LLKHF_EXTENDED},
570 {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP|KF_EXTENDED}, {0}}},
571 /* CONTROL == LCONTROL */
572 /* 34 */
573 {VK_CONTROL, 0, FALSE,
574 {{VK_CONTROL, 0x00}, {VK_LCONTROL, 0x00}, {0}},
575 {{WM_KEYDOWN, hook/*|wparam, VK_CONTROL*/},
576 {WM_KEYDOWN, wparam|lparam, VK_CONTROL, 0}, {0}}},
577 {VK_CONTROL, KEYEVENTF_KEYUP, FALSE,
578 {{VK_CONTROL, 0x80}, {VK_LCONTROL, 0x80}, {0}},
579 {{WM_KEYUP, hook/*|wparam, VK_CONTROL*/},
580 {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP}, {0}}},
581 /* CONTROL | KEYEVENTF_EXTENDEDKEY == RCONTROL */
582 /* 36 */
583 {VK_CONTROL, KEYEVENTF_EXTENDEDKEY, FALSE,
584 {{VK_CONTROL, 0x00}, {VK_RCONTROL, 0x00}, {0}},
585 {{WM_KEYDOWN, hook/*|wparam*/|lparam, VK_CONTROL, LLKHF_EXTENDED},
586 {WM_KEYDOWN, wparam|lparam, VK_CONTROL, KF_EXTENDED}, {0}}},
587 {VK_CONTROL, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
588 {{VK_CONTROL, 0x80}, {VK_RCONTROL, 0x80}, {0}},
589 {{WM_KEYUP, hook/*|wparam*/|lparam, VK_CONTROL, LLKHF_UP|LLKHF_EXTENDED},
590 {WM_KEYUP, wparam|lparam, VK_CONTROL, KF_UP|KF_EXTENDED}, {0}}},
591
592 /* test L-MENU & R-MENU: */
593 /* RMENU == LMENU */
594 /* 38 */
595 {VK_RMENU, 0, FALSE,
596 {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {VK_CONTROL, 0x00, 1}, {VK_LCONTROL, 0x01, 1}, {0}},
597 {{WM_SYSKEYDOWN, hook|wparam|optional, VK_LCONTROL},
598 {WM_SYSKEYDOWN, hook|wparam, VK_RMENU},
599 {WM_KEYDOWN, wparam|lparam|optional, VK_CONTROL, 0},
600 {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0}, {0}}},
601 {VK_RMENU, KEYEVENTF_KEYUP, TRUE,
602 {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {VK_CONTROL, 0x81, 1}, {VK_LCONTROL, 0x80, 1}, {0}},
603 {{WM_KEYUP, hook|wparam|optional, VK_LCONTROL},
604 {WM_KEYUP, hook|wparam, VK_RMENU},
605 {WM_SYSKEYUP, wparam|lparam|optional, VK_CONTROL, KF_UP},
606 {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP},
607 {WM_SYSCOMMAND, optional}, {0}}},
608 /* LMENU | KEYEVENTF_EXTENDEDKEY == RMENU */
609 /* 40 */
610 {VK_LMENU, KEYEVENTF_EXTENDEDKEY, FALSE,
611 {{VK_MENU, 0x00}, {VK_RMENU, 0x00}, {0}},
612 {{WM_SYSKEYDOWN, hook|wparam|lparam, VK_LMENU, LLKHF_EXTENDED},
613 {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, KF_EXTENDED}, {0}}},
614 {VK_LMENU, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, TRUE,
615 {{VK_MENU, 0x80}, {VK_RMENU, 0x80}, {0}},
616 {{WM_KEYUP, hook|wparam|lparam, VK_LMENU, LLKHF_UP|LLKHF_EXTENDED},
617 {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP|KF_EXTENDED},
618 {WM_SYSCOMMAND}, {0}}},
619 /* RMENU | KEYEVENTF_EXTENDEDKEY == RMENU */
620 /* 42 */
621 {VK_RMENU, KEYEVENTF_EXTENDEDKEY, FALSE,
622 {{VK_MENU, 0x00}, {VK_RMENU, 0x00}, {VK_CONTROL, 0x00, 1}, {VK_LCONTROL, 0x01, 1}, {0}},
623 {{WM_SYSKEYDOWN, hook|wparam|lparam|optional, VK_LCONTROL, 0},
624 {WM_SYSKEYDOWN, hook|wparam|lparam, VK_RMENU, LLKHF_EXTENDED},
625 {WM_KEYDOWN, wparam|lparam|optional, VK_CONTROL, 0},
626 {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, KF_EXTENDED}, {0}}},
627 {VK_RMENU, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, TRUE,
628 {{VK_MENU, 0x80}, {VK_RMENU, 0x80}, {VK_CONTROL, 0x81, 1}, {VK_LCONTROL, 0x80, 1}, {0}},
629 {{WM_KEYUP, hook|wparam|lparam|optional, VK_LCONTROL, LLKHF_UP},
630 {WM_KEYUP, hook|wparam|lparam, VK_RMENU, LLKHF_UP|LLKHF_EXTENDED},
631 {WM_SYSKEYUP, wparam|lparam|optional, VK_CONTROL, KF_UP},
632 {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP|KF_EXTENDED},
633 {WM_SYSCOMMAND, optional}, {0}}},
634 /* MENU == LMENU */
635 /* 44 */
636 {VK_MENU, 0, FALSE,
637 {{VK_MENU, 0x00}, {VK_LMENU, 0x00}, {0}},
638 {{WM_SYSKEYDOWN, hook/*|wparam, VK_MENU*/},
639 {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0}, {0}}},
640 {VK_MENU, KEYEVENTF_KEYUP, TRUE,
641 {{VK_MENU, 0x80}, {VK_LMENU, 0x80}, {0}},
642 {{WM_KEYUP, hook/*|wparam, VK_MENU*/},
643 {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP},
644 {WM_SYSCOMMAND}, {0}}},
645 /* MENU | KEYEVENTF_EXTENDEDKEY == RMENU */
646 /* 46 */
647 {VK_MENU, KEYEVENTF_EXTENDEDKEY, FALSE,
648 {{VK_MENU, 0x00}, {VK_RMENU, 0x00}, {VK_CONTROL, 0x00, 1}, {VK_LCONTROL, 0x01, 1}, {0}},
649 {{WM_SYSKEYDOWN, hook|wparam|lparam|optional, VK_CONTROL, 0},
650 {WM_SYSKEYDOWN, hook/*|wparam*/|lparam, VK_MENU, LLKHF_EXTENDED},
651 {WM_SYSKEYDOWN, wparam|lparam, VK_MENU, KF_EXTENDED}, {0}}},
652 {VK_MENU, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, TRUE,
653 {{VK_MENU, 0x80}, {VK_RMENU, 0x80}, {VK_CONTROL, 0x81, 1}, {VK_LCONTROL, 0x80, 1}, {0}},
654 {{WM_KEYUP, hook|wparam|lparam|optional, VK_CONTROL, LLKHF_UP},
655 {WM_KEYUP, hook/*|wparam*/|lparam, VK_MENU, LLKHF_UP|LLKHF_EXTENDED},
656 {WM_SYSKEYUP, wparam|lparam, VK_MENU, KF_UP|KF_EXTENDED},
657 {WM_SYSCOMMAND}, {0}}},
658
659 /* test LSHIFT & RSHIFT */
660 /* 48 */
661 {VK_LSHIFT, 0, FALSE,
662 {{VK_SHIFT, 0x00}, {VK_LSHIFT, 0x00}, {0}},
663 {{WM_KEYDOWN, hook|wparam|lparam, VK_LSHIFT, 0},
664 {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}},
665 {VK_RSHIFT, KEYEVENTF_EXTENDEDKEY, FALSE,
666 {{VK_RSHIFT, 0x00}, {0}},
667 {{WM_KEYDOWN, hook|wparam|lparam, VK_RSHIFT, LLKHF_EXTENDED},
668 {WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0}, {0}}},
669 {VK_RSHIFT, KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY, FALSE,
670 {{VK_RSHIFT, 0x80}, {0}},
671 {{WM_KEYUP, hook|wparam|lparam, VK_RSHIFT, LLKHF_UP|LLKHF_EXTENDED},
672 {WM_KEYUP, optional}, {0}}},
673 {VK_LSHIFT, KEYEVENTF_KEYUP, FALSE,
674 {{VK_SHIFT, 0x80}, {VK_LSHIFT, 0x80}, {0}},
675 {{WM_KEYUP, hook|wparam, VK_LSHIFT},
676 {WM_KEYUP, wparam|lparam, VK_SHIFT, KF_UP}, {0}}},
677
678 {0, 0, FALSE, {{0}}, {{0}}} /* end */
679 };
680
681 static struct message sent_messages[MAXKEYMESSAGES];
682 static UINT sent_messages_cnt;
683
684 /* Verify that only specified key state transitions occur */
685 static void compare_and_check(int id, BYTE *ks1, BYTE *ks2, const struct sendinput_test_s *test)
686 {
687 int i, failcount = 0;
688 const struct transition_s *t = test->expected_transitions;
689 UINT actual_cnt = 0;
690 const struct message *expected = test->expected_messages;
691
692 while (t->wVk) {
693 BOOL matched = ((ks1[t->wVk]&0x80) == (t->before_state&0x80)
694 && (ks2[t->wVk]&0x80) == (~t->before_state&0x80));
695
696 if (!matched && !t->optional && test->_todo_wine)
697 {
698 failcount++;
699 todo_wine {
700 ok(matched, "%2d (%x/%x): %02x from %02x -> %02x "
701 "instead of %02x -> %02x\n", id, test->wVk, test->dwFlags,
702 t->wVk, ks1[t->wVk]&0x80, ks2[t->wVk]&0x80, t->before_state,
703 ~t->before_state&0x80);
704 }
705 } else {
706 ok(matched || t->optional, "%2d (%x/%x): %02x from %02x -> %02x "
707 "instead of %02x -> %02x\n", id, test->wVk, test->dwFlags,
708 t->wVk, ks1[t->wVk]&0x80, ks2[t->wVk]&0x80, t->before_state,
709 ~t->before_state&0x80);
710 }
711 ks2[t->wVk] = ks1[t->wVk]; /* clear the match */
712 t++;
713 }
714 for (i = 0; i < 256; i++)
715 if (ks2[i] != ks1[i] && test->_todo_wine)
716 {
717 failcount++;
718 todo_wine
719 ok(FALSE, "%2d (%x/%x): %02x from %02x -> %02x unexpected\n",
720 id, test->wVk, test->dwFlags, i, ks1[i], ks2[i]);
721 }
722 else
723 ok(ks2[i] == ks1[i], "%2d (%x/%x): %02x from %02x -> %02x unexpected\n",
724 id, test->wVk, test->dwFlags, i, ks1[i], ks2[i]);
725
726 while (expected->message && actual_cnt < sent_messages_cnt)
727 {
728 const struct message *actual = &sent_messages[actual_cnt];
729
730 if (expected->message == actual->message)
731 {
732 if (expected->flags & wparam)
733 {
734 if ((expected->flags & optional) && (expected->wParam != actual->wParam))
735 {
736 expected++;
737 continue;
738 }
739 if (expected->wParam != actual->wParam && test->_todo_wine)
740 {
741 failcount++;
742 todo_wine
743 ok(FALSE, "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
744 id, test->wVk, test->dwFlags, expected->message, expected->wParam, actual->wParam);
745 }
746 else
747 ok(expected->wParam == actual->wParam,
748 "%2d (%x/%x): in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
749 id, test->wVk, test->dwFlags, expected->message, expected->wParam, actual->wParam);
750 }
751 if (expected->flags & lparam)
752 {
753 if (expected->lParam != actual->lParam && test->_todo_wine)
754 {
755 failcount++;
756 todo_wine
757 ok(FALSE, "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
758 id, test->wVk, test->dwFlags, expected->message, expected->lParam, actual->lParam);
759 }
760 else
761 ok(expected->lParam == actual->lParam,
762 "%2d (%x/%x): in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
763 id, test->wVk, test->dwFlags, expected->message, expected->lParam, actual->lParam);
764 }
765 ok((expected->flags & hook) == (actual->flags & hook),
766 "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n",
767 id, test->wVk, test->dwFlags, expected->message);
768
769 }
770 else if (expected->flags & optional)
771 {
772 expected++;
773 continue;
774 }
775 /* NT4 doesn't send SYSKEYDOWN/UP to hooks, only KEYDOWN/UP */
776 else if ((expected->flags & hook) &&
777 (expected->message == WM_SYSKEYDOWN || expected->message == WM_SYSKEYUP) &&
778 (actual->message == expected->message - 4))
779 {
780 ok((expected->flags & hook) == (actual->flags & hook),
781 "%2d (%x/%x): the msg 0x%04x should have been sent by a hook\n",
782 id, test->wVk, test->dwFlags, expected->message);
783 }
784 /* For VK_RMENU, at least localized Win2k/XP sends KEYDOWN/UP
785 * instead of SYSKEYDOWN/UP to the WNDPROC */
786 else if (test->wVk == VK_RMENU && !(expected->flags & hook) &&
787 (expected->message == WM_SYSKEYDOWN || expected->message == WM_SYSKEYUP) &&
788 (actual->message == expected->message - 4))
789 {
790 ok(expected->wParam == actual->wParam && expected->lParam == actual->lParam,
791 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
792 id, test->wVk, test->dwFlags, expected->message, actual->message);
793 }
794 else if (test->_todo_wine)
795 {
796 failcount++;
797 todo_wine
798 ok(FALSE,
799 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
800 id, test->wVk, test->dwFlags, expected->message, actual->message);
801 }
802 else
803 ok(FALSE,
804 "%2d (%x/%x): the msg 0x%04x was expected, but got msg 0x%04x instead\n",
805 id, test->wVk, test->dwFlags, expected->message, actual->message);
806
807 actual_cnt++;
808 expected++;
809 }
810 /* skip all optional trailing messages */
811 while (expected->message && (expected->flags & optional))
812 expected++;
813
814
815 if (expected->message || actual_cnt < sent_messages_cnt)
816 {
817 if (test->_todo_wine)
818 {
819 failcount++;
820 todo_wine
821 ok(FALSE, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n",
822 id, test->wVk, test->dwFlags, expected->message, sent_messages[actual_cnt].message);
823 }
824 else
825 ok(FALSE, "%2d (%x/%x): the msg sequence is not complete: expected %04x - actual %04x\n",
826 id, test->wVk, test->dwFlags, expected->message, sent_messages[actual_cnt].message);
827 }
828
829 if( test->_todo_wine && !failcount) /* succeeded yet marked todo */
830 todo_wine
831 ok(TRUE, "%2d (%x/%x): marked \"todo_wine\" but succeeds\n", id, test->wVk, test->dwFlags);
832
833 sent_messages_cnt = 0;
834 }
835
836 /* WndProc2 checks that we get at least the messages specified */
837 static LRESULT CALLBACK WndProc2(HWND hWnd, UINT Msg, WPARAM wParam,
838 LPARAM lParam)
839 {
840 if (winetest_debug > 1) trace("MSG: %8x W:%8lx L:%8lx\n", Msg, wParam, lParam);
841
842 if (Msg != WM_PAINT &&
843 Msg != WM_NCPAINT &&
844 Msg != WM_SYNCPAINT &&
845 Msg != WM_ERASEBKGND &&
846 Msg != WM_NCHITTEST &&
847 Msg != WM_GETTEXT &&
848 Msg != WM_GETICON &&
849 Msg != WM_IME_SELECT &&
850 Msg != WM_DEVICECHANGE &&
851 Msg != WM_TIMECHANGE)
852 {
853 ok(sent_messages_cnt < MAXKEYMESSAGES, "Too many messages\n");
854 if (sent_messages_cnt < MAXKEYMESSAGES)
855 {
856 sent_messages[sent_messages_cnt].message = Msg;
857 sent_messages[sent_messages_cnt].flags = 0;
858 sent_messages[sent_messages_cnt].wParam = wParam;
859 sent_messages[sent_messages_cnt++].lParam = HIWORD(lParam) & (KF_UP|KF_EXTENDED);
860 }
861 }
862 return DefWindowProcA(hWnd, Msg, wParam, lParam);
863 }
864
865 static LRESULT CALLBACK hook_proc(int code, WPARAM wparam, LPARAM lparam)
866 {
867 KBDLLHOOKSTRUCT *hook_info = (KBDLLHOOKSTRUCT *)lparam;
868
869 if (code == HC_ACTION)
870 {
871 ok(sent_messages_cnt < MAXKEYMESSAGES, "Too many messages\n");
872 if (sent_messages_cnt < MAXKEYMESSAGES)
873 {
874 sent_messages[sent_messages_cnt].message = wparam;
875 sent_messages[sent_messages_cnt].flags = hook;
876 sent_messages[sent_messages_cnt].wParam = hook_info->vkCode;
877 sent_messages[sent_messages_cnt++].lParam = hook_info->flags & (LLKHF_UP|LLKHF_EXTENDED);
878 }
879
880 if(0) /* For some reason not stable on Wine */
881 {
882 if (wparam == WM_KEYDOWN || wparam == WM_SYSKEYDOWN)
883 ok(!(GetAsyncKeyState(hook_info->vkCode) & 0x8000), "key %x should be up\n", hook_info->vkCode);
884 else if (wparam == WM_KEYUP || wparam == WM_SYSKEYUP)
885 ok(GetAsyncKeyState(hook_info->vkCode) & 0x8000, "key %x should be down\n", hook_info->vkCode);
886 }
887
888 if (winetest_debug > 1)
889 trace("Hook: w=%lx vk:%8x sc:%8x fl:%8x %lx\n", wparam,
890 hook_info->vkCode, hook_info->scanCode, hook_info->flags, hook_info->dwExtraInfo);
891 }
892 return CallNextHookEx( 0, code, wparam, lparam );
893 }
894 static void test_Input_blackbox(void)
895 {
896 TEST_INPUT i;
897 int ii;
898 BYTE ks1[256], ks2[256];
899 LONG_PTR prevWndProc;
900 HWND window;
901 HHOOK hook;
902
903 if (GetKeyboardLayout(0) != (HKL)(ULONG_PTR)0x04090409)
904 {
905 skip("Skipping Input_blackbox test on non-US keyboard\n");
906 return;
907 }
908 window = CreateWindowA("Static", NULL, WS_POPUP|WS_HSCROLL|WS_VSCROLL
909 |WS_VISIBLE, 0, 0, 200, 60, NULL, NULL,
910 NULL, NULL);
911 ok(window != NULL, "error: %d\n", (int) GetLastError());
912 SetWindowPos( window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
913 SetForegroundWindow( window );
914
915 if (!(hook = SetWindowsHookExA(WH_KEYBOARD_LL, hook_proc, GetModuleHandleA( NULL ), 0)))
916 {
917 DestroyWindow(window);
918 win_skip("WH_KEYBOARD_LL is not supported\n");
919 return;
920 }
921
922 /* must process all initial messages, otherwise X11DRV_KeymapNotify unsets
923 * key state set by SendInput(). */
924 empty_message_queue();
925
926 prevWndProc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR) WndProc2);
927 ok(prevWndProc != 0 || (prevWndProc == 0 && GetLastError() == 0),
928 "error: %d\n", (int) GetLastError());
929
930 i.type = INPUT_KEYBOARD;
931 i.u.ki.time = 0;
932 i.u.ki.dwExtraInfo = 0;
933
934 for (ii = 0; ii < sizeof(sendinput_test)/sizeof(struct sendinput_test_s)-1;
935 ii++) {
936 GetKeyboardState(ks1);
937 i.u.ki.wScan = ii+1 /* useful for debugging */;
938 i.u.ki.dwFlags = sendinput_test[ii].dwFlags;
939 i.u.ki.wVk = sendinput_test[ii].wVk;
940 pSendInput(1, (INPUT*)&i, sizeof(TEST_INPUT));
941 empty_message_queue();
942 GetKeyboardState(ks2);
943 if (!ii && sent_messages_cnt <= 1 && !memcmp( ks1, ks2, sizeof(ks1) ))
944 {
945 win_skip( "window doesn't receive the queued input\n" );
946 /* release the key */
947 i.u.ki.dwFlags |= KEYEVENTF_KEYUP;
948 pSendInput(1, (INPUT*)&i, sizeof(TEST_INPUT));
949 break;
950 }
951 compare_and_check(ii, ks1, ks2, &sendinput_test[ii]);
952 }
953
954 empty_message_queue();
955 DestroyWindow(window);
956 UnhookWindowsHookEx(hook);
957 }
958
959 static void reset_key_status(void)
960 {
961 key_status.last_key_down = -1;
962 key_status.last_key_up = -1;
963 key_status.last_syskey_down = -1;
964 key_status.last_syskey_up = -1;
965 key_status.last_char = -1;
966 key_status.last_syschar = -1;
967 key_status.last_hook_down = -1;
968 key_status.last_hook_up = -1;
969 key_status.last_hook_syskey_down = -1;
970 key_status.last_hook_syskey_up = -1;
971 key_status.expect_alt = FALSE;
972 key_status.sendinput_broken = FALSE;
973 }
974
975 static void test_unicode_keys(HWND hwnd, HHOOK hook)
976 {
977 TEST_INPUT inputs[2];
978 MSG msg;
979
980 /* init input data that never changes */
981 inputs[1].type = inputs[0].type = INPUT_KEYBOARD;
982 inputs[1].u.ki.dwExtraInfo = inputs[0].u.ki.dwExtraInfo = 0;
983 inputs[1].u.ki.time = inputs[0].u.ki.time = 0;
984
985 /* pressing & releasing a single unicode character */
986 inputs[0].u.ki.wVk = 0;
987 inputs[0].u.ki.wScan = 0x3c0;
988 inputs[0].u.ki.dwFlags = KEYEVENTF_UNICODE;
989
990 reset_key_status();
991 pSendInput(1, (INPUT*)inputs, sizeof(INPUT));
992 while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){
993 if(msg.message == WM_KEYDOWN && msg.wParam == VK_PACKET){
994 TranslateMessage(&msg);
995 }
996 DispatchMessageW(&msg);
997 }
998 if(!key_status.sendinput_broken){
999 ok(key_status.last_key_down == VK_PACKET,
1000 "Last keydown msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_key_down);
1001 ok(key_status.last_char == 0x3c0,
1002 "Last char msg wparam should have been 0x3c0 (was: 0x%x)\n", key_status.last_char);
1003 if(hook)
1004 ok(key_status.last_hook_down == 0x3c0,
1005 "Last hookdown msg should have been 0x3c0, was: 0x%x\n", key_status.last_hook_down);
1006 }
1007
1008 inputs[1].u.ki.wVk = 0;
1009 inputs[1].u.ki.wScan = 0x3c0;
1010 inputs[1].u.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP;
1011
1012 reset_key_status();
1013 pSendInput(1, (INPUT*)(inputs+1), sizeof(INPUT));
1014 while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){
1015 if(msg.message == WM_KEYDOWN && msg.wParam == VK_PACKET){
1016 TranslateMessage(&msg);
1017 }
1018 DispatchMessageW(&msg);
1019 }
1020 if(!key_status.sendinput_broken){
1021 ok(key_status.last_key_up == VK_PACKET,
1022 "Last keyup msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_key_up);
1023 if(hook)
1024 ok(key_status.last_hook_up == 0x3c0,
1025 "Last hookup msg should have been 0x3c0, was: 0x%x\n", key_status.last_hook_up);
1026 }
1027
1028 /* holding alt, pressing & releasing a unicode character, releasing alt */
1029 inputs[0].u.ki.wVk = VK_LMENU;
1030 inputs[0].u.ki.wScan = 0;
1031 inputs[0].u.ki.dwFlags = 0;
1032
1033 inputs[1].u.ki.wVk = 0;
1034 inputs[1].u.ki.wScan = 0x3041;
1035 inputs[1].u.ki.dwFlags = KEYEVENTF_UNICODE;
1036
1037 reset_key_status();
1038 key_status.expect_alt = TRUE;
1039 pSendInput(2, (INPUT*)inputs, sizeof(INPUT));
1040 while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){
1041 if(msg.message == WM_SYSKEYDOWN && msg.wParam == VK_PACKET){
1042 TranslateMessage(&msg);
1043 }
1044 DispatchMessageW(&msg);
1045 }
1046 if(!key_status.sendinput_broken){
1047 ok(key_status.last_syskey_down == VK_PACKET,
1048 "Last syskeydown msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_syskey_down);
1049 ok(key_status.last_syschar == 0x3041,
1050 "Last syschar msg should have been 0x3041 (was: 0x%x)\n", key_status.last_syschar);
1051 if(hook)
1052 ok(key_status.last_hook_syskey_down == 0x3041,
1053 "Last hooksysdown msg should have been 0x3041, was: 0x%x\n", key_status.last_hook_syskey_down);
1054 }
1055
1056 inputs[1].u.ki.wVk = 0;
1057 inputs[1].u.ki.wScan = 0x3041;
1058 inputs[1].u.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP;
1059
1060 inputs[0].u.ki.wVk = VK_LMENU;
1061 inputs[0].u.ki.wScan = 0;
1062 inputs[0].u.ki.dwFlags = KEYEVENTF_KEYUP;
1063
1064 reset_key_status();
1065 key_status.expect_alt = TRUE;
1066 pSendInput(2, (INPUT*)inputs, sizeof(INPUT));
1067 while(PeekMessageW(&msg, hwnd, 0, 0, PM_REMOVE)){
1068 if(msg.message == WM_SYSKEYDOWN && msg.wParam == VK_PACKET){
1069 TranslateMessage(&msg);
1070 }
1071 DispatchMessageW(&msg);
1072 }
1073 if(!key_status.sendinput_broken){
1074 ok(key_status.last_key_up == VK_PACKET,
1075 "Last keyup msg should have been VK_PACKET[0x%04x] (was: 0x%x)\n", VK_PACKET, key_status.last_key_up);
1076 if(hook)
1077 ok(key_status.last_hook_up == 0x3041,
1078 "Last hook up msg should have been 0x3041, was: 0x%x\n", key_status.last_hook_up);
1079 }
1080 }
1081
1082 static LRESULT CALLBACK unicode_wnd_proc( HWND hWnd, UINT msg, WPARAM wParam,
1083 LPARAM lParam )
1084 {
1085 switch(msg){
1086 case WM_KEYDOWN:
1087 key_status.last_key_down = wParam;
1088 break;
1089 case WM_SYSKEYDOWN:
1090 key_status.last_syskey_down = wParam;
1091 break;
1092 case WM_KEYUP:
1093 key_status.last_key_up = wParam;
1094 break;
1095 case WM_SYSKEYUP:
1096 key_status.last_syskey_up = wParam;
1097 break;
1098 case WM_CHAR:
1099 key_status.last_char = wParam;
1100 break;
1101 case WM_SYSCHAR:
1102 key_status.last_syschar = wParam;
1103 break;
1104 }
1105 return DefWindowProcW(hWnd, msg, wParam, lParam);
1106 }
1107
1108 static LRESULT CALLBACK llkbd_unicode_hook(int nCode, WPARAM wParam, LPARAM lParam)
1109 {
1110 if(nCode == HC_ACTION){
1111 LPKBDLLHOOKSTRUCT info = (LPKBDLLHOOKSTRUCT)lParam;
1112 if(!info->vkCode){
1113 key_status.sendinput_broken = TRUE;
1114 win_skip("SendInput doesn't support unicode on this platform\n");
1115 }else{
1116 if(key_status.expect_alt){
1117 ok(info->vkCode == VK_LMENU, "vkCode should have been VK_LMENU[0x%04x], was: 0x%x\n", VK_LMENU, info->vkCode);
1118 key_status.expect_alt = FALSE;
1119 }else
1120 ok(info->vkCode == VK_PACKET, "vkCode should have been VK_PACKET[0x%04x], was: 0x%x\n", VK_PACKET, info->vkCode);
1121 }
1122 switch(wParam){
1123 case WM_KEYDOWN:
1124 key_status.last_hook_down = info->scanCode;
1125 break;
1126 case WM_KEYUP:
1127 key_status.last_hook_up = info->scanCode;
1128 break;
1129 case WM_SYSKEYDOWN:
1130 key_status.last_hook_syskey_down = info->scanCode;
1131 break;
1132 case WM_SYSKEYUP:
1133 key_status.last_hook_syskey_up = info->scanCode;
1134 break;
1135 }
1136 }
1137 return CallNextHookEx(NULL, nCode, wParam, lParam);
1138 }
1139
1140 static void test_Input_unicode(void)
1141 {
1142 WCHAR classNameW[] = {'I','n','p','u','t','U','n','i','c','o','d','e',
1143 'K','e','y','T','e','s','t','C','l','a','s','s',0};
1144 WCHAR windowNameW[] = {'I','n','p','u','t','U','n','i','c','o','d','e',
1145 'K','e','y','T','e','s','t',0};
1146 MSG msg;
1147 WNDCLASSW wclass;
1148 HANDLE hInstance = GetModuleHandleW(NULL);
1149 HHOOK hook;
1150 HMODULE hModuleImm32;
1151 BOOL (WINAPI *pImmDisableIME)(DWORD);
1152
1153 wclass.lpszClassName = classNameW;
1154 wclass.style = CS_HREDRAW | CS_VREDRAW;
1155 wclass.lpfnWndProc = unicode_wnd_proc;
1156 wclass.hInstance = hInstance;
1157 wclass.hIcon = LoadIconW(0, (LPCWSTR)IDI_APPLICATION);
1158 wclass.hCursor = LoadCursorW( NULL, (LPCWSTR)IDC_ARROW);
1159 wclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1160 wclass.lpszMenuName = 0;
1161 wclass.cbClsExtra = 0;
1162 wclass.cbWndExtra = 0;
1163 if(!RegisterClassW(&wclass)){
1164 win_skip("Unicode functions not supported\n");
1165 return;
1166 }
1167
1168 hModuleImm32 = LoadLibraryA("imm32.dll");
1169 if (hModuleImm32) {
1170 pImmDisableIME = (void *)GetProcAddress(hModuleImm32, "ImmDisableIME");
1171 if (pImmDisableIME)
1172 pImmDisableIME(0);
1173 }
1174 pImmDisableIME = NULL;
1175 FreeLibrary(hModuleImm32);
1176
1177 /* create the test window that will receive the keystrokes */
1178 hWndTest = CreateWindowW(wclass.lpszClassName, windowNameW,
1179 WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 100, 100,
1180 NULL, NULL, hInstance, NULL);
1181
1182 assert(hWndTest);
1183 assert(IsWindowUnicode(hWndTest));
1184
1185 hook = SetWindowsHookExW(WH_KEYBOARD_LL, llkbd_unicode_hook, GetModuleHandleW(NULL), 0);
1186 if(!hook)
1187 win_skip("unable to set WH_KEYBOARD_LL hook\n");
1188
1189 ShowWindow(hWndTest, SW_SHOW);
1190 SetWindowPos(hWndTest, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);
1191 SetForegroundWindow(hWndTest);
1192 UpdateWindow(hWndTest);
1193
1194 /* flush pending messages */
1195 while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageW(&msg);
1196
1197 SetFocus(hWndTest);
1198
1199 test_unicode_keys(hWndTest, hook);
1200
1201 if(hook)
1202 UnhookWindowsHookEx(hook);
1203 DestroyWindow(hWndTest);
1204 }
1205
1206 static void test_keynames(void)
1207 {
1208 int i, len;
1209 char buff[256];
1210
1211 for (i = 0; i < 512; i++)
1212 {
1213 strcpy(buff, "----");
1214 len = GetKeyNameTextA(i << 16, buff, sizeof(buff));
1215 ok(len || !buff[0], "%d: Buffer is not zeroed\n", i);
1216 }
1217 }
1218
1219 static POINT pt_old, pt_new;
1220 static BOOL clipped;
1221 #define STEP 3
1222
1223 static LRESULT CALLBACK hook_proc1( int code, WPARAM wparam, LPARAM lparam )
1224 {
1225 MSLLHOOKSTRUCT *hook = (MSLLHOOKSTRUCT *)lparam;
1226 POINT pt, pt1;
1227
1228 if (code == HC_ACTION)
1229 {
1230 /* This is our new cursor position */
1231 pt_new = hook->pt;
1232 /* Should return previous position */
1233 GetCursorPos(&pt);
1234 ok(pt.x == pt_old.x && pt.y == pt_old.y, "GetCursorPos: (%d,%d)\n", pt.x, pt.y);
1235
1236 /* Should set new position until hook chain is finished. */
1237 pt.x = pt_old.x + STEP;
1238 pt.y = pt_old.y + STEP;
1239 SetCursorPos(pt.x, pt.y);
1240 GetCursorPos(&pt1);
1241 if (clipped)
1242 ok(pt1.x == pt_old.x && pt1.y == pt_old.y, "Wrong set pos: (%d,%d)\n", pt1.x, pt1.y);
1243 else
1244 ok(pt1.x == pt.x && pt1.y == pt.y, "Wrong set pos: (%d,%d)\n", pt1.x, pt1.y);
1245 }
1246 return CallNextHookEx( 0, code, wparam, lparam );
1247 }
1248
1249 static LRESULT CALLBACK hook_proc2( int code, WPARAM wparam, LPARAM lparam )
1250 {
1251 MSLLHOOKSTRUCT *hook = (MSLLHOOKSTRUCT *)lparam;
1252 POINT pt;
1253
1254 if (code == HC_ACTION)
1255 {
1256 ok(hook->pt.x == pt_new.x && hook->pt.y == pt_new.y,
1257 "Wrong hook coords: (%d %d) != (%d,%d)\n", hook->pt.x, hook->pt.y, pt_new.x, pt_new.y);
1258
1259 /* Should match position set above */
1260 GetCursorPos(&pt);
1261 if (clipped)
1262 ok(pt.x == pt_old.x && pt.y == pt_old.y, "GetCursorPos: (%d,%d)\n", pt.x, pt.y);
1263 else
1264 ok(pt.x == pt_old.x +STEP && pt.y == pt_old.y +STEP, "GetCursorPos: (%d,%d)\n", pt.x, pt.y);
1265 }
1266 return CallNextHookEx( 0, code, wparam, lparam );
1267 }
1268
1269 static void test_mouse_ll_hook(void)
1270 {
1271 HWND hwnd;
1272 HHOOK hook1, hook2;
1273 POINT pt_org, pt;
1274 RECT rc;
1275
1276 GetCursorPos(&pt_org);
1277 hwnd = CreateWindowA("static", "Title", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
1278 10, 10, 200, 200, NULL, NULL, NULL, NULL);
1279 SetCursorPos(100, 100);
1280
1281 if (!(hook2 = SetWindowsHookExA(WH_MOUSE_LL, hook_proc2, GetModuleHandleA(0), 0)))
1282 {
1283 win_skip( "cannot set MOUSE_LL hook\n" );
1284 goto done;
1285 }
1286 hook1 = SetWindowsHookExA(WH_MOUSE_LL, hook_proc1, GetModuleHandleA(0), 0);
1287
1288 GetCursorPos(&pt_old);
1289 mouse_event(MOUSEEVENTF_MOVE, -STEP, 0, 0, 0);
1290 GetCursorPos(&pt_old);
1291 ok(pt_old.x == pt_new.x && pt_old.y == pt_new.y, "Wrong new pos: (%d,%d)\n", pt_old.x, pt_old.y);
1292 mouse_event(MOUSEEVENTF_MOVE, +STEP, 0, 0, 0);
1293 GetCursorPos(&pt_old);
1294 ok(pt_old.x == pt_new.x && pt_old.y == pt_new.y, "Wrong new pos: (%d,%d)\n", pt_old.x, pt_old.y);
1295 mouse_event(MOUSEEVENTF_MOVE, 0, -STEP, 0, 0);
1296 GetCursorPos(&pt_old);
1297 ok(pt_old.x == pt_new.x && pt_old.y == pt_new.y, "Wrong new pos: (%d,%d)\n", pt_old.x, pt_old.y);
1298 mouse_event(MOUSEEVENTF_MOVE, 0, +STEP, 0, 0);
1299 GetCursorPos(&pt_old);
1300 ok(pt_old.x == pt_new.x && pt_old.y == pt_new.y, "Wrong new pos: (%d,%d)\n", pt_old.x, pt_old.y);
1301
1302 SetRect(&rc, 50, 50, 151, 151);
1303 ClipCursor(&rc);
1304 clipped = TRUE;
1305
1306 SetCursorPos(40, 40);
1307 GetCursorPos(&pt_old);
1308 ok(pt_old.x == 50 && pt_old.y == 50, "Wrong new pos: (%d,%d)\n", pt_new.x, pt_new.y);
1309 SetCursorPos(160, 160);
1310 GetCursorPos(&pt_old);
1311 ok(pt_old.x == 150 && pt_old.y == 150, "Wrong new pos: (%d,%d)\n", pt_new.x, pt_new.y);
1312 mouse_event(MOUSEEVENTF_MOVE, +STEP, +STEP, 0, 0);
1313 GetCursorPos(&pt_old);
1314 ok(pt_old.x == 150 && pt_old.y == 150, "Wrong new pos: (%d,%d)\n", pt_new.x, pt_new.y);
1315
1316 clipped = FALSE;
1317 pt_new.x = pt_new.y = 150;
1318 ClipCursor(NULL);
1319 UnhookWindowsHookEx(hook1);
1320
1321 /* Now check that mouse buttons do not change mouse position
1322 if we don't have MOUSEEVENTF_MOVE flag specified. */
1323
1324 /* We reusing the same hook callback, so make it happy */
1325 pt_old.x = pt_new.x - STEP;
1326 pt_old.y = pt_new.y - STEP;
1327 mouse_event(MOUSEEVENTF_LEFTUP, 123, 456, 0, 0);
1328 GetCursorPos(&pt);
1329 ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y);
1330 mouse_event(MOUSEEVENTF_RIGHTUP, 456, 123, 0, 0);
1331 GetCursorPos(&pt);
1332 ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y);
1333
1334 mouse_event(MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE, 123, 456, 0, 0);
1335 GetCursorPos(&pt);
1336 ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y);
1337 mouse_event(MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE, 456, 123, 0, 0);
1338 GetCursorPos(&pt);
1339 ok(pt.x == pt_new.x && pt.y == pt_new.y, "Position changed: (%d,%d)\n", pt.x, pt.y);
1340
1341 UnhookWindowsHookEx(hook2);
1342 done:
1343 DestroyWindow(hwnd);
1344 SetCursorPos(pt_org.x, pt_org.y);
1345 }
1346
1347 static void test_GetMouseMovePointsEx(void)
1348 {
1349 #define BUFLIM 64
1350 #define MYERROR 0xdeadbeef
1351 int count, retval;
1352 MOUSEMOVEPOINT in;
1353 MOUSEMOVEPOINT out[200];
1354 POINT point;
1355
1356 /* Get a valid content for the input struct */
1357 if(!GetCursorPos(&point)) {
1358 win_skip("GetCursorPos() failed with error %u\n", GetLastError());
1359 return;
1360 }
1361 memset(&in, 0, sizeof(MOUSEMOVEPOINT));
1362 in.x = point.x;
1363 in.y = point.y;
1364
1365 /* test first parameter
1366 * everything different than sizeof(MOUSEMOVEPOINT)
1367 * is expected to fail with ERROR_INVALID_PARAMETER
1368 */
1369 SetLastError(MYERROR);
1370 retval = pGetMouseMovePointsEx(0, &in, out, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1371 if (retval == ERROR_INVALID_PARAMETER)
1372 {
1373 win_skip( "GetMouseMovePointsEx broken on WinME\n" );
1374 return;
1375 }
1376 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1377 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1378 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1379
1380 SetLastError(MYERROR);
1381 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)-1, &in, out, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1382 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1383 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1384 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1385
1386 SetLastError(MYERROR);
1387 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)+1, &in, out, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1388 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1389 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1390 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1391
1392 /* test second and third parameter
1393 */
1394 SetLastError(MYERROR);
1395 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), NULL, out, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1396 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1397 ok(GetLastError() == ERROR_NOACCESS || GetLastError() == MYERROR,
1398 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1399
1400 SetLastError(MYERROR);
1401 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, NULL, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1402 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1403 ok(ERROR_NOACCESS == GetLastError(),
1404 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1405
1406 SetLastError(MYERROR);
1407 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), NULL, NULL, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1408 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1409 ok(ERROR_NOACCESS == GetLastError(),
1410 "expected error ERROR_NOACCESS, got %u\n", GetLastError());
1411
1412 SetLastError(MYERROR);
1413 count = 0;
1414 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, NULL, count, GMMP_USE_DISPLAY_POINTS);
1415 if (retval == -1)
1416 ok(GetLastError() == ERROR_POINT_NOT_FOUND, "unexpected error %u\n", GetLastError());
1417 else
1418 ok(retval == count, "expected GetMouseMovePointsEx to succeed, got %d\n", retval);
1419
1420 /* test fourth parameter
1421 * a value higher than 64 is expected to fail with ERROR_INVALID_PARAMETER
1422 */
1423 SetLastError(MYERROR);
1424 count = -1;
1425 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, count, GMMP_USE_DISPLAY_POINTS);
1426 ok(retval == count, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1427 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1428 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1429
1430 SetLastError(MYERROR);
1431 count = 0;
1432 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, count, GMMP_USE_DISPLAY_POINTS);
1433 if (retval == -1)
1434 ok(GetLastError() == ERROR_POINT_NOT_FOUND, "unexpected error %u\n", GetLastError());
1435 else
1436 ok(retval == count, "expected GetMouseMovePointsEx to succeed, got %d\n", retval);
1437
1438 SetLastError(MYERROR);
1439 count = BUFLIM;
1440 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, count, GMMP_USE_DISPLAY_POINTS);
1441 if (retval == -1)
1442 ok(GetLastError() == ERROR_POINT_NOT_FOUND, "unexpected error %u\n", GetLastError());
1443 else
1444 ok((0 <= retval) && (retval <= count), "expected GetMouseMovePointsEx to succeed, got %d\n", retval);
1445
1446 SetLastError(MYERROR);
1447 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, out, BUFLIM+1, GMMP_USE_DISPLAY_POINTS);
1448 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1449 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1450 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1451
1452 /* it was not possible to force an error with the fifth parameter on win2k */
1453
1454 /* test combinations of wrong parameters to see which error wins */
1455 SetLastError(MYERROR);
1456 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)-1, NULL, out, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1457 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1458 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1459 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1460
1461 SetLastError(MYERROR);
1462 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT)-1, &in, NULL, BUFLIM, GMMP_USE_DISPLAY_POINTS);
1463 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1464 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1465 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1466
1467 SetLastError(MYERROR);
1468 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), NULL, out, BUFLIM+1, GMMP_USE_DISPLAY_POINTS);
1469 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1470 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1471 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1472
1473 SetLastError(MYERROR);
1474 retval = pGetMouseMovePointsEx(sizeof(MOUSEMOVEPOINT), &in, NULL, BUFLIM+1, GMMP_USE_DISPLAY_POINTS);
1475 ok(retval == -1, "expected GetMouseMovePointsEx to fail, got %d\n", retval);
1476 ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == MYERROR,
1477 "expected error ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1478
1479 #undef BUFLIM
1480 #undef MYERROR
1481 }
1482
1483 static void test_GetRawInputDeviceList(void)
1484 {
1485 RAWINPUTDEVICELIST devices[32];
1486 UINT ret, oret, devcount, odevcount;
1487 DWORD err;
1488
1489 SetLastError(0xdeadbeef);
1490 ret = pGetRawInputDeviceList(NULL, NULL, 0);
1491 err = GetLastError();
1492 ok(ret == -1, "expected -1, got %d\n", ret);
1493 ok(err == ERROR_INVALID_PARAMETER, "expected 87, got %d\n", err);
1494
1495 SetLastError(0xdeadbeef);
1496 ret = pGetRawInputDeviceList(NULL, NULL, sizeof(devices[0]));
1497 err = GetLastError();
1498 ok(ret == -1, "expected -1, got %d\n", ret);
1499 ok(err == ERROR_NOACCESS, "expected 998, got %d\n", err);
1500
1501 devcount = 0;
1502 ret = pGetRawInputDeviceList(NULL, &devcount, sizeof(devices[0]));
1503 ok(ret == 0, "expected 0, got %d\n", ret);
1504 ok(devcount > 0, "expected non-zero\n");
1505
1506 SetLastError(0xdeadbeef);
1507 devcount = 0;
1508 ret = pGetRawInputDeviceList(devices, &devcount, sizeof(devices[0]));
1509 err = GetLastError();
1510 ok(ret == -1, "expected -1, got %d\n", ret);
1511 ok(err == ERROR_INSUFFICIENT_BUFFER, "expected 122, got %d\n", err);
1512 ok(devcount > 0, "expected non-zero\n");
1513
1514 /* devcount contains now the correct number of devices */
1515 ret = pGetRawInputDeviceList(devices, &devcount, sizeof(devices[0]));
1516 ok(ret > 0, "expected non-zero\n");
1517
1518 /* check if variable changes from larger to smaller value */
1519 devcount = odevcount = sizeof(devices) / sizeof(devices[0]);
1520 oret = ret = pGetRawInputDeviceList(devices, &odevcount, sizeof(devices[0]));
1521 ok(ret > 0, "expected non-zero\n");
1522 ok(devcount == odevcount, "expected %d, got %d\n", devcount, odevcount);
1523 devcount = odevcount;
1524 odevcount = sizeof(devices) / sizeof(devices[0]);
1525 ret = pGetRawInputDeviceList(NULL, &odevcount, sizeof(devices[0]));
1526 ok(ret == 0, "expected 0, got %d\n", ret);
1527 ok(odevcount == oret, "expected %d, got %d\n", oret, odevcount);
1528 }
1529
1530 static void test_key_map(void)
1531 {
1532 HKL kl = GetKeyboardLayout(0);
1533 UINT kL, kR, s, sL;
1534 int i;
1535 static const UINT numpad_collisions[][2] = {
1536 { VK_NUMPAD0, VK_INSERT },
1537 { VK_NUMPAD1, VK_END },
1538 { VK_NUMPAD2, VK_DOWN },
1539 { VK_NUMPAD3, VK_NEXT },
1540 { VK_NUMPAD4, VK_LEFT },
1541 { VK_NUMPAD6, VK_RIGHT },
1542 { VK_NUMPAD7, VK_HOME },
1543 { VK_NUMPAD8, VK_UP },
1544 { VK_NUMPAD9, VK_PRIOR },
1545 };
1546
1547 s = MapVirtualKeyExA(VK_SHIFT, MAPVK_VK_TO_VSC, kl);
1548 ok(s != 0, "MapVirtualKeyEx(VK_SHIFT) should return non-zero\n");
1549 sL = MapVirtualKeyExA(VK_LSHIFT, MAPVK_VK_TO_VSC, kl);
1550 ok(s == sL || broken(sL == 0), /* win9x */
1551 "%x != %x\n", s, sL);
1552
1553 kL = MapVirtualKeyExA(0x2a, MAPVK_VSC_TO_VK, kl);
1554 ok(kL == VK_SHIFT, "Scan code -> vKey = %x (not VK_SHIFT)\n", kL);
1555 kR = MapVirtualKeyExA(0x36, MAPVK_VSC_TO_VK, kl);
1556 ok(kR == VK_SHIFT, "Scan code -> vKey = %x (not VK_SHIFT)\n", kR);
1557
1558 kL = MapVirtualKeyExA(0x2a, MAPVK_VSC_TO_VK_EX, kl);
1559 ok(kL == VK_LSHIFT || broken(kL == 0), /* win9x */
1560 "Scan code -> vKey = %x (not VK_LSHIFT)\n", kL);
1561 kR = MapVirtualKeyExA(0x36, MAPVK_VSC_TO_VK_EX, kl);
1562 ok(kR == VK_RSHIFT || broken(kR == 0), /* win9x */
1563 "Scan code -> vKey = %x (not VK_RSHIFT)\n", kR);
1564
1565 /* test that MAPVK_VSC_TO_VK prefers the non-numpad vkey if there's ambiguity */
1566 for (i = 0; i < sizeof(numpad_collisions)/sizeof(numpad_collisions[0]); i++)
1567 {
1568 UINT numpad_scan = MapVirtualKeyExA(numpad_collisions[i][0], MAPVK_VK_TO_VSC, kl);
1569 UINT other_scan = MapVirtualKeyExA(numpad_collisions[i][1], MAPVK_VK_TO_VSC, kl);
1570
1571 /* do they really collide for this layout? */
1572 if (numpad_scan && other_scan == numpad_scan)
1573 {
1574 UINT vkey = MapVirtualKeyExA(numpad_scan, MAPVK_VSC_TO_VK, kl);
1575 ok(vkey != numpad_collisions[i][0],
1576 "Got numpad vKey %x for scan code %x when there was another choice\n",
1577 vkey, numpad_scan);
1578 }
1579 }
1580 }
1581
1582 #define shift 1
1583 #define ctrl 2
1584
1585 static const struct tounicode_tests
1586 {
1587 UINT vk;
1588 DWORD modifiers;
1589 WCHAR chr; /* if vk is 0, lookup vk using this char */
1590 int expect_ret;
1591 WCHAR expect_buf[4];
1592 } utests[] =
1593 {
1594 { 'A', 0, 0, 1, {'a',0}},
1595 { 'A', ctrl, 0, 1, {1, 0}},
1596 { 'A', shift|ctrl, 0, 1, {1, 0}},
1597 { VK_TAB, ctrl, 0, 0, {0}},
1598 { VK_TAB, shift|ctrl, 0, 0, {0}},
1599 { VK_RETURN, ctrl, 0, 1, {'\n', 0}},
1600 { VK_RETURN, shift|ctrl, 0, 0, {0}},
1601 { '4', ctrl, 0, 0, {0}},
1602 { '4', shift|ctrl, 0, 0, {0}},
1603 { 0, ctrl, '!', 0, {0}},
1604 { 0, ctrl, '\"', 0, {0}},
1605 { 0, ctrl, '#', 0, {0}},
1606 { 0, ctrl, '$', 0, {0}},
1607 { 0, ctrl, '%', 0, {0}},
1608 { 0, ctrl, '\'', 0, {0}},
1609 { 0, ctrl, '(', 0, {0}},
1610 { 0, ctrl, ')', 0, {0}},
1611 { 0, ctrl, '*', 0, {0}},
1612 { 0, ctrl, '+', 0, {0}},
1613 { 0, ctrl, ',', 0, {0}},
1614 { 0, ctrl, '-', 0, {0}},
1615 { 0, ctrl, '.', 0, {0}},
1616 { 0, ctrl, '/', 0, {0}},
1617 { 0, ctrl, ':', 0, {0}},
1618 { 0, ctrl, ';', 0, {0}},
1619 { 0, ctrl, '<', 0, {0}},
1620 { 0, ctrl, '=', 0, {0}},
1621 { 0, ctrl, '>', 0, {0}},
1622 { 0, ctrl, '?', 0, {0}},
1623 { 0, ctrl, '@', 1, {0}},
1624 { 0, ctrl, '[', 1, {0x1b}},
1625 { 0, ctrl, '\\', 1, {0x1c}},
1626 { 0, ctrl, ']', 1, {0x1d}},
1627 { 0, ctrl, '^', 1, {0x1e}},
1628 { 0, ctrl, '_', 1, {0x1f}},
1629 { 0, ctrl, '`', 0, {0}},
1630 { VK_SPACE, 0, 0, 1, {' ',0}},
1631 { VK_SPACE, shift, 0, 1, {' ',0}},
1632 { VK_SPACE, ctrl, 0, 1, {' ',0}},
1633 };
1634
1635 static void test_ToUnicode(void)
1636 {
1637 WCHAR wStr[4];
1638 BYTE state[256];
1639 const BYTE SC_RETURN = 0x1c, SC_TAB = 0x0f, SC_A = 0x1e;
1640 const BYTE HIGHEST_BIT = 0x80;
1641 int i, ret;
1642 BOOL us_kbd = (GetKeyboardLayout(0) == (HKL)(ULONG_PTR)0x04090409);
1643
1644 for(i=0; i<256; i++)
1645 state[i]=0;
1646
1647 wStr[1] = 0xAA;
1648 SetLastError(0xdeadbeef);
1649 ret = ToUnicode(VK_RETURN, SC_RETURN, state, wStr, 4, 0);
1650 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1651 {
1652 win_skip("ToUnicode is not implemented\n");
1653 return;
1654 }
1655
1656 ok(ret == 1, "ToUnicode for Return key didn't return 1 (was %i)\n", ret);
1657 if(ret == 1)
1658 {
1659 ok(wStr[0]=='\r', "ToUnicode for CTRL + Return was %i (expected 13)\n", wStr[0]);
1660 ok(wStr[1]==0 || broken(wStr[1]!=0) /* nt4 */,
1661 "ToUnicode didn't null-terminate the buffer when there was room.\n");
1662 }
1663
1664 for (i = 0; i < sizeof(utests) / sizeof(utests[0]); i++)
1665 {
1666 UINT vk = utests[i].vk, mod = utests[i].modifiers, scan;
1667
1668 if(!vk)
1669 {
1670 short vk_ret;
1671
1672 if (!us_kbd) continue;
1673 vk_ret = VkKeyScanW(utests[i].chr);
1674 if (vk_ret == -1) continue;
1675 vk = vk_ret & 0xff;
1676 if (vk_ret & 0x100) mod |= shift;
1677 if (vk_ret & 0x200) mod |= ctrl;
1678 }
1679 scan = MapVirtualKeyW(vk, MAPVK_VK_TO_VSC);
1680
1681 state[VK_SHIFT] = state[VK_LSHIFT] = (mod & shift) ? HIGHEST_BIT : 0;
1682 state[VK_CONTROL] = state[VK_LCONTROL] = (mod & ctrl) ? HIGHEST_BIT : 0;
1683
1684 ret = ToUnicode(vk, scan, state, wStr, 4, 0);
1685 ok(ret == utests[i].expect_ret, "%d: got %d expected %d\n", i, ret, utests[i].expect_ret);
1686 if (ret)
1687 ok(!lstrcmpW(wStr, utests[i].expect_buf), "%d: got %s expected %s\n", i, wine_dbgstr_w(wStr),
1688 wine_dbgstr_w(utests[i].expect_buf));
1689
1690 }
1691 state[VK_SHIFT] = state[VK_LSHIFT] = 0;
1692 state[VK_CONTROL] = state[VK_LCONTROL] = 0;
1693
1694 ret = ToUnicode(VK_TAB, SC_TAB, NULL, wStr, 4, 0);
1695 ok(ret == 0, "ToUnicode with NULL keystate didn't return 0 (was %i)\n", ret);
1696 ret = ToUnicode(VK_RETURN, SC_RETURN, NULL, wStr, 4, 0);
1697 ok(ret == 0, "ToUnicode with NULL keystate didn't return 0 (was %i)\n", ret);
1698 ret = ToUnicode('A', SC_A, NULL, wStr, 4, 0);
1699 ok(ret == 0, "ToUnicode with NULL keystate didn't return 0 (was %i)\n", ret);
1700 ret = ToUnicodeEx(VK_TAB, SC_TAB, NULL, wStr, 4, 0, GetKeyboardLayout(0));
1701 ok(ret == 0, "ToUnicodeEx with NULL keystate didn't return 0 (was %i)\n", ret);
1702 ret = ToUnicodeEx(VK_RETURN, SC_RETURN, NULL, wStr, 4, 0, GetKeyboardLayout(0));
1703 ok(ret == 0, "ToUnicodeEx with NULL keystate didn't return 0 (was %i)\n", ret);
1704 ret = ToUnicodeEx('A', SC_A, NULL, wStr, 4, 0, GetKeyboardLayout(0));
1705 ok(ret == 0, "ToUnicodeEx with NULL keystate didn't return 0 (was %i)\n", ret);
1706 }
1707
1708 static void test_ToAscii(void)
1709 {
1710 WORD character;
1711 BYTE state[256];
1712 const BYTE SC_RETURN = 0x1c, SC_A = 0x1e;
1713 const BYTE HIGHEST_BIT = 0x80;
1714 int ret;
1715
1716 memset(state, 0, sizeof(state));
1717
1718 character = 0;
1719 ret = ToAscii(VK_RETURN, SC_RETURN, state, &character, 0);
1720 ok(ret == 1, "ToAscii for Return key didn't return 1 (was %i)\n", ret);
1721 ok(character == '\r', "ToAscii for Return was %i (expected 13)\n", character);
1722
1723 character = 0;
1724 ret = ToAscii('A', SC_A, state, &character, 0);
1725 ok(ret == 1, "ToAscii for character 'A' didn't return 1 (was %i)\n", ret);
1726 ok(character == 'a', "ToAscii for character 'A' was %i (expected %i)\n", character, 'a');
1727
1728 state[VK_CONTROL] |= HIGHEST_BIT;
1729 state[VK_LCONTROL] |= HIGHEST_BIT;
1730 character = 0;
1731 ret = ToAscii(VK_RETURN, SC_RETURN, state, &character, 0);
1732 ok(ret == 1, "ToAscii for CTRL + Return key didn't return 1 (was %i)\n", ret);
1733 ok(character == '\n', "ToAscii for CTRL + Return was %i (expected 10)\n", character);
1734
1735 character = 0;
1736 ret = ToAscii('A', SC_A, state, &character, 0);
1737 ok(ret == 1, "ToAscii for CTRL + character 'A' didn't return 1 (was %i)\n", ret);
1738 ok(character == 1, "ToAscii for CTRL + character 'A' was %i (expected 1)\n", character);
1739
1740 state[VK_SHIFT] |= HIGHEST_BIT;
1741 state[VK_LSHIFT] |= HIGHEST_BIT;
1742 ret = ToAscii(VK_RETURN, SC_RETURN, state, &character, 0);
1743 ok(ret == 0, "ToAscii for CTRL + Shift + Return key didn't return 0 (was %i)\n", ret);
1744
1745 ret = ToAscii(VK_RETURN, SC_RETURN, NULL, &character, 0);
1746 ok(ret == 0, "ToAscii for NULL keystate didn't return 0 (was %i)\n", ret);
1747 ret = ToAscii('A', SC_A, NULL, &character, 0);
1748 ok(ret == 0, "ToAscii for NULL keystate didn't return 0 (was %i)\n", ret);
1749 ret = ToAsciiEx(VK_RETURN, SC_RETURN, NULL, &character, 0, GetKeyboardLayout(0));
1750 ok(ret == 0, "ToAsciiEx for NULL keystate didn't return 0 (was %i)\n", ret);
1751 ret = ToAsciiEx('A', SC_A, NULL, &character, 0, GetKeyboardLayout(0));
1752 ok(ret == 0, "ToAsciiEx for NULL keystate didn't return 0 (was %i)\n", ret);
1753 }
1754
1755 static void test_get_async_key_state(void)
1756 {
1757 /* input value sanity checks */
1758 ok(0 == GetAsyncKeyState(1000000), "GetAsyncKeyState did not return 0\n");
1759 ok(0 == GetAsyncKeyState(-1000000), "GetAsyncKeyState did not return 0\n");
1760 }
1761
1762 static void test_keyboard_layout_name(void)
1763 {
1764 BOOL ret;
1765 char klid[KL_NAMELENGTH];
1766
1767 if (0) /* crashes on native system */
1768 ret = GetKeyboardLayoutNameA(NULL);
1769
1770 SetLastError(0xdeadbeef);
1771 ret = GetKeyboardLayoutNameW(NULL);
1772 ok(!ret, "got %d\n", ret);
1773 ok(GetLastError() == ERROR_NOACCESS, "got %d\n", GetLastError());
1774
1775 if (GetKeyboardLayout(0) != (HKL)(ULONG_PTR)0x04090409) return;
1776
1777 klid[0] = 0;
1778 ret = GetKeyboardLayoutNameA(klid);
1779 ok(ret, "GetKeyboardLayoutNameA failed %u\n", GetLastError());
1780 ok(!strcmp(klid, "00000409"), "expected 00000409, got %s\n", klid);
1781 }
1782
1783 static void test_key_names(void)
1784 {
1785 char buffer[40];
1786 WCHAR bufferW[40];
1787 int ret, prev;
1788 LONG lparam = 0x1d << 16;
1789
1790 memset( buffer, 0xcc, sizeof(buffer) );
1791 ret = GetKeyNameTextA( lparam, buffer, sizeof(buffer) );
1792 ok( ret > 0, "wrong len %u for '%s'\n", ret, buffer );
1793 ok( ret == strlen(buffer), "wrong len %u for '%s'\n", ret, buffer );
1794
1795 memset( buffer, 0xcc, sizeof(buffer) );
1796 prev = ret;
1797 ret = GetKeyNameTextA( lparam, buffer, prev );
1798 ok( ret == prev - 1, "wrong len %u for '%s'\n", ret, buffer );
1799 ok( ret == strlen(buffer), "wrong len %u for '%s'\n", ret, buffer );
1800
1801 memset( buffer, 0xcc, sizeof(buffer) );
1802 ret = GetKeyNameTextA( lparam, buffer, 0 );
1803 ok( ret == 0, "wrong len %u for '%s'\n", ret, buffer );
1804 ok( buffer[0] == 0, "wrong string '%s'\n", buffer );
1805
1806 memset( bufferW, 0xcc, sizeof(bufferW) );
1807 ret = GetKeyNameTextW( lparam, bufferW, sizeof(bufferW)/sizeof(WCHAR) );
1808 ok( ret > 0, "wrong len %u for %s\n", ret, wine_dbgstr_w(bufferW) );
1809 ok( ret == lstrlenW(bufferW), "wrong len %u for %s\n", ret, wine_dbgstr_w(bufferW) );
1810
1811 memset( bufferW, 0xcc, sizeof(bufferW) );
1812 prev = ret;
1813 ret = GetKeyNameTextW( lparam, bufferW, prev );
1814 ok( ret == prev - 1, "wrong len %u for %s\n", ret, wine_dbgstr_w(bufferW) );
1815 ok( ret == lstrlenW(bufferW), "wrong len %u for %s\n", ret, wine_dbgstr_w(bufferW) );
1816
1817 memset( bufferW, 0xcc, sizeof(bufferW) );
1818 ret = GetKeyNameTextW( lparam, bufferW, 0 );
1819 ok( ret == 0, "wrong len %u for %s\n", ret, wine_dbgstr_w(bufferW) );
1820 ok( bufferW[0] == 0xcccc, "wrong string %s\n", wine_dbgstr_w(bufferW) );
1821 }
1822
1823 static void simulate_click(BOOL left, int x, int y)
1824 {
1825 INPUT input[2];
1826 UINT events_no;
1827
1828 SetCursorPos(x, y);
1829 memset(input, 0, sizeof(input));
1830 input[0].type = INPUT_MOUSE;
1831 U(input[0]).mi.dx = x;
1832 U(input[0]).mi.dy = y;
1833 U(input[0]).mi.dwFlags = left ? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_RIGHTDOWN;
1834 input[1].type = INPUT_MOUSE;
1835 U(input[1]).mi.dx = x;
1836 U(input[1]).mi.dy = y;
1837 U(input[1]).mi.dwFlags = left ? MOUSEEVENTF_LEFTUP : MOUSEEVENTF_RIGHTUP;
1838 events_no = SendInput(2, input, sizeof(input[0]));
1839 ok(events_no == 2, "SendInput returned %d\n", events_no);
1840 }
1841
1842 static BOOL wait_for_message( MSG *msg )
1843 {
1844 BOOL ret;
1845
1846 for (;;)
1847 {
1848 ret = PeekMessageA(msg, 0, 0, 0, PM_REMOVE);
1849 if (ret)
1850 {
1851 if (msg->message == WM_PAINT) DispatchMessageA(msg);
1852 else break;
1853 }
1854 else if (MsgWaitForMultipleObjects(0, NULL, FALSE, 100, QS_ALLINPUT) == WAIT_TIMEOUT) break;
1855 }
1856 if (!ret) msg->message = 0;
1857 return ret;
1858 }
1859
1860 static BOOL wait_for_event(HANDLE event, int timeout)
1861 {
1862 DWORD end_time = GetTickCount() + timeout;
1863 MSG msg;
1864
1865 do {
1866 if(MsgWaitForMultipleObjects(1, &event, FALSE, timeout, QS_ALLINPUT) == WAIT_OBJECT_0)
1867 return TRUE;
1868 while(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
1869 DispatchMessageA(&msg);
1870 timeout = end_time - GetTickCount();
1871 }while(timeout > 0);
1872
1873 return FALSE;
1874 }
1875
1876 static WNDPROC def_static_proc;
1877 static DWORD hittest_no;
1878 static LRESULT WINAPI static_hook_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
1879 {
1880 if (msg == WM_NCHITTEST)
1881 {
1882 /* break infinite hittest loop */
1883 if(hittest_no > 50) return HTCLIENT;
1884 hittest_no++;
1885 }
1886
1887 return def_static_proc(hwnd, msg, wp, lp);
1888 }
1889
1890 struct thread_data
1891 {
1892 HANDLE start_event;
1893 HANDLE end_event;
1894 HWND win;
1895 };
1896
1897 static DWORD WINAPI create_static_win(void *arg)
1898 {
1899 struct thread_data *thread_data = arg;
1900 HWND win;
1901
1902 win = CreateWindowA("static", "static", WS_VISIBLE | WS_POPUP,
1903 100, 100, 100, 100, 0, NULL, NULL, NULL);
1904 ok(win != 0, "CreateWindow failed\n");
1905 def_static_proc = (void*)SetWindowLongPtrA(win,
1906 GWLP_WNDPROC, (LONG_PTR)static_hook_proc);
1907 thread_data->win = win;
1908
1909 SetEvent(thread_data->start_event);
1910 wait_for_event(thread_data->end_event, 5000);
1911 return 0;
1912 }
1913
1914 static void test_Input_mouse(void)
1915 {
1916 BOOL got_button_down, got_button_up;
1917 HWND hwnd, button_win, static_win;
1918 struct thread_data thread_data;
1919 HANDLE thread;
1920 DWORD thread_id;
1921 WNDCLASSA wclass;
1922 POINT pt, pt_org;
1923 int region_type;
1924 HRGN hregion;
1925 RECT region;
1926 BOOL ret;
1927 MSG msg;
1928
1929 GetCursorPos(&pt_org);
1930
1931 button_win = CreateWindowA("button", "button", WS_VISIBLE | WS_POPUP,
1932 100, 100, 100, 100, 0, NULL, NULL, NULL);
1933 ok(button_win != 0, "CreateWindow failed\n");
1934
1935 pt.x = pt.y = 150;
1936 hwnd = WindowFromPoint(pt);
1937 if (hwnd != button_win)
1938 {
1939 skip("there's another window covering test window\n");
1940 DestroyWindow(button_win);
1941 return;
1942 }
1943
1944 /* simple button click test */
1945 simulate_click(TRUE, 150, 150);
1946 got_button_down = got_button_up = FALSE;
1947 while (wait_for_message(&msg))
1948 {
1949 DispatchMessageA(&msg);
1950
1951 if (msg.message == WM_LBUTTONDOWN)
1952 {
1953 got_button_down = TRUE;
1954 }
1955 else if (msg.message == WM_LBUTTONUP)
1956 {
1957 got_button_up = TRUE;
1958 break;
1959 }
1960 }
1961 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
1962 ok(got_button_up, "expected WM_LBUTTONUP message\n");
1963
1964 /* click through HTTRANSPARENT child window */
1965 static_win = CreateWindowA("static", "static", WS_VISIBLE | WS_CHILD,
1966 0, 0, 100, 100, button_win, NULL, NULL, NULL);
1967 ok(static_win != 0, "CreateWindow failed\n");
1968 def_static_proc = (void*)SetWindowLongPtrA(static_win,
1969 GWLP_WNDPROC, (LONG_PTR)static_hook_proc);
1970 simulate_click(FALSE, 150, 150);
1971 hittest_no = 0;
1972 got_button_down = got_button_up = FALSE;
1973 while (wait_for_message(&msg))
1974 {
1975 DispatchMessageA(&msg);
1976
1977 if (msg.message == WM_RBUTTONDOWN)
1978 {
1979 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
1980 got_button_down = TRUE;
1981 }
1982 else if (msg.message == WM_RBUTTONUP)
1983 {
1984 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
1985 got_button_up = TRUE;
1986 break;
1987 }
1988 }
1989 ok(hittest_no && hittest_no<50, "expected WM_NCHITTEST message\n");
1990 ok(got_button_down, "expected WM_RBUTTONDOWN message\n");
1991 ok(got_button_up, "expected WM_RBUTTONUP message\n");
1992 DestroyWindow(static_win);
1993
1994 /* click through HTTRANSPARENT top-level window */
1995 static_win = CreateWindowA("static", "static", WS_VISIBLE | WS_POPUP,
1996 100, 100, 100, 100, 0, NULL, NULL, NULL);
1997 ok(static_win != 0, "CreateWindow failed\n");
1998 def_static_proc = (void*)SetWindowLongPtrA(static_win,
1999 GWLP_WNDPROC, (LONG_PTR)static_hook_proc);
2000 simulate_click(TRUE, 150, 150);
2001 hittest_no = 0;
2002 got_button_down = got_button_up = FALSE;
2003 while (wait_for_message(&msg))
2004 {
2005 DispatchMessageA(&msg);
2006
2007 if (msg.message == WM_LBUTTONDOWN)
2008 {
2009 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2010 got_button_down = TRUE;
2011 }
2012 else if (msg.message == WM_LBUTTONUP)
2013 {
2014 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2015 got_button_up = TRUE;
2016 break;
2017 }
2018 }
2019 ok(hittest_no && hittest_no<50, "expected WM_NCHITTEST message\n");
2020 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2021 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2022 DestroyWindow(static_win);
2023
2024 /* click on HTTRANSPARENT top-level window that belongs to other thread */
2025 thread_data.start_event = CreateEventA(NULL, FALSE, FALSE, NULL);
2026 ok(thread_data.start_event != NULL, "CreateEvent failed\n");
2027 thread_data.end_event = CreateEventA(NULL, FALSE, FALSE, NULL);
2028 ok(thread_data.end_event != NULL, "CreateEvent failed\n");
2029 thread = CreateThread(NULL, 0, create_static_win, &thread_data, 0, NULL);
2030 ok(thread != NULL, "CreateThread failed\n");
2031 hittest_no = 0;
2032 got_button_down = got_button_up = FALSE;
2033 WaitForSingleObject(thread_data.start_event, INFINITE);
2034 simulate_click(FALSE, 150, 150);
2035 while (wait_for_message(&msg))
2036 {
2037 DispatchMessageA(&msg);
2038
2039 if (msg.message == WM_RBUTTONDOWN)
2040 got_button_down = TRUE;
2041 else if (msg.message == WM_RBUTTONUP)
2042 got_button_up = TRUE;
2043 }
2044 SetEvent(thread_data.end_event);
2045 WaitForSingleObject(thread, INFINITE);
2046 ok(hittest_no && hittest_no<50, "expected WM_NCHITTEST message\n");
2047 ok(!got_button_down, "unexpected WM_RBUTTONDOWN message\n");
2048 ok(!got_button_up, "unexpected WM_RBUTTONUP message\n");
2049
2050 /* click on HTTRANSPARENT top-level window that belongs to other thread,
2051 * thread input queues are attached */
2052 thread = CreateThread(NULL, 0, create_static_win, &thread_data, 0, &thread_id);
2053 ok(thread != NULL, "CreateThread failed\n");
2054 hittest_no = 0;
2055 got_button_down = got_button_up = FALSE;
2056 WaitForSingleObject(thread_data.start_event, INFINITE);
2057 ok(AttachThreadInput(thread_id, GetCurrentThreadId(), TRUE),
2058 "AttachThreadInput failed\n");
2059 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2060 SetWindowPos(thread_data.win, button_win, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);
2061 simulate_click(TRUE, 150, 150);
2062 while (wait_for_message(&msg))
2063 {
2064 DispatchMessageA(&msg);
2065
2066 if (msg.message == WM_LBUTTONDOWN)
2067 got_button_down = TRUE;
2068 else if (msg.message == WM_LBUTTONUP)
2069 got_button_up = TRUE;
2070 }
2071 SetEvent(thread_data.end_event);
2072 WaitForSingleObject(thread, INFINITE);
2073 todo_wine ok(hittest_no > 50, "expected loop with WM_NCHITTEST messages\n");
2074 ok(!got_button_down, "unexpected WM_LBUTTONDOWN message\n");
2075 ok(!got_button_up, "unexpected WM_LBUTTONUP message\n");
2076
2077 /* click after SetCapture call */
2078 hwnd = CreateWindowA("button", "button", WS_VISIBLE | WS_POPUP,
2079 0, 0, 100, 100, 0, NULL, NULL, NULL);
2080 ok(hwnd != 0, "CreateWindow failed\n");
2081 SetCapture(button_win);
2082 got_button_down = got_button_up = FALSE;
2083 simulate_click(FALSE, 50, 50);
2084 while (wait_for_message(&msg))
2085 {
2086 DispatchMessageA(&msg);
2087
2088 if (msg.message == WM_RBUTTONDOWN)
2089 {
2090 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2091 got_button_down = TRUE;
2092 }
2093 else if (msg.message == WM_RBUTTONUP)
2094 {
2095 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2096 got_button_up = TRUE;
2097 break;
2098 }
2099 }
2100 ok(got_button_down, "expected WM_RBUTTONDOWN message\n");
2101 ok(got_button_up, "expected WM_RBUTTONUP message\n");
2102 DestroyWindow(hwnd);
2103
2104 /* click on child window after SetCapture call */
2105 hwnd = CreateWindowA("button", "button2", WS_VISIBLE | WS_CHILD,
2106 0, 0, 100, 100, button_win, NULL, NULL, NULL);
2107 ok(hwnd != 0, "CreateWindow failed\n");
2108 got_button_down = got_button_up = FALSE;
2109 simulate_click(TRUE, 150, 150);
2110 while (wait_for_message(&msg))
2111 {
2112 DispatchMessageA(&msg);
2113
2114 if (msg.message == WM_LBUTTONDOWN)
2115 {
2116 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2117 got_button_down = TRUE;
2118 }
2119 else if (msg.message == WM_LBUTTONUP)
2120 {
2121 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2122 got_button_up = TRUE;
2123 break;
2124 }
2125 }
2126 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2127 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2128 DestroyWindow(hwnd);
2129 ok(ReleaseCapture(), "ReleaseCapture failed\n");
2130
2131 wclass.style = 0;
2132 wclass.lpfnWndProc = WndProc;
2133 wclass.cbClsExtra = 0;
2134 wclass.cbWndExtra = 0;
2135 wclass.hInstance = GetModuleHandleA(NULL);
2136 wclass.hIcon = LoadIconA(0, (LPCSTR)IDI_APPLICATION);
2137 wclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
2138 wclass.hbrBackground = CreateSolidBrush(RGB(128, 128, 128));
2139 wclass.lpszMenuName = NULL;
2140 wclass.lpszClassName = "InputLayeredTestClass";
2141 RegisterClassA( &wclass );
2142
2143 /* click through layered window with alpha channel / color key */
2144 hwnd = CreateWindowA(wclass.lpszClassName, "InputLayeredTest",
2145 WS_VISIBLE | WS_POPUP, 100, 100, 100, 100, button_win, NULL, NULL, NULL);
2146 ok(hwnd != NULL, "CreateWindowEx failed\n");
2147
2148 SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
2149 SetWindowLongA(hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED);
2150 ret = SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA);
2151 ok(ret, "SetLayeredWindowAttributes failed\n");
2152 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2153 Sleep(100);
2154
2155 if (pGetWindowRgnBox)
2156 {
2157 region_type = pGetWindowRgnBox(hwnd, &region);
2158 ok(region_type == ERROR, "expected ERROR, got %d\n", region_type);
2159 }
2160
2161 got_button_down = got_button_up = FALSE;
2162 simulate_click(TRUE, 150, 150);
2163 while (wait_for_message(&msg))
2164 {
2165 DispatchMessageA(&msg);
2166
2167 if (msg.message == WM_LBUTTONDOWN)
2168 {
2169 ok(msg.hwnd == hwnd, "msg.hwnd = %p\n", msg.hwnd);
2170 got_button_down = TRUE;
2171 }
2172 else if (msg.message == WM_LBUTTONUP)
2173 {
2174 ok(msg.hwnd == hwnd, "msg.hwnd = %p\n", msg.hwnd);
2175 got_button_up = TRUE;
2176 break;
2177 }
2178 }
2179 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2180 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2181
2182 ret = SetLayeredWindowAttributes(hwnd, 0, 0, LWA_ALPHA);
2183 ok(ret, "SetLayeredWindowAttributes failed\n");
2184 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2185 Sleep(100);
2186
2187 if (pGetWindowRgnBox)
2188 {
2189 region_type = pGetWindowRgnBox(hwnd, &region);
2190 ok(region_type == ERROR, "expected ERROR, got %d\n", region_type);
2191 }
2192
2193 got_button_down = got_button_up = FALSE;
2194 simulate_click(TRUE, 150, 150);
2195 while (wait_for_message(&msg))
2196 {
2197 DispatchMessageA(&msg);
2198
2199 if (msg.message == WM_LBUTTONDOWN)
2200 {
2201 todo_wine
2202 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2203 got_button_down = TRUE;
2204 }
2205 else if (msg.message == WM_LBUTTONUP)
2206 {
2207 todo_wine
2208 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2209 got_button_up = TRUE;
2210 break;
2211 }
2212 }
2213 ok(got_button_down || broken(!got_button_down), "expected WM_LBUTTONDOWN message\n");
2214 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2215
2216 ret = SetLayeredWindowAttributes(hwnd, RGB(0, 255, 0), 255, LWA_ALPHA | LWA_COLORKEY);
2217 ok(ret, "SetLayeredWindowAttributes failed\n");
2218 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2219 Sleep(100);
2220
2221 if (pGetWindowRgnBox)
2222 {
2223 region_type = pGetWindowRgnBox(hwnd, &region);
2224 ok(region_type == ERROR, "expected ERROR, got %d\n", region_type);
2225 }
2226
2227 got_button_down = got_button_up = FALSE;
2228 simulate_click(TRUE, 150, 150);
2229 while (wait_for_message(&msg))
2230 {
2231 DispatchMessageA(&msg);
2232
2233 if (msg.message == WM_LBUTTONDOWN)
2234 {
2235 ok(msg.hwnd == hwnd, "msg.hwnd = %p\n", msg.hwnd);
2236 got_button_down = TRUE;
2237 }
2238 else if (msg.message == WM_LBUTTONUP)
2239 {
2240 ok(msg.hwnd == hwnd, "msg.hwnd = %p\n", msg.hwnd);
2241 got_button_up = TRUE;
2242 break;
2243 }
2244 }
2245 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2246 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2247
2248 ret = SetLayeredWindowAttributes(hwnd, RGB(128, 128, 128), 0, LWA_COLORKEY);
2249 ok(ret, "SetLayeredWindowAttributes failed\n");
2250 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2251 Sleep(100);
2252
2253 if (pGetWindowRgnBox)
2254 {
2255 region_type = pGetWindowRgnBox(hwnd, &region);
2256 ok(region_type == ERROR, "expected ERROR, got %d\n", region_type);
2257 }
2258
2259 got_button_down = got_button_up = FALSE;
2260 simulate_click(TRUE, 150, 150);
2261 while (wait_for_message(&msg))
2262 {
2263 DispatchMessageA(&msg);
2264
2265 if (msg.message == WM_LBUTTONDOWN)
2266 {
2267 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2268 got_button_down = TRUE;
2269 }
2270 else if (msg.message == WM_LBUTTONUP)
2271 {
2272 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2273 got_button_up = TRUE;
2274 break;
2275 }
2276 }
2277 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2278 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2279
2280 SetWindowLongA(hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED);
2281 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2282 Sleep(100);
2283
2284 if (pGetWindowRgnBox)
2285 {
2286 region_type = pGetWindowRgnBox(hwnd, &region);
2287 ok(region_type == ERROR, "expected ERROR, got %d\n", region_type);
2288 }
2289
2290 got_button_down = got_button_up = FALSE;
2291 simulate_click(TRUE, 150, 150);
2292 while (wait_for_message(&msg))
2293 {
2294 DispatchMessageA(&msg);
2295
2296 if (msg.message == WM_LBUTTONDOWN)
2297 {
2298 ok(msg.hwnd == hwnd, "msg.hwnd = %p\n", msg.hwnd);
2299 got_button_down = TRUE;
2300 }
2301 else if (msg.message == WM_LBUTTONUP)
2302 {
2303 ok(msg.hwnd == hwnd, "msg.hwnd = %p\n", msg.hwnd);
2304 got_button_up = TRUE;
2305 break;
2306 }
2307 }
2308 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2309 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2310
2311 hregion = CreateRectRgn(0, 0, 10, 10);
2312 ok(hregion != NULL, "CreateRectRgn failed\n");
2313 ret = SetWindowRgn(hwnd, hregion, TRUE);
2314 ok(ret, "SetWindowRgn failed\n");
2315 DeleteObject(hregion);
2316 while (wait_for_message(&msg)) DispatchMessageA(&msg);
2317 Sleep(1000);
2318
2319 if (pGetWindowRgnBox)
2320 {
2321 region_type = pGetWindowRgnBox(hwnd, &region);
2322 ok(region_type == SIMPLEREGION, "expected SIMPLEREGION, got %d\n", region_type);
2323 }
2324
2325 got_button_down = got_button_up = FALSE;
2326 simulate_click(TRUE, 150, 150);
2327 while (wait_for_message(&msg))
2328 {
2329 DispatchMessageA(&msg);
2330
2331 if (msg.message == WM_LBUTTONDOWN)
2332 {
2333 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2334 got_button_down = TRUE;
2335 }
2336 else if (msg.message == WM_LBUTTONUP)
2337 {
2338 ok(msg.hwnd == button_win, "msg.hwnd = %p\n", msg.hwnd);
2339 got_button_up = TRUE;
2340 break;
2341 }
2342 }
2343 ok(got_button_down, "expected WM_LBUTTONDOWN message\n");
2344 ok(got_button_up, "expected WM_LBUTTONUP message\n");
2345
2346 DestroyWindow(hwnd);
2347 SetCursorPos(pt_org.x, pt_org.y);
2348
2349 CloseHandle(thread_data.start_event);
2350 CloseHandle(thread_data.end_event);
2351 DestroyWindow(button_win);
2352 }
2353
2354
2355 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2356 {
2357 if (message == WM_USER+1)
2358 {
2359 HWND hwnd = (HWND)lParam;
2360 ok(GetFocus() == hwnd, "thread expected focus %p, got %p\n", hwnd, GetFocus());
2361 ok(GetActiveWindow() == hwnd, "thread expected active %p, got %p\n", hwnd, GetActiveWindow());
2362 }
2363 return DefWindowProcA(hwnd, message, wParam, lParam);
2364 }
2365
2366 struct wnd_event
2367 {
2368 HWND hwnd;
2369 HANDLE wait_event;
2370 HANDLE start_event;
2371 DWORD attach_from;
2372 DWORD attach_to;
2373 BOOL setWindows;
2374 };
2375
2376 static DWORD WINAPI thread_proc(void *param)
2377 {
2378 MSG msg;
2379 struct wnd_event *wnd_event = param;
2380 BOOL ret;
2381
2382 if (wnd_event->wait_event)
2383 {
2384 ok(WaitForSingleObject(wnd_event->wait_event, INFINITE) == WAIT_OBJECT_0,
2385 "WaitForSingleObject failed\n");
2386 CloseHandle(wnd_event->wait_event);
2387 }
2388
2389 if (wnd_event->attach_from)
2390 {
2391 ret = AttachThreadInput(wnd_event->attach_from, GetCurrentThreadId(), TRUE);
2392 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2393 }
2394
2395 if (wnd_event->attach_to)
2396 {
2397 ret = AttachThreadInput(GetCurrentThreadId(), wnd_event->attach_to, TRUE);
2398 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2399 }
2400
2401 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
2402 100, 100, 200, 200, 0, 0, 0, NULL);
2403 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
2404
2405 if (wnd_event->setWindows)
2406 {
2407 SetFocus(wnd_event->hwnd);
2408 SetActiveWindow(wnd_event->hwnd);
2409 }
2410
2411 SetEvent(wnd_event->start_event);
2412
2413 while (GetMessageA(&msg, 0, 0, 0))
2414 {
2415 TranslateMessage(&msg);
2416 DispatchMessageA(&msg);
2417 }
2418
2419 return 0;
2420 }
2421
2422 static void test_attach_input(void)
2423 {
2424 HANDLE hThread;
2425 HWND ourWnd, Wnd2;
2426 DWORD ret, tid;
2427 struct wnd_event wnd_event;
2428 WNDCLASSA cls;
2429
2430 cls.style = 0;
2431 cls.lpfnWndProc = MsgCheckProcA;
2432 cls.cbClsExtra = 0;
2433 cls.cbWndExtra = 0;
2434 cls.hInstance = GetModuleHandleA(0);
2435 cls.hIcon = 0;
2436 cls.hCursor = LoadCursorW( NULL, (LPCWSTR)IDC_ARROW);
2437 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
2438 cls.lpszMenuName = NULL;
2439 cls.lpszClassName = "TestWindowClass";
2440 if(!RegisterClassA(&cls)) return;
2441
2442 wnd_event.wait_event = NULL;
2443 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
2444 wnd_event.attach_from = 0;
2445 wnd_event.attach_to = 0;
2446 wnd_event.setWindows = FALSE;
2447 if (!wnd_event.start_event)
2448 {
2449 win_skip("skipping interthread message test under win9x\n");
2450 return;
2451 }
2452
2453 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
2454 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
2455
2456 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2457 CloseHandle(wnd_event.start_event);
2458
2459 ourWnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
2460 0, 0, 0, 0, 0, 0, 0, NULL);
2461 ok(ourWnd!= 0, "failed to create ourWnd window\n");
2462
2463 Wnd2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
2464 0, 0, 0, 0, 0, 0, 0, NULL);
2465 ok(Wnd2!= 0, "failed to create Wnd2 window\n");
2466
2467 SetFocus(ourWnd);
2468 SetActiveWindow(ourWnd);
2469
2470 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
2471 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2472
2473 ok(GetActiveWindow() == ourWnd, "expected active %p, got %p\n", ourWnd, GetActiveWindow());
2474 ok(GetFocus() == ourWnd, "expected focus %p, got %p\n", ourWnd, GetFocus());
2475
2476 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)ourWnd);
2477
2478 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
2479 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2480 ok(GetActiveWindow() == ourWnd, "expected active %p, got %p\n", ourWnd, GetActiveWindow());
2481 ok(GetFocus() == ourWnd, "expected focus %p, got %p\n", ourWnd, GetFocus());
2482
2483 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, 0);
2484
2485 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
2486 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2487
2488 ok(GetActiveWindow() == ourWnd, "expected active %p, got %p\n", ourWnd, GetActiveWindow());
2489 ok(GetFocus() == ourWnd, "expected focus %p, got %p\n", ourWnd, GetFocus());
2490 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)ourWnd);
2491
2492 SetActiveWindow(Wnd2);
2493 SetFocus(Wnd2);
2494 ok(GetActiveWindow() == Wnd2, "expected active %p, got %p\n", Wnd2, GetActiveWindow());
2495 ok(GetFocus() == Wnd2, "expected focus %p, got %p\n", Wnd2, GetFocus());
2496
2497 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)Wnd2);
2498
2499 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
2500 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2501 ok(GetActiveWindow() == Wnd2, "expected active %p, got %p\n", Wnd2, GetActiveWindow());
2502 ok(GetFocus() == Wnd2, "expected focus %p, got %p\n", Wnd2, GetFocus());
2503
2504 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, 0);
2505
2506 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
2507 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
2508
2509 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2510 CloseHandle(hThread);
2511
2512 wnd_event.wait_event = NULL;
2513 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
2514 wnd_event.attach_from = 0;
2515 wnd_event.attach_to = 0;
2516 wnd_event.setWindows = TRUE;
2517
2518 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
2519 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
2520
2521 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2522 CloseHandle(wnd_event.start_event);
2523
2524 SetFocus(ourWnd);
2525 SetActiveWindow(ourWnd);
2526
2527 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
2528 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2529
2530 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
2531 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
2532
2533 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)wnd_event.hwnd);
2534
2535 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
2536 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2537
2538 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
2539 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
2540
2541 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)wnd_event.hwnd);
2542
2543 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
2544 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2545
2546 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
2547 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
2548
2549 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)wnd_event.hwnd);
2550
2551 SetFocus(Wnd2);
2552 SetActiveWindow(Wnd2);
2553 ok(GetActiveWindow() == Wnd2, "expected active %p, got %p\n", Wnd2, GetActiveWindow());
2554 ok(GetFocus() == Wnd2, "expected focus %p, got %p\n", Wnd2, GetFocus());
2555
2556 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, (LPARAM)Wnd2);
2557
2558 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
2559 ok(ret, "AttachThreadInput error %d\n", GetLastError());
2560
2561 ok(GetActiveWindow() == Wnd2, "expected active %p, got %p\n", Wnd2, GetActiveWindow());
2562 ok(GetFocus() == Wnd2, "expected focus %p, got %p\n", Wnd2, GetFocus());
2563
2564 SendMessageA(wnd_event.hwnd, WM_USER+1, 0, 0);
2565
2566 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
2567 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
2568
2569 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2570 CloseHandle(hThread);
2571
2572 wnd_event.wait_event = CreateEventW(NULL, 0, 0, NULL);
2573 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
2574 wnd_event.attach_from = 0;
2575 wnd_event.attach_to = 0;
2576 wnd_event.setWindows = TRUE;
2577
2578 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
2579 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
2580
2581 SetLastError(0xdeadbeef);
2582 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
2583 ok(!ret, "AttachThreadInput succeeded\n");
2584 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef) /* <= Win XP */,
2585 "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2586
2587 SetLastError(0xdeadbeef);
2588 ret = AttachThreadInput(tid, GetCurrentThreadId(), TRUE);
2589 ok(!ret, "AttachThreadInput succeeded\n");
2590 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef) /* <= Win XP */,
2591 "expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2592
2593 SetEvent(wnd_event.wait_event);
2594
2595 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2596 CloseHandle(wnd_event.start_event);
2597
2598 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
2599 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
2600
2601 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2602 CloseHandle(hThread);
2603
2604 wnd_event.wait_event = NULL;
2605 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
2606 wnd_event.attach_from = GetCurrentThreadId();
2607 wnd_event.attach_to = 0;
2608 wnd_event.setWindows = FALSE;
2609
2610 SetFocus(ourWnd);
2611 SetActiveWindow(ourWnd);
2612
2613 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
2614 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
2615
2616 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2617 CloseHandle(wnd_event.start_event);
2618
2619 ok(GetActiveWindow() == ourWnd, "expected active %p, got %p\n", ourWnd, GetActiveWindow());
2620 ok(GetFocus() == ourWnd, "expected focus %p, got %p\n", ourWnd, GetFocus());
2621
2622 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
2623 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
2624
2625 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2626 CloseHandle(hThread);
2627
2628 wnd_event.wait_event = NULL;
2629 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
2630 wnd_event.attach_from = 0;
2631 wnd_event.attach_to = GetCurrentThreadId();
2632 wnd_event.setWindows = FALSE;
2633
2634 SetFocus(ourWnd);
2635 SetActiveWindow(ourWnd);
2636
2637 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
2638 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
2639
2640 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2641 CloseHandle(wnd_event.start_event);
2642
2643 ok(GetActiveWindow() == ourWnd, "expected active %p, got %p\n", ourWnd, GetActiveWindow());
2644 ok(GetFocus() == ourWnd, "expected focus %p, got %p\n", ourWnd, GetFocus());
2645
2646 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
2647 ok(ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
2648
2649 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2650 CloseHandle(hThread);
2651 DestroyWindow(ourWnd);
2652 DestroyWindow(Wnd2);
2653 }
2654
2655 static DWORD WINAPI get_key_state_thread(void *arg)
2656 {
2657 HANDLE *semaphores = arg;
2658 DWORD result;
2659
2660 ReleaseSemaphore(semaphores[0], 1, NULL);
2661 result = WaitForSingleObject(semaphores[1], 1000);
2662 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
2663
2664 result = GetKeyState('X');
2665 ok((result & 0x8000) || broken(!(result & 0x8000)), /* > Win 2003 */
2666 "expected that highest bit is set, got %x\n", result);
2667
2668 ReleaseSemaphore(semaphores[0], 1, NULL);
2669 result = WaitForSingleObject(semaphores[1], 1000);
2670 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
2671
2672 result = GetKeyState('X');
2673 ok(!(result & 0x8000), "expected that highest bit is unset, got %x\n", result);
2674
2675 return 0;
2676 }
2677
2678 static void test_GetKeyState(void)
2679 {
2680 HANDLE semaphores[2];
2681 HANDLE thread;
2682 DWORD result;
2683 HWND hwnd;
2684
2685 semaphores[0] = CreateSemaphoreA(NULL, 0, 1, NULL);
2686 ok(semaphores[0] != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
2687 semaphores[1] = CreateSemaphoreA(NULL, 0, 1, NULL);
2688 ok(semaphores[1] != NULL, "CreateSemaphoreA failed %u\n", GetLastError());
2689
2690 hwnd = CreateWindowA("static", "Title", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
2691 10, 10, 200, 200, NULL, NULL, NULL, NULL);
2692 ok(hwnd != NULL, "CreateWindowA failed %u\n", GetLastError());
2693
2694 thread = CreateThread(NULL, 0, get_key_state_thread, semaphores, 0, NULL);
2695 ok(thread != NULL, "CreateThread failed %u\n", GetLastError());
2696 result = WaitForSingleObject(semaphores[0], 1000);
2697 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
2698
2699 SetFocus(hwnd);
2700 keybd_event('X', 0, 0, 0);
2701
2702 ReleaseSemaphore(semaphores[1], 1, NULL);
2703 result = WaitForSingleObject(semaphores[0], 1000);
2704 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
2705
2706 keybd_event('X', 0, KEYEVENTF_KEYUP, 0);
2707
2708 ReleaseSemaphore(semaphores[1], 1, NULL);
2709 result = WaitForSingleObject(thread, 1000);
2710 ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result);
2711 CloseHandle(thread);
2712
2713 DestroyWindow(hwnd);
2714 CloseHandle(semaphores[0]);
2715 CloseHandle(semaphores[1]);
2716 }
2717
2718 static void test_OemKeyScan(void)
2719 {
2720 DWORD ret, expect, vkey, scan;
2721 WCHAR oem, wchr;
2722 char oem_char;
2723
2724 for (oem = 0; oem < 0x200; oem++)
2725 {
2726 ret = OemKeyScan( oem );
2727
2728 oem_char = LOBYTE( oem );
2729 if (!OemToCharBuffW( &oem_char, &wchr, 1 ))
2730 expect = -1;
2731 else
2732 {
2733 vkey = VkKeyScanW( wchr );
2734 scan = MapVirtualKeyW( LOBYTE( vkey ), MAPVK_VK_TO_VSC );
2735 if (!scan)
2736 expect = -1;
2737 else
2738 {
2739 vkey &= 0xff00;
2740 vkey <<= 8;
2741 expect = vkey | scan;
2742 }
2743 }
2744 ok( ret == expect, "%04x: got %08x expected %08x\n", oem, ret, expect );
2745 }
2746 }
2747
2748 START_TEST(input)
2749 {
2750 init_function_pointers();
2751
2752 if (pSendInput)
2753 {
2754 test_Input_blackbox();
2755 test_Input_whitebox();
2756 test_Input_unicode();
2757 test_Input_mouse();
2758 }
2759 else win_skip("SendInput is not available\n");
2760
2761 test_keynames();
2762 test_mouse_ll_hook();
2763 test_key_map();
2764 test_ToUnicode();
2765 test_ToAscii();
2766 test_get_async_key_state();
2767 test_keyboard_layout_name();
2768 test_key_names();
2769 test_attach_input();
2770 test_GetKeyState();
2771 test_OemKeyScan();
2772
2773 if(pGetMouseMovePointsEx)
2774 test_GetMouseMovePointsEx();
2775 else
2776 win_skip("GetMouseMovePointsEx is not available\n");
2777
2778 if(pGetRawInputDeviceList)
2779 test_GetRawInputDeviceList();
2780 else
2781 win_skip("GetRawInputDeviceList is not available\n");
2782 }
A free Windows-compatible Operating System