?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Don't invalidate the newly exposed child region on the parent if it doesn...
[wine.git] / dlls / user32 / tests / msg.c
blobe36eb7125e62615140bfd16813680652342a299f
1 /*
2 * Unit tests for window message handling
3 *
4 * Copyright 1999 Ove Kaaven
5 * Copyright 2003 Dimitrie O. Paun
6 * Copyright 2004,2005,2016 Dmitry Timoshkov
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <assert.h>
24 #include <limits.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winnls.h"
33 #include "dbt.h"
34 #include "commctrl.h"
35 #include "imm.h"
36
37 #include "wine/test.h"
38
39 #define MDI_FIRST_CHILD_ID 2004
40
41 /* undocumented SWP flags - from SDK 3.1 */
42 #define SWP_NOCLIENTSIZE 0x0800
43 #define SWP_NOCLIENTMOVE 0x1000
44 #define SWP_STATECHANGED 0x8000
45
46 #define SW_NORMALNA 0xCC /* undoc. flag in MinMaximize */
47
48 #ifndef WM_KEYF1
49 #define WM_KEYF1 0x004d
50 #endif
51
52 #ifndef WM_SYSTIMER
53 #define WM_SYSTIMER 0x0118
54 #endif
55
56 #define WND_PARENT_ID 1
57 #define WND_POPUP_ID 2
58 #define WND_CHILD_ID 3
59
60 #ifndef WM_LBTRACKPOINT
61 #define WM_LBTRACKPOINT 0x0131
62 #endif
63
64 #ifdef __i386__
65 #define ARCH "x86"
66 #elif defined __x86_64__
67 #define ARCH "amd64"
68 #elif defined __arm__
69 #define ARCH "arm"
70 #elif defined __aarch64__
71 #define ARCH "arm64"
72 #else
73 #define ARCH "none"
74 #endif
75
76 /* encoded DRAWITEMSTRUCT into an LPARAM */
77 typedef struct
78 {
79 union
80 {
81 struct
82 {
83 UINT type : 4; /* ODT_* flags */
84 UINT ctl_id : 4; /* Control ID */
85 UINT item_id : 4; /* Menu item ID */
86 UINT action : 4; /* ODA_* flags */
87 UINT state : 16; /* ODS_* flags */
88 } item;
89 LPARAM lp;
90 } u;
91 } DRAW_ITEM_STRUCT;
92
93 /* encoded MEASUREITEMSTRUCT into a WPARAM */
94 typedef struct
95 {
96 union
97 {
98 struct
99 {
100 UINT CtlType : 4;
101 UINT CtlID : 4;
102 UINT itemID : 4;
103 UINT wParam : 20;
104 } item;
105 WPARAM wp;
106 } u;
107 } MEASURE_ITEM_STRUCT;
108
109 static BOOL test_DestroyWindow_flag;
110 static BOOL test_context_menu;
111 static HWINEVENTHOOK hEvent_hook;
112 static HHOOK hKBD_hook;
113 static HHOOK hCBT_hook;
114 static DWORD cbt_hook_thread_id;
115 static DWORD winevent_hook_thread_id;
116
117 static const WCHAR testWindowClassW[] =
118 { 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
119
120 static LRESULT WINAPI ParentMsgCheckProcA(HWND, UINT, WPARAM, LPARAM);
121
122 /*
123 FIXME: add tests for these
124 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
125 WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
126 WS_THICKFRAME: thick border
127 WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
128 WS_BORDER (default for overlapped windows): single black border
129 none (default for child (and popup?) windows): no border
130 */
131
132 typedef enum {
133 sent=0x1,
134 posted=0x2,
135 parent=0x4,
136 wparam=0x8,
137 lparam=0x10,
138 defwinproc=0x20,
139 beginpaint=0x40,
140 optional=0x80,
141 hook=0x100,
142 winevent_hook=0x200,
143 kbd_hook=0x400,
144 winevent_hook_todo=0x800
145 } msg_flags_t;
146
147 struct message {
148 UINT message; /* the WM_* code */
149 msg_flags_t flags; /* message props */
150 WPARAM wParam; /* expected value of wParam */
151 LPARAM lParam; /* expected value of lParam */
152 WPARAM wp_mask; /* mask for wParam checks */
153 LPARAM lp_mask; /* mask for lParam checks */
154 };
155
156 struct recvd_message {
157 UINT message; /* the WM_* code */
158 msg_flags_t flags; /* message props */
159 HWND hwnd; /* window that received the message */
160 WPARAM wParam; /* expected value of wParam */
161 LPARAM lParam; /* expected value of lParam */
162 int line; /* source line where logged */
163 const char *descr; /* description for trace output */
164 char output[512]; /* trace output */
165 };
166
167 /* Empty message sequence */
168 static const struct message WmEmptySeq[] =
169 {
170 { 0 }
171 };
172 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
173 static const struct message WmCreateOverlappedSeq[] = {
174 { HCBT_CREATEWND, hook },
175 { WM_GETMINMAXINFO, sent },
176 { WM_NCCREATE, sent },
177 { WM_NCCALCSIZE, sent|wparam, 0 },
178 { 0x0093, sent|defwinproc|optional },
179 { 0x0094, sent|defwinproc|optional },
180 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on win10. */
181 { WM_CREATE, sent },
182 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
183 { 0 }
184 };
185 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
186 * for a not visible overlapped window.
187 */
188 static const struct message WmSWP_ShowOverlappedSeq[] = {
189 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
190 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
191 { WM_NCPAINT, sent|wparam|optional, 1 },
192 { WM_GETTEXT, sent|defwinproc|optional },
193 { WM_ERASEBKGND, sent|optional },
194 { HCBT_ACTIVATE, hook },
195 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
196 { WM_NOTIFYFORMAT, sent|optional },
197 { WM_QUERYUISTATE, sent|optional },
198 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
199 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
200 { WM_ACTIVATEAPP, sent|wparam, 1 },
201 { WM_NCACTIVATE, sent },
202 { WM_GETTEXT, sent|defwinproc|optional },
203 { WM_ACTIVATE, sent|wparam, 1 },
204 { HCBT_SETFOCUS, hook },
205 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
206 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
207 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
208 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
209 { WM_GETTEXT, sent|optional },
210 { WM_NCPAINT, sent|wparam|optional, 1 },
211 { WM_GETTEXT, sent|defwinproc|optional },
212 { WM_ERASEBKGND, sent|optional },
213 /* Win9x adds SWP_NOZORDER below */
214 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
215 { WM_GETTEXT, sent|optional },
216 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
217 { WM_NCPAINT, sent|wparam|optional, 1 },
218 { WM_ERASEBKGND, sent|optional },
219 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on win10 */
220 { WM_SYNCPAINT, sent|optional },
221 { WM_GETTITLEBARINFOEX, sent|optional },
222 { WM_PAINT, sent|optional },
223 { WM_NCPAINT, sent|beginpaint|optional },
224 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
225 { WM_ERASEBKGND, sent|beginpaint|optional },
226 { 0 }
227 };
228 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
229 * for a visible overlapped window.
230 */
231 static const struct message WmSWP_HideOverlappedSeq[] = {
232 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
233 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
234 { HCBT_ACTIVATE, hook|optional },
235 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
236 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
237 { WM_NCACTIVATE, sent|optional },
238 { WM_ACTIVATE, sent|optional },
239 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
240 { 0 }
241 };
242
243 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
244 * for a visible overlapped window.
245 */
246 static const struct message WmSWP_ResizeSeq[] = {
247 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
248 { WM_GETMINMAXINFO, sent|defwinproc },
249 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
250 { WM_NCPAINT, sent|optional },
251 { WM_GETTEXT, sent|defwinproc|optional },
252 { WM_ERASEBKGND, sent|optional },
253 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
254 { WM_SIZE, sent|defwinproc|optional },
255 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
256 { WM_NCPAINT, sent|optional },
257 { WM_GETTEXT, sent|defwinproc|optional },
258 { WM_ERASEBKGND, sent|optional },
259 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
260 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
261 { 0 }
262 };
263
264 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
265 * for a visible popup window.
266 */
267 static const struct message WmSWP_ResizePopupSeq[] = {
268 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
269 { WM_GETMINMAXINFO, sent|defwinproc|optional }, /* Win9x */
270 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
271 { WM_NCPAINT, sent|optional },
272 { WM_GETTEXT, sent|defwinproc|optional },
273 { WM_ERASEBKGND, sent|optional },
274 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
275 { WM_SIZE, sent|defwinproc|wparam|optional, SIZE_RESTORED },
276 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
277 { WM_NCPAINT, sent|optional },
278 { WM_GETTEXT, sent|defwinproc|optional },
279 { WM_ERASEBKGND, sent|optional },
280 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
281 { 0 }
282 };
283
284 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
285 * for a visible overlapped window.
286 */
287 static const struct message WmSWP_MoveSeq[] = {
288 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE },
289 { WM_NCPAINT, sent|optional },
290 { WM_GETTEXT, sent|defwinproc|optional },
291 { WM_ERASEBKGND, sent|optional },
292 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
293 { WM_MOVE, sent|defwinproc|wparam, 0 },
294 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
295 { 0 }
296 };
297 /* Resize with SetWindowPos(SWP_NOZORDER)
298 * for a visible overlapped window
299 * SWP_NOZORDER is stripped by the logging code
300 */
301 static const struct message WmSWP_ResizeNoZOrder[] = {
302 { WM_WINDOWPOSCHANGING, sent|wparam, /*SWP_NOZORDER|*/SWP_NOACTIVATE },
303 { WM_GETMINMAXINFO, sent|defwinproc },
304 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
305 { WM_NCPAINT, sent|optional },
306 { WM_GETTEXT, sent|defwinproc|optional },
307 { WM_ERASEBKGND, sent|optional },
308 { WM_WINDOWPOSCHANGED, sent|wparam|optional, /*SWP_NOZORDER|*/SWP_NOACTIVATE, 0,
309 SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
310 { WM_MOVE, sent|defwinproc|optional },
311 { WM_SIZE, sent|defwinproc|optional },
312 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
313 { WM_NCPAINT, sent|optional }, /* Win9x doesn't send it */
314 { WM_GETTEXT, sent|defwinproc|optional }, /* Win9x doesn't send it */
315 { WM_ERASEBKGND, sent|optional }, /* Win9x doesn't send it */
316 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
317 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on win10. */
318 { 0 }
319 };
320
321 /* Switch visible mdi children */
322 static const struct message WmSwitchChild[] = {
323 /* Switch MDI child */
324 { WM_MDIACTIVATE, sent },/* in the MDI client */
325 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 1st MDI child */
326 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
327 { WM_CHILDACTIVATE, sent },/* in the 1st MDI child */
328 /* Deactivate 2nd MDI child */
329 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
330 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
331 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
332 /* Preparing for maximize and maximize the 1st MDI child */
333 { WM_GETMINMAXINFO, sent|defwinproc }, /* in the 1st MDI child */
334 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED }, /* in the 1st MDI child */
335 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
336 { WM_CHILDACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
337 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 1st MDI child */
338 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED }, /* in the 1st MDI child */
339 /* Lock redraw 2nd MDI child */
340 { WM_SETREDRAW, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
341 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
342 /* Restore 2nd MDI child */
343 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },/* in the 2nd MDI child */
344 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
345 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
346 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 2nd MDI child */
347 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED }, /* in the 2nd MDI child */
348 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
349 /* Redraw 2nd MDI child */
350 { WM_SETREDRAW, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
351 /* Redraw MDI frame */
352 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },/* in MDI frame */
353 { WM_NCCALCSIZE, sent|wparam, 1 },/* in MDI frame */
354 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in MDI frame */
355 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in MDI frame */
356 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
357 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
358 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
359 { HCBT_SETFOCUS, hook },
360 { WM_KILLFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
361 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },/* in the 1st MDI child */
362 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
363 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
364 { WM_SETFOCUS, sent },/* in the MDI client */
365 { HCBT_SETFOCUS, hook },
366 { WM_KILLFOCUS, sent },/* in the MDI client */
367 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
368 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 }, /* in the 1st MDI child */
369 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
370 { WM_SETFOCUS, sent|defwinproc }, /* in the 1st MDI child */
371 { WM_MDIACTIVATE, sent|defwinproc },/* in the 1st MDI child */
372 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* in the 1st MDI child */
373 { 0 }
374 };
375
376 /* Switch visible not maximized mdi children */
377 static const struct message WmSwitchNotMaximizedChild[] = {
378 /* Switch not maximized MDI child */
379 { WM_MDIACTIVATE, sent },/* in the MDI client */
380 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 2nd MDI child */
381 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
382 { WM_CHILDACTIVATE, sent },/* in the 2nd MDI child */
383 /* Deactivate 1st MDI child */
384 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
385 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
386 /* Activate 2nd MDI child */
387 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE}, /* in the 2nd MDI child */
388 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 2nd MDI child */
389 { HCBT_SETFOCUS, hook }, /* in the 1st MDI child */
390 { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
391 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
392 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
393 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
394 { WM_SETFOCUS, sent, 0 }, /* in the MDI client */
395 { HCBT_SETFOCUS, hook },
396 { WM_KILLFOCUS, sent }, /* in the MDI client */
397 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
398 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
399 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
400 { WM_SETFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
401 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
402 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in the 2nd MDI child */
403 { 0 }
404 };
405
406
407 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
408 SWP_NOZORDER|SWP_FRAMECHANGED)
409 * for a visible overlapped window with WS_CLIPCHILDREN style set.
410 */
411 static const struct message WmSWP_FrameChanged_clip[] = {
412 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
413 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
414 { WM_NCPAINT, sent|parent|optional }, /* wparam != 1 */
415 { WM_GETTEXT, sent|parent|defwinproc|optional },
416 { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
417 { WM_NCPAINT, sent }, /* wparam != 1 */
418 { WM_ERASEBKGND, sent },
419 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
420 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
421 { WM_PAINT, sent },
422 { 0 }
423 };
424 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
425 SWP_NOZORDER|SWP_FRAMECHANGED)
426 * for a visible overlapped window.
427 */
428 static const struct message WmSWP_FrameChangedDeferErase[] = {
429 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
430 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
431 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
432 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
433 { WM_PAINT, sent|parent|optional },
434 { WM_NCPAINT, sent|beginpaint|parent|optional }, /* wparam != 1 */
435 { WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
436 { WM_PAINT, sent },
437 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
438 { WM_ERASEBKGND, sent|beginpaint|optional },
439 { 0 }
440 };
441
442 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
443 SWP_NOZORDER|SWP_FRAMECHANGED)
444 * for a visible overlapped window without WS_CLIPCHILDREN style set.
445 */
446 static const struct message WmSWP_FrameChanged_noclip[] = {
447 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
448 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
449 { WM_NCPAINT, sent|parent|optional }, /* wparam != 1 */
450 { WM_GETTEXT, sent|parent|defwinproc|optional },
451 { WM_ERASEBKGND, sent|parent|optional },
452 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
453 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
454 { WM_PAINT, sent },
455 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
456 { WM_ERASEBKGND, sent|beginpaint|optional },
457 { 0 }
458 };
459
460 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
461 static const struct message WmShowOverlappedSeq[] = {
462 { WM_SHOWWINDOW, sent|wparam, 1 },
463 { WM_NCPAINT, sent|wparam|optional, 1 },
464 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
465 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
466 { WM_NCPAINT, sent|wparam|optional, 1 },
467 { WM_GETTEXT, sent|defwinproc|optional },
468 { WM_ERASEBKGND, sent|optional },
469 { HCBT_ACTIVATE, hook|optional },
470 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|optional, 0, 0 },
471 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
472 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
473 { WM_NCPAINT, sent|wparam|optional, 1 },
474 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
475 { WM_NCACTIVATE, sent|wparam|optional, 1 },
476 { WM_GETTEXT, sent|defwinproc|optional },
477 { WM_ACTIVATE, sent|wparam|optional, 1 },
478 { HCBT_SETFOCUS, hook|optional },
479 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
480 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
481 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
482 { WM_SETFOCUS, sent|wparam|defwinproc|optional, 0 },
483 { WM_GETTEXT, sent|optional },
484 { WM_NCPAINT, sent|wparam|optional, 1 },
485 { WM_GETTEXT, sent|defwinproc|optional },
486 { WM_ERASEBKGND, sent|optional },
487 /* Win9x adds SWP_NOZORDER below */
488 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
489 { WM_NCCALCSIZE, sent|optional },
490 { WM_GETTEXT, sent|optional },
491 { WM_NCPAINT, sent|optional },
492 { WM_ERASEBKGND, sent|optional },
493 { WM_SYNCPAINT, sent|optional },
494 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
495 * messages. Does that mean that CreateWindow doesn't set initial
496 * window dimensions for overlapped windows?
497 */
498 { WM_SIZE, sent },
499 { WM_MOVE, sent },
500 #endif
501 { WM_PAINT, sent|optional },
502 { WM_NCPAINT, sent|beginpaint|optional },
503 { 0 }
504 };
505 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
506 static const struct message WmShowMaxOverlappedSeq[] = {
507 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
508 { WM_GETMINMAXINFO, sent },
509 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
510 { WM_GETMINMAXINFO, sent|defwinproc },
511 { WM_NCCALCSIZE, sent|wparam, TRUE },
512 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
513 { HCBT_ACTIVATE, hook|optional },
514 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|optional, 0, 0 },
515 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
516 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
517 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
518 { WM_NCACTIVATE, sent|wparam|optional, 1 },
519 { WM_GETTEXT, sent|defwinproc|optional },
520 { WM_ACTIVATE, sent|wparam|optional, 1 },
521 { HCBT_SETFOCUS, hook|optional },
522 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
523 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
524 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
525 { WM_SETFOCUS, sent|wparam|defwinproc|optional, 0 },
526 { WM_GETTEXT, sent|optional },
527 { WM_NCPAINT, sent|wparam|optional, 1 },
528 { WM_GETTEXT, sent|defwinproc|optional },
529 { WM_ERASEBKGND, sent|optional },
530 /* Win9x adds SWP_NOZORDER below */
531 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
532 { WM_MOVE, sent|defwinproc },
533 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
534 { WM_GETTEXT, sent|optional },
535 { WM_NCCALCSIZE, sent|optional },
536 { WM_NCPAINT, sent|optional },
537 { WM_ERASEBKGND, sent|optional },
538 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
539 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on win10. */
540 { WM_SYNCPAINT, sent|optional },
541 { WM_GETTITLEBARINFOEX, sent|optional },
542 { WM_PAINT, sent|optional },
543 { WM_NCPAINT, sent|beginpaint|optional },
544 { WM_ERASEBKGND, sent|beginpaint|optional },
545 { 0 }
546 };
547 /* ShowWindow(SW_RESTORE) for a not visible maximized overlapped window */
548 static const struct message WmShowRestoreMaxOverlappedSeq[] = {
549 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
550 { WM_GETTEXT, sent|optional },
551 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
552 { WM_GETMINMAXINFO, sent|defwinproc },
553 { WM_NCCALCSIZE, sent|wparam, TRUE },
554 { WM_NCPAINT, sent|optional },
555 { WM_GETTEXT, sent|defwinproc|optional },
556 { WM_ERASEBKGND, sent|optional },
557 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
558 { WM_MOVE, sent|defwinproc|optional },
559 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
560 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
561 { WM_NCPAINT, sent|optional },
562 { WM_ERASEBKGND, sent|optional },
563 { WM_PAINT, sent|optional },
564 { WM_GETTITLEBARINFOEX, sent|optional },
565 { WM_NCPAINT, sent|beginpaint|optional },
566 { WM_ERASEBKGND, sent|beginpaint|optional },
567 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
568 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
569 { WM_SYNCPAINT, sent|optional },
570 { 0 }
571 };
572 /* ShowWindow(SW_RESTORE) for a not visible minimized overlapped window */
573 static const struct message WmShowRestoreMinOverlappedSeq[] = {
574 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
575 { WM_QUERYOPEN, sent|optional },
576 { WM_GETTEXT, sent|optional },
577 { WM_NCACTIVATE, sent|wparam|optional, 1 },
578 { WM_WINDOWPOSCHANGING, sent|optional }, /* SWP_NOSIZE|SWP_NOMOVE */
579 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
580 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
581 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sent on Win7. */
582 { WM_MOVE, sent|optional },
583 { WM_SIZE, sent|wparam|optional, SIZE_RESTORED },
584 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sent on Win7. */
585 { WM_GETTEXT, sent|optional },
586 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED|SWP_NOCOPYBITS },
587 { WM_GETMINMAXINFO, sent|defwinproc|optional },
588 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
589 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sent on Win10. */
590 { HCBT_ACTIVATE, hook|optional },
591 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|optional, 0, 0 },
592 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
593 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
594 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
595 { WM_NCACTIVATE, sent|wparam|optional, 1 },
596 { WM_GETTEXT, sent|defwinproc|optional },
597 { WM_ACTIVATE, sent|wparam|optional, 1 },
598 { HCBT_SETFOCUS, hook|optional },
599 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
600 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
601 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
602 { WM_SETFOCUS, sent|wparam|defwinproc|optional, 0 },
603 { WM_GETTEXT, sent|optional },
604 { WM_NCPAINT, sent|wparam|optional, 1 },
605 { WM_GETTEXT, sent|defwinproc|optional },
606 { WM_ERASEBKGND, sent },
607 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_STATECHANGED|SWP_FRAMECHANGED|SWP_NOCOPYBITS },
608 { WM_MOVE, sent|defwinproc },
609 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
610 { HCBT_SETFOCUS, hook|optional },
611 { WM_SETFOCUS, sent|wparam|optional, 0 },
612 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
613 { WM_NCPAINT, sent|wparam|optional, 1 },
614 { WM_ERASEBKGND, sent|optional },
615 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
616 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
617 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
618 { HCBT_SETFOCUS, hook|optional },
619 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
620 { WM_SETFOCUS, sent|wparam|optional, 0 },
621 { WM_ACTIVATE, sent|wparam, 1 },
622 { WM_GETTEXT, sent|optional },
623 { WM_PAINT, sent|optional },
624 { WM_GETTITLEBARINFOEX, sent|optional },
625 { WM_NCPAINT, sent|beginpaint|optional },
626 { WM_ERASEBKGND, sent|beginpaint|optional },
627 { 0 }
628 };
629 /* ShowWindow(SW_SHOWMINIMIZED) for a not visible overlapped window */
630 static const struct message WmShowMinOverlappedSeq[] = {
631 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
632 { HCBT_SETFOCUS, hook|optional },
633 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
634 { WM_KILLFOCUS, sent|optional },
635 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
636 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
637 { WM_GETTEXT, sent|optional },
638 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCOPYBITS|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
639 { WM_GETMINMAXINFO, sent|defwinproc },
640 { WM_NCCALCSIZE, sent|wparam, TRUE },
641 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
642 { WM_NCPAINT, sent|optional },
643 { WM_GETTEXT, sent|defwinproc|optional },
644 { WM_WINDOWPOSCHANGED, sent },
645 { WM_MOVE, sent|defwinproc },
646 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
647 { WM_NCCALCSIZE, sent|optional },
648 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
649 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on win10. */
650 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
651 { WM_NCACTIVATE, sent|wparam|optional, 0 },
652 { WM_GETTEXT, sent|defwinproc|optional },
653 { WM_ACTIVATE, sent|optional },
654 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
655
656 /* Vista sometimes restores the window right away... */
657 { WM_SYSCOMMAND, sent|optional|wparam, SC_RESTORE },
658 { HCBT_SYSCOMMAND, hook|optional|wparam, SC_RESTORE },
659 { HCBT_MINMAX, hook|optional|lparam, 0, SW_RESTORE },
660 { WM_QUERYOPEN, sent|optional },
661 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
662 { WM_GETMINMAXINFO, sent|optional|defwinproc },
663 { WM_NCCALCSIZE, sent|optional|wparam, TRUE },
664 { HCBT_ACTIVATE, hook|optional },
665 { WM_ACTIVATEAPP, sent|optional|wparam, 1 },
666 { WM_NCACTIVATE, sent|optional },
667 { WM_GETTEXT, sent|optional },
668 { WM_ACTIVATE, sent|optional|wparam, 1 },
669 { HCBT_SETFOCUS, hook|optional },
670 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
671 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
672 { WM_SETFOCUS, sent|optional },
673 { WM_NCPAINT, sent|optional },
674 { WM_GETTEXT, sent|defwinproc|optional },
675 { WM_ERASEBKGND, sent|optional },
676 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
677 { WM_MOVE, sent|defwinproc|optional },
678 { WM_SIZE, sent|defwinproc|optional|wparam, SIZE_RESTORED },
679 { WM_ACTIVATE, sent|optional|wparam, 1 },
680 { WM_SYSCOMMAND, sent|optional|wparam, SC_RESTORE },
681 { HCBT_SYSCOMMAND, hook|optional|wparam, SC_RESTORE },
682
683 { WM_PAINT, sent|optional },
684 { WM_NCPAINT, sent|beginpaint|optional },
685 { WM_ERASEBKGND, sent|beginpaint|optional },
686 { 0 }
687 };
688 /* ShowWindow(SW_HIDE) for a visible overlapped window */
689 static const struct message WmHideOverlappedSeq[] = {
690 { WM_SHOWWINDOW, sent|wparam, 0 },
691 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
692 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
693 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
694 { WM_SIZE, sent|optional }, /* XP doesn't send it */
695 { WM_MOVE, sent|optional }, /* XP doesn't send it */
696 { WM_NCACTIVATE, sent|wparam|optional, 0 },
697 { WM_ACTIVATE, sent|wparam|optional, 0 },
698 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
699 { HCBT_SETFOCUS, hook|optional },
700 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
701 { WM_KILLFOCUS, sent|wparam|optional, 0 },
702 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
703 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
704 { 0 }
705 };
706 /* DestroyWindow for a visible overlapped window */
707 static const struct message WmDestroyOverlappedSeq[] = {
708 { HCBT_DESTROYWND, hook },
709 { 0x0090, sent|optional },
710 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
711 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
712 { 0x0090, sent|optional },
713 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
714 { WM_NCACTIVATE, sent|optional|wparam, 0 },
715 { WM_ACTIVATE, sent|optional },
716 { WM_ACTIVATEAPP, sent|optional|wparam, 0 },
717 { WM_KILLFOCUS, sent|optional|wparam, 0 },
718 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
719 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
720 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
721 { WM_DESTROY, sent },
722 { WM_NCDESTROY, sent },
723 { 0 }
724 };
725 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
726 static const struct message WmCreateMaxPopupSeq[] = {
727 { HCBT_CREATEWND, hook },
728 { WM_NCCREATE, sent },
729 { WM_NCCALCSIZE, sent|wparam, 0 },
730 { WM_CREATE, sent },
731 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
732 { WM_SIZE, sent|wparam, SIZE_RESTORED },
733 { WM_MOVE, sent },
734 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
735 { WM_GETMINMAXINFO, sent },
736 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
737 { WM_NCCALCSIZE, sent|wparam, TRUE },
738 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
739 { WM_MOVE, sent|defwinproc },
740 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
741 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
742 { WM_SHOWWINDOW, sent|wparam, 1 },
743 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
744 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
745 { HCBT_ACTIVATE, hook },
746 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
747 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
748 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
749 { WM_NCPAINT, sent|wparam|optional, 1 },
750 { WM_ERASEBKGND, sent|optional },
751 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_NOMOVE|SWP_NOSIZE },
752 { WM_ACTIVATEAPP, sent|wparam, 1 },
753 { WM_NCACTIVATE, sent },
754 { WM_ACTIVATE, sent|wparam, 1 },
755 { HCBT_SETFOCUS, hook },
756 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
757 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
758 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
759 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
760 { WM_GETTEXT, sent|optional },
761 { WM_SYNCPAINT, sent|wparam|optional, 4 },
762 { WM_NCPAINT, sent|wparam|optional, 1 },
763 { WM_ERASEBKGND, sent|optional },
764 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
765 { WM_ERASEBKGND, sent|defwinproc|optional },
766 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
767 { 0 }
768 };
769 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
770 static const struct message WmCreateInvisibleMaxPopupSeq[] = {
771 { HCBT_CREATEWND, hook },
772 { WM_NCCREATE, sent },
773 { WM_NCCALCSIZE, sent|wparam, 0 },
774 { WM_CREATE, sent },
775 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
776 { WM_SIZE, sent|wparam, SIZE_RESTORED },
777 { WM_MOVE, sent },
778 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
779 { WM_GETMINMAXINFO, sent },
780 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
781 { WM_NCCALCSIZE, sent|wparam, TRUE },
782 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
783 { WM_MOVE, sent|defwinproc },
784 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
785 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
786 { 0 }
787 };
788 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
789 static const struct message WmShowMaxPopupResizedSeq[] = {
790 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
791 { WM_GETMINMAXINFO, sent },
792 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED, 0, SWP_STATECHANGED /* w1064v1809 */ },
793 { WM_NCCALCSIZE, sent|wparam, TRUE },
794 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
795 { HCBT_ACTIVATE, hook },
796 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
797 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
798 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
799 { WM_NCPAINT, sent|wparam|optional, 1 },
800 { WM_ERASEBKGND, sent|optional },
801 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
802 { WM_ACTIVATEAPP, sent|wparam, 1 },
803 { WM_NCACTIVATE, sent },
804 { WM_ACTIVATE, sent|wparam, 1 },
805 { HCBT_SETFOCUS, hook },
806 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
807 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
808 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
809 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
810 { WM_GETTEXT, sent|optional },
811 { WM_NCPAINT, sent|wparam|optional, 1 },
812 { WM_ERASEBKGND, sent|optional },
813 { WM_WINDOWPOSCHANGED, sent },
814 /* WinNT4.0 sends WM_MOVE */
815 { WM_MOVE, sent|defwinproc|optional },
816 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
817 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
818 { 0 }
819 };
820 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
821 static const struct message WmShowMaxPopupSeq[] = {
822 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
823 { WM_GETMINMAXINFO, sent },
824 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED, 0, SWP_STATECHANGED /* w1064v1809 */ },
825 { WM_NCCALCSIZE, sent|wparam, TRUE },
826 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
827 { HCBT_ACTIVATE, hook },
828 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
829 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
830 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
831 { WM_NCPAINT, sent|wparam|optional, 1 },
832 { WM_ERASEBKGND, sent|optional },
833 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOMOVE|SWP_NOSIZE },
834 { WM_ACTIVATEAPP, sent|wparam, 1 },
835 { WM_NCACTIVATE, sent },
836 { WM_ACTIVATE, sent|wparam, 1 },
837 { HCBT_SETFOCUS, hook },
838 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
839 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
840 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
841 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
842 { WM_GETTEXT, sent|optional },
843 { WM_SYNCPAINT, sent|wparam|optional, 4 },
844 { WM_NCPAINT, sent|wparam|optional, 1 },
845 { WM_ERASEBKGND, sent|optional },
846 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
847 { WM_ERASEBKGND, sent|defwinproc|optional },
848 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE, 0, SWP_STATECHANGED /* w1064v1809 */ },
849 { WM_SIZE, sent|defwinproc|optional },
850 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
851 { 0 }
852 };
853 /* CreateWindow(WS_VISIBLE) for popup window */
854 static const struct message WmCreatePopupSeq[] = {
855 { HCBT_CREATEWND, hook },
856 { WM_NCCREATE, sent },
857 { WM_NCCALCSIZE, sent|wparam, 0 },
858 { WM_CREATE, sent },
859 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
860 { WM_SIZE, sent|wparam, SIZE_RESTORED },
861 { WM_MOVE, sent },
862 { WM_SHOWWINDOW, sent|wparam, 1 },
863 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
864 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
865 { HCBT_ACTIVATE, hook },
866 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
867 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
868 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
869 { WM_NCPAINT, sent|wparam|optional, 1 },
870 { WM_ERASEBKGND, sent|optional },
871 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
872 { WM_ACTIVATEAPP, sent|wparam, 1 },
873 { WM_NCACTIVATE, sent },
874 { WM_ACTIVATE, sent|wparam, 1 },
875 { HCBT_SETFOCUS, hook },
876 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
877 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
878 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
879 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
880 { WM_GETTEXT, sent|optional },
881 { WM_SYNCPAINT, sent|wparam|optional, 4 },
882 { WM_NCPAINT, sent|wparam|optional, 1 },
883 { WM_ERASEBKGND, sent|optional },
884 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
885 { 0 }
886 };
887 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
888 static const struct message WmShowVisMaxPopupSeq[] = {
889 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
890 { WM_GETMINMAXINFO, sent },
891 { WM_GETTEXT, sent|optional },
892 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
893 { WM_GETTEXT, sent|optional },
894 { WM_NCCALCSIZE, sent|wparam, TRUE },
895 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
896 { WM_NCPAINT, sent|wparam|optional, 1 },
897 { WM_ERASEBKGND, sent|optional },
898 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
899 { WM_MOVE, sent|defwinproc },
900 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
901 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
902 { 0 }
903 };
904 /* ShowWindow(hwnd, SW_RESTORE) to a minimized window */
905 static const struct message WmShowRestoreMinimizedOverlappedSeq[] =
906 {
907 { HCBT_MINMAX, hook },
908 { WM_QUERYOPEN, sent },
909 { WM_GETTEXT, sent|optional },
910 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
911 { WM_GETMINMAXINFO, sent|defwinproc },
912 { WM_NCCALCSIZE, sent },
913 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
914 { HCBT_ACTIVATE, hook },
915 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
916 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
917 { WM_NCACTIVATE, sent },
918 { WM_GETTEXT, sent|defwinproc|optional },
919 { WM_ACTIVATE, sent|wparam, WA_ACTIVE },
920 { HCBT_SETFOCUS, hook },
921 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
922 { WM_SETFOCUS, sent|defwinproc },
923 { WM_NCPAINT, sent },
924 { WM_GETTEXT, sent|defwinproc|optional },
925 { WM_GETTEXT, sent|defwinproc|optional },
926 { WM_ERASEBKGND, sent },
927 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
928 { WM_MOVE, sent|defwinproc },
929 { WM_SIZE, sent|defwinproc },
930 { WM_NCCALCSIZE, sent|optional },
931 { WM_NCPAINT, sent|optional },
932 { WM_ERASEBKGND, sent|optional },
933 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
934 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
935 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
936 /* Note this WM_ACTIVATE message even if the window is already active and focused */
937 { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, 0 },
938 { WM_SYNCPAINT, sent|optional },
939 { WM_PAINT, sent },
940 { WM_GETMINMAXINFO, sent|optional },
941 { 0 }
942 };
943 /* ShowWindow(hwnd, SW_SHOWNOACTIVATE) to a minimized window */
944 static const struct message WmShowNoActivateMinimizedOverlappedSeq[] =
945 {
946 { HCBT_MINMAX, hook },
947 { WM_QUERYOPEN, sent },
948 { WM_GETTEXT, sent|optional },
949 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
950 { WM_GETMINMAXINFO, sent|defwinproc },
951 { WM_NCCALCSIZE, sent },
952 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
953 { WM_NCPAINT, sent },
954 { WM_GETTEXT, sent|defwinproc|optional },
955 { WM_ERASEBKGND, sent },
956 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
957 { WM_MOVE, sent|defwinproc },
958 { WM_SIZE, sent|defwinproc },
959 /* Following optional messages are on XP/2003 */
960 { WM_NCCALCSIZE, sent|optional },
961 { WM_NCPAINT, sent|optional },
962 { WM_ERASEBKGND, sent|optional },
963 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
964 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
965 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
966 { HCBT_SETFOCUS, hook|optional },
967 { WM_SETFOCUS, sent|optional },
968 { HCBT_ACTIVATE, hook|optional },
969 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
970 { WM_NCACTIVATE, sent|optional },
971 { WM_GETTEXT, sent|defwinproc|optional },
972 { WM_ACTIVATE, sent|wparam|optional, WA_ACTIVE },
973 { HCBT_SETFOCUS, hook|optional },
974 { WM_SETFOCUS, sent|defwinproc|optional },
975 { WM_KILLFOCUS, sent|optional },
976 { WM_SETFOCUS, sent|optional },
977 /* Note this WM_ACTIVATE message on XP even if the window is already active and focused */
978 { WM_ACTIVATE, sent|wparam|lparam|optional, WA_ACTIVE, 0 },
979 { WM_SYNCPAINT, sent|optional },
980 { WM_PAINT, sent },
981 { WM_GETMINMAXINFO, sent|optional },
982 { 0 }
983 };
984 /* ShowWindow(hwnd, SW_RESTORE) to an active minimized window */
985 static const struct message WmShowRestoreActiveMinimizedOverlappedSeq[] =
986 {
987 { HCBT_MINMAX, hook },
988 { WM_QUERYOPEN, sent },
989 { WM_GETTEXT, sent|optional },
990 { WM_NCACTIVATE, sent },
991 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
992 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
993 { WM_NCCALCSIZE, sent|optional },
994 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends this. */
995 { WM_MOVE, sent|optional },
996 { WM_SIZE, sent|optional },
997 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends this. */
998 { WM_GETTEXT, sent|optional },
999 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1000 { WM_GETMINMAXINFO, sent|defwinproc },
1001 { WM_NCCALCSIZE, sent },
1002 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win8+ sends this. */
1003 { WM_NCPAINT, sent },
1004 { WM_GETTEXT, sent|defwinproc|optional },
1005 { WM_ERASEBKGND, sent },
1006 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1007 { WM_MOVE, sent|defwinproc },
1008 { WM_SIZE, sent|defwinproc },
1009 { WM_NCCALCSIZE, sent|optional },
1010 { WM_NCPAINT, sent|optional },
1011 { WM_ERASEBKGND, sent|optional },
1012 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1013 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
1014 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1015 { HCBT_SETFOCUS, hook },
1016 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1017 { WM_SETFOCUS, sent },
1018 /* Note this WM_ACTIVATE message even if the window is already active */
1019 { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, 0 },
1020 { WM_SYNCPAINT, sent|optional },
1021 { WM_PAINT, sent },
1022 { WM_GETMINMAXINFO, sent|optional },
1023 { 0 }
1024 };
1025 /* ShowWindow(hwnd, SW_SHOWNOACTIVATE) to an active minimized window */
1026 static const struct message WmShowNoActivateActiveMinimizedOverlappedSeq[] =
1027 {
1028 { HCBT_MINMAX, hook },
1029 { WM_QUERYOPEN, sent },
1030 { WM_GETTEXT, sent|optional },
1031 { WM_NCACTIVATE, sent },
1032 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1033 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1034 { WM_NCCALCSIZE, sent|optional },
1035 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends this. */
1036 { WM_MOVE, sent|optional },
1037 { WM_SIZE, sent|optional },
1038 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends this. */
1039 { WM_GETTEXT, sent|optional },
1040 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1041 { WM_GETMINMAXINFO, sent|defwinproc },
1042 { WM_NCCALCSIZE, sent },
1043 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win8+ sends this. */
1044 { WM_NCPAINT, sent },
1045 { WM_GETTEXT, sent|defwinproc|optional },
1046 { WM_ERASEBKGND, sent },
1047 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1048 { WM_MOVE, sent|defwinproc },
1049 { WM_SIZE, sent|defwinproc },
1050 { WM_NCCALCSIZE, sent|optional },
1051 { WM_NCPAINT, sent|optional },
1052 { WM_ERASEBKGND, sent|optional },
1053 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1054 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
1055 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1056 /* Following optional messages are present on XP */
1057 { HCBT_SETFOCUS, hook|optional },
1058 { WM_SETFOCUS, sent|optional },
1059 /* Note this WM_ACTIVATE message even if the window is already active and with flag SW_SHOWNOACTIVATE */
1060 { WM_ACTIVATE, sent|wparam|lparam|optional, WA_ACTIVE, 0 },
1061 { WM_SYNCPAINT, sent|optional },
1062 { WM_PAINT, sent },
1063 { WM_GETMINMAXINFO, sent|optional },
1064 { 0 }
1065 };
1066 /* CreateWindow (for a child popup window, not initially visible) */
1067 static const struct message WmCreateChildPopupSeq[] = {
1068 { HCBT_CREATEWND, hook },
1069 { WM_NCCREATE, sent },
1070 { WM_NCCALCSIZE, sent|wparam, 0 },
1071 { WM_CREATE, sent },
1072 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1073 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1074 { WM_MOVE, sent },
1075 { 0 }
1076 };
1077 /* CreateWindow (for a popup window, not initially visible,
1078 * which sets WS_VISIBLE in WM_CREATE handler)
1079 */
1080 static const struct message WmCreateInvisiblePopupSeq[] = {
1081 { HCBT_CREATEWND, hook },
1082 { WM_NCCREATE, sent },
1083 { WM_NCCALCSIZE, sent|wparam, 0 },
1084 { WM_CREATE, sent },
1085 { WM_STYLECHANGING, sent },
1086 { WM_STYLECHANGED, sent },
1087 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1088 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1089 { WM_MOVE, sent },
1090 { 0 }
1091 };
1092 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
1093 * for a popup window with WS_VISIBLE style set
1094 */
1095 static const struct message WmShowVisiblePopupSeq_2[] = {
1096 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1097 { 0 }
1098 };
1099 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
1100 * for a popup window with WS_VISIBLE style set
1101 */
1102 static const struct message WmShowVisiblePopupSeq_3[] = {
1103 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1104 { HCBT_ACTIVATE, hook },
1105 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1106 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1107 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1108 { WM_NCACTIVATE, sent },
1109 { WM_ACTIVATE, sent|wparam, 1 },
1110 { HCBT_SETFOCUS, hook },
1111 { WM_KILLFOCUS, sent|parent },
1112 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1113 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1114 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1115 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1116 { WM_SETFOCUS, sent|defwinproc },
1117 { WM_GETTEXT, sent|optional },
1118 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_SHOWWINDOW },
1119 { 0 }
1120 };
1121 /* CreateWindow (for a popup window with WS_VISIBLE style set and extreme location)
1122 */
1123 static const struct message WmShowPopupExtremeLocationSeq[] = {
1124 { HCBT_CREATEWND, hook },
1125 { WM_NCCREATE, sent },
1126 { WM_NCCALCSIZE, sent|wparam, 0 },
1127 { WM_CREATE, sent },
1128 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1129 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1130 { WM_MOVE, sent },
1131 { WM_SHOWWINDOW, sent|wparam, 1 },
1132 { WM_WINDOWPOSCHANGING, sent },
1133 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1134 { HCBT_ACTIVATE, hook },
1135 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1136 { WM_WINDOWPOSCHANGING, sent|optional },
1137 { WM_QUERYNEWPALETTE, sent|optional },
1138
1139 /* occasionally received on test machines */
1140 { WM_NCPAINT, sent|optional },
1141 { WM_ERASEBKGND, sent|optional },
1142 { WM_WINDOWPOSCHANGED, sent|optional },
1143
1144 { WM_ACTIVATEAPP, sent },
1145 { WM_NCACTIVATE, sent },
1146 { WM_ACTIVATE, sent },
1147 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1148 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1149 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1150 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1151 { HCBT_SETFOCUS, hook },
1152 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1153 { WM_SETFOCUS, sent|defwinproc },
1154 { WM_NCPAINT, sent|wparam|optional, 1 }, /* Not always sent on Win8+ */
1155 { WM_ERASEBKGND, sent|optional }, /* Not always sent on Win8+ */
1156 { WM_WINDOWPOSCHANGED, sent },
1157 /* occasionally received on test machines */
1158 { WM_NCPAINT, sent|optional },
1159 { WM_ERASEBKGND, sent|optional },
1160 { 0 }
1161 };
1162 /* CreateWindow (for a popup window with WS_VISIBLE style set)
1163 */
1164 static const struct message WmShowPopupFirstDrawSeq_1[] = {
1165 { HCBT_CREATEWND, hook },
1166 { WM_NCCREATE, sent },
1167 { WM_NCCALCSIZE, sent|wparam, 0 },
1168 { WM_CREATE, sent },
1169 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1170 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1171 { WM_MOVE, sent },
1172 { WM_SHOWWINDOW, sent|wparam, 1 },
1173 { WM_WINDOWPOSCHANGING, sent },
1174 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1175 { HCBT_ACTIVATE, hook },
1176 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1177 { WM_WINDOWPOSCHANGING, sent|optional },
1178 { WM_QUERYNEWPALETTE, sent|optional },
1179 { WM_ACTIVATEAPP, sent },
1180 { WM_NCACTIVATE, sent },
1181 { WM_ACTIVATE, sent },
1182 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1183 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1184 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1185 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1186 { HCBT_SETFOCUS, hook },
1187 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1188 { WM_SETFOCUS, sent|defwinproc },
1189 { WM_NCPAINT, sent|wparam, 1 },
1190 { WM_ERASEBKGND, sent },
1191 { WM_WINDOWPOSCHANGED, sent },
1192 { WM_PAINT, sent },
1193 /* occasionally received on test machines */
1194 { WM_NCPAINT, sent|beginpaint|optional },
1195 { WM_ERASEBKGND, sent|beginpaint|optional },
1196 { 0 }
1197 };
1198 /* CreateWindow (for a popup window that is shown with ShowWindow(SW_SHOWMAXIMIZED))
1199 */
1200 static const struct message WmShowPopupFirstDrawSeq_2[] = {
1201 { HCBT_CREATEWND, hook },
1202 { WM_NCCREATE, sent },
1203 { WM_NCCALCSIZE, sent|wparam, 0 },
1204 { WM_CREATE, sent },
1205 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1206 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1207 { WM_MOVE, sent },
1208 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1209 { WM_GETMINMAXINFO, sent },
1210 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_STATECHANGED|SWP_SHOWWINDOW|SWP_FRAMECHANGED },
1211 { WM_NCCALCSIZE, sent|wparam, TRUE },
1212 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1213 { HCBT_ACTIVATE, hook },
1214 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1215 { WM_WINDOWPOSCHANGING, sent|optional },
1216 { WM_NCPAINT, sent|optional|wparam, 1 },
1217 { WM_ERASEBKGND, sent|optional },
1218 { WM_WINDOWPOSCHANGED, sent|optional },
1219 { WM_QUERYNEWPALETTE, sent|optional },
1220 { WM_ACTIVATEAPP, sent },
1221 { WM_NCACTIVATE, sent },
1222 { WM_ACTIVATE, sent },
1223 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1224 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1225 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1226 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1227 { HCBT_SETFOCUS, hook },
1228 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1229 { WM_SETFOCUS, sent|defwinproc },
1230 { WM_NCPAINT, sent|wparam, 1 },
1231 { WM_ERASEBKGND, sent },
1232 { WM_WINDOWPOSCHANGED, sent|optional },
1233 { WM_MOVE, sent|defwinproc },
1234 { WM_SIZE, sent|defwinproc, 0 },
1235 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1236 { WM_PAINT, sent},
1237 /* occasionally received on test machines */
1238 { WM_NCPAINT, sent|beginpaint|optional },
1239 { WM_ERASEBKGND, sent|beginpaint|optional },
1240 { 0 }
1241 };
1242 static const struct message WmFirstDrawSetWindowPosSeq1[] = {
1243 { HCBT_CREATEWND, hook },
1244 { WM_NCCREATE, sent },
1245 { WM_NCCALCSIZE, sent|wparam, 0 },
1246 { WM_CREATE, sent },
1247 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1248 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1249 { WM_MOVE, sent },
1250 { WM_WINDOWPOSCHANGING, sent },
1251 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1252 { HCBT_ACTIVATE, hook },
1253 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1254 { WM_WINDOWPOSCHANGING, sent|optional },
1255 { WM_QUERYNEWPALETTE, sent|optional },
1256 { WM_ACTIVATEAPP, sent },
1257 { WM_NCACTIVATE, sent },
1258 { WM_ACTIVATE, sent },
1259 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1260 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1261 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1262 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1263 { HCBT_SETFOCUS, hook },
1264 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1265 { WM_SETFOCUS, sent|defwinproc },
1266 { WM_NCPAINT, sent|wparam, 1 },
1267 { WM_ERASEBKGND, sent },
1268 { WM_WINDOWPOSCHANGED, sent },
1269 { WM_MOVE, sent|defwinproc },
1270 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1271 { 0 }
1272 };
1273 static const struct message WmFirstDrawSetWindowPosSeq2[] = {
1274 { HCBT_CREATEWND, hook },
1275 { WM_NCCREATE, sent },
1276 { WM_NCCALCSIZE, sent|wparam, 0 },
1277 { WM_CREATE, sent },
1278 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1279 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1280 { WM_MOVE, sent },
1281 { WM_WINDOWPOSCHANGING, sent },
1282 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not always sent. */
1283 { HCBT_ACTIVATE, hook },
1284 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1285 { WM_QUERYNEWPALETTE, sent|optional },
1286 { WM_WINDOWPOSCHANGING, sent|optional },
1287 { WM_ACTIVATEAPP, sent },
1288 { WM_NCACTIVATE, sent },
1289 { WM_ACTIVATE, sent },
1290 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1291 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1292 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1293 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1294 { HCBT_SETFOCUS, hook },
1295 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1296 { WM_SETFOCUS, sent|defwinproc },
1297 { WM_WINDOWPOSCHANGED, sent },
1298 { WM_MOVE, sent|defwinproc },
1299 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1300 { 0 }
1301 };
1302 static const struct message WmFirstDrawSetWindowPosSeq3[] = {
1303 { HCBT_CREATEWND, hook },
1304 { WM_NCCREATE, sent },
1305 { WM_NCCALCSIZE, sent|wparam, 0 },
1306 { WM_CREATE, sent },
1307 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1308 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1309 { WM_MOVE, sent },
1310 { HCBT_ACTIVATE, hook|optional },
1311 /* Probably shouldn't happen, but not part of this test */
1312 { WM_QUERYNEWPALETTE, sent|optional },
1313 { WM_ACTIVATEAPP, sent|optional },
1314 { WM_NCACTIVATE, sent|optional },
1315 { WM_ACTIVATE, sent|optional },
1316 { HCBT_SETFOCUS, hook|optional },
1317 { WM_SETFOCUS, sent|defwinproc|optional },
1318 { 0 }
1319 };
1320 static const struct message WmFirstDrawSetWindowPosSeq4[] = {
1321 { HCBT_CREATEWND, hook },
1322 { WM_NCCREATE, sent },
1323 { WM_NCCALCSIZE, sent|wparam, 0 },
1324 { WM_CREATE, sent },
1325 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1326 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1327 { WM_MOVE, sent },
1328 { WM_WINDOWPOSCHANGING, sent },
1329 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1330 { HCBT_ACTIVATE, hook },
1331 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1332 { WM_WINDOWPOSCHANGING, sent|optional },
1333 { WM_QUERYNEWPALETTE, sent|optional },
1334 { WM_ACTIVATEAPP, sent },
1335 { WM_NCACTIVATE, sent },
1336 { WM_ACTIVATE, sent },
1337 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1338 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1339 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1340 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1341 { HCBT_SETFOCUS, hook },
1342 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1343 { WM_SETFOCUS, sent|defwinproc },
1344 { WM_NCPAINT, sent|wparam, 1 },
1345 { WM_ERASEBKGND, sent },
1346 { WM_WINDOWPOSCHANGED, sent },
1347 { 0 }
1348 };
1349 static const struct message WmFirstDrawSetWindowPosSeq5[] = {
1350 { HCBT_CREATEWND, hook },
1351 { WM_NCCREATE, sent },
1352 { WM_NCCALCSIZE, sent|wparam, 0 },
1353 { WM_CREATE, sent },
1354 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1355 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1356 { WM_MOVE, sent },
1357 { WM_WINDOWPOSCHANGING, sent },
1358 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1359 { HCBT_ACTIVATE, hook },
1360 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1361 { WM_WINDOWPOSCHANGING, sent|optional },
1362 { WM_QUERYNEWPALETTE, sent|optional },
1363 { WM_ACTIVATEAPP, sent },
1364 { WM_NCACTIVATE, sent },
1365 { WM_ACTIVATE, sent },
1366 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1367 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1368 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1369 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Not sent on Win10. */
1370 { HCBT_SETFOCUS, hook },
1371 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
1372 { WM_SETFOCUS, sent|defwinproc },
1373 { WM_WINDOWPOSCHANGED, sent },
1374 { 0 }
1375 };
1376 static const struct message WmFirstDrawChildSeq1[] = {
1377 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1378 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
1379 { 0 }
1380 };
1381 static const struct message WmFirstDrawChildSeq2[] = {
1382 { WM_NCPAINT, sent|wparam, 1 },
1383 { WM_ERASEBKGND, sent },
1384 /* occasionally received on test machines */
1385 { WM_NCPAINT, sent|optional },
1386 { WM_ERASEBKGND, sent|optional },
1387 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1388 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
1389 { 0 }
1390 };
1391 /* CreateWindow (for child window, not initially visible) */
1392 static const struct message WmCreateChildSeq[] = {
1393 { HCBT_CREATEWND, hook },
1394 { WM_NCCREATE, sent },
1395 /* child is inserted into parent's child list after WM_NCCREATE returns */
1396 { WM_NCCALCSIZE, sent|wparam, 0 },
1397 { WM_CREATE, sent },
1398 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1399 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1400 { WM_MOVE, sent },
1401 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
1402 { 0 }
1403 };
1404 /* CreateWindow (for maximized child window, not initially visible) */
1405 static const struct message WmCreateMaximizedChildSeq[] = {
1406 { HCBT_CREATEWND, hook },
1407 { WM_NCCREATE, sent },
1408 { WM_NCCALCSIZE, sent|wparam, 0 },
1409 { WM_CREATE, sent },
1410 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1411 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1412 { WM_MOVE, sent },
1413 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1414 { WM_GETMINMAXINFO, sent },
1415 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
1416 { WM_NCCALCSIZE, sent|wparam, 1 },
1417 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
1418 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
1419 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1420 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
1421 { 0 }
1422 };
1423 /* CreateWindow (for a child window, initially visible) */
1424 static const struct message WmCreateVisibleChildSeq[] = {
1425 { HCBT_CREATEWND, hook },
1426 { WM_NCCREATE, sent },
1427 /* child is inserted into parent's child list after WM_NCCREATE returns */
1428 { WM_NCCALCSIZE, sent|wparam, 0 },
1429 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
1430 { WM_CREATE, sent },
1431 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1432 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1433 { WM_MOVE, sent },
1434 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
1435 { WM_SHOWWINDOW, sent|wparam, 1 },
1436 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1437 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1438 { WM_ERASEBKGND, sent|parent|optional },
1439 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1440 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
1441 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1442 { 0 }
1443 };
1444 /* ShowWindow(SW_SHOW) for a not visible child window */
1445 static const struct message WmShowChildSeq[] = {
1446 { WM_SHOWWINDOW, sent|wparam, 1 },
1447 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1448 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1449 { WM_ERASEBKGND, sent|parent|optional },
1450 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1451 { 0 }
1452 };
1453 /* ShowWindow(SW_HIDE) for a visible child window */
1454 static const struct message WmHideChildSeq[] = {
1455 { WM_SHOWWINDOW, sent|wparam, 0 },
1456 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1457 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1458 { WM_ERASEBKGND, sent|parent|optional },
1459 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1460 { 0 }
1461 };
1462 /* ShowWindow(SW_HIDE) for a visible child window checking all parent events*/
1463 static const struct message WmHideChildSeq2[] = {
1464 { WM_SHOWWINDOW, sent|wparam, 0 },
1465 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1466 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1467 { WM_ERASEBKGND, sent|parent|optional },
1468 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1469 { 0 }
1470 };
1471 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
1472 * for a not visible child window
1473 */
1474 static const struct message WmShowChildSeq_2[] = {
1475 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1476 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1477 { WM_CHILDACTIVATE, sent },
1478 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1479 { 0 }
1480 };
1481 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
1482 * for a not visible child window
1483 */
1484 static const struct message WmShowChildSeq_3[] = {
1485 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1486 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1487 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1488 { 0 }
1489 };
1490 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
1491 * for a visible child window with a caption
1492 */
1493 static const struct message WmShowChildSeq_4[] = {
1494 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1495 { WM_CHILDACTIVATE, sent },
1496 { 0 }
1497 };
1498 /* ShowWindow(SW_MINIMIZE) for child with invisible parent */
1499 static const struct message WmShowChildInvisibleParentSeq_1[] = {
1500 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
1501 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
1502 { WM_NCCALCSIZE, sent|wparam, 1 },
1503 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1504 { WM_CHILDACTIVATE, sent|optional },
1505 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
1506 { WM_MOVE, sent|defwinproc },
1507 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
1508 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1509 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1510 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1511 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1512 { WM_GETTEXT, sent|optional },
1513 { 0 }
1514 };
1515 /* repeated ShowWindow(SW_MINIMIZE) for child with invisible parent */
1516 static const struct message WmShowChildInvisibleParentSeq_1r[] = {
1517 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
1518 { 0 }
1519 };
1520 /* ShowWindow(SW_MAXIMIZE) for child with invisible parent */
1521 static const struct message WmShowChildInvisibleParentSeq_2[] = {
1522 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1523 { WM_GETMINMAXINFO, sent },
1524 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
1525 { WM_NCCALCSIZE, sent|wparam, 1 },
1526 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1527 { WM_CHILDACTIVATE, sent },
1528 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
1529 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
1530 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1531 { 0 }
1532 };
1533 /* repeated ShowWindow(SW_MAXIMIZE) for child with invisible parent */
1534 static const struct message WmShowChildInvisibleParentSeq_2r[] = {
1535 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1536 { 0 }
1537 };
1538 /* ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
1539 static const struct message WmShowChildInvisibleParentSeq_3[] = {
1540 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
1541 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
1542 { WM_NCCALCSIZE, sent|wparam, 1 },
1543 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1544 { WM_CHILDACTIVATE, sent },
1545 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
1546 { WM_MOVE, sent|defwinproc },
1547 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
1548 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1549 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1550 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1551 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1552 { WM_GETTEXT, sent|optional },
1553 { 0 }
1554 };
1555 /* repeated ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
1556 static const struct message WmShowChildInvisibleParentSeq_3r[] = {
1557 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
1558 { 0 }
1559 };
1560 /* ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
1561 static const struct message WmShowChildInvisibleParentSeq_4[] = {
1562 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
1563 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
1564 { WM_NCCALCSIZE, sent|wparam, 1 },
1565 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1566 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
1567 { WM_MOVE, sent|defwinproc },
1568 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
1569 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1570 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1571 /* FIXME: Wine creates an icon/title window while Windows doesn't */
1572 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
1573 { WM_GETTEXT, sent|optional },
1574 { 0 }
1575 };
1576 /* repeated ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
1577 static const struct message WmShowChildInvisibleParentSeq_4r[] = {
1578 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
1579 { 0 }
1580 };
1581 /* ShowWindow(SW_SHOW) for child with invisible parent */
1582 static const struct message WmShowChildInvisibleParentSeq_5[] = {
1583 { WM_SHOWWINDOW, sent|wparam, 1 },
1584 { 0 }
1585 };
1586 /* ShowWindow(SW_HIDE) for child with invisible parent */
1587 static const struct message WmHideChildInvisibleParentSeq[] = {
1588 { WM_SHOWWINDOW, sent|wparam, 0 },
1589 { 0 }
1590 };
1591 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
1592 static const struct message WmShowChildInvisibleParentSeq_6[] = {
1593 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1594 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1595 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1596 { 0 }
1597 };
1598 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
1599 static const struct message WmHideChildInvisibleParentSeq_2[] = {
1600 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1601 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1602 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1603 { 0 }
1604 };
1605 /* DestroyWindow for a visible child window */
1606 static const struct message WmDestroyChildSeq[] = {
1607 { HCBT_DESTROYWND, hook },
1608 { 0x0090, sent|optional },
1609 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1610 { WM_SHOWWINDOW, sent|wparam, 0 },
1611 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1612 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1613 { WM_ERASEBKGND, sent|parent|optional },
1614 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1615 { HCBT_SETFOCUS, hook }, /* set focus to a parent */
1616 { WM_KILLFOCUS, sent },
1617 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1618 { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
1619 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1620 { WM_SETFOCUS, sent|parent },
1621 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1622 { WM_DESTROY, sent },
1623 { WM_DESTROY, sent|optional }, /* some other (IME?) window */
1624 { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
1625 { WM_NCDESTROY, sent },
1626 { 0 }
1627 };
1628 /* visible child window destroyed by thread exit */
1629 static const struct message WmExitThreadSeq[] = {
1630 { WM_NCDESTROY, sent }, /* actually in grandchild */
1631 { WM_PAINT, sent|parent },
1632 { WM_ERASEBKGND, sent|parent|beginpaint },
1633 { 0 }
1634 };
1635 /* DestroyWindow for a visible child window with invisible parent */
1636 static const struct message WmDestroyInvisibleChildSeq[] = {
1637 { HCBT_DESTROYWND, hook },
1638 { 0x0090, sent|optional },
1639 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1640 { WM_SHOWWINDOW, sent|wparam, 0 },
1641 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1642 { WM_DESTROY, sent },
1643 { WM_NCDESTROY, sent },
1644 { 0 }
1645 };
1646 /* Resizing child window with MoveWindow (32) */
1647 static const struct message WmResizingChildWithMoveWindowSeq[] = {
1648 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
1649 { WM_NCCALCSIZE, sent|wparam, 1 },
1650 { WM_ERASEBKGND, sent|parent|optional },
1651 { WM_ERASEBKGND, sent|optional },
1652 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE },
1653 { WM_MOVE, sent|defwinproc },
1654 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1655 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1656 { 0 }
1657 };
1658 /* Creation of a custom dialog (32) */
1659 static const struct message WmCreateCustomDialogSeq[] = {
1660 { HCBT_CREATEWND, hook },
1661 { WM_GETMINMAXINFO, sent },
1662 { WM_NCCREATE, sent },
1663 { WM_NCCALCSIZE, sent|wparam, 0 },
1664 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
1665 { WM_CREATE, sent },
1666 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1667 { WM_NOTIFYFORMAT, sent|optional },
1668 { WM_QUERYUISTATE, sent|optional },
1669 { WM_WINDOWPOSCHANGING, sent|optional },
1670 { WM_GETMINMAXINFO, sent|optional },
1671 { WM_NCCALCSIZE, sent|optional },
1672 { WM_WINDOWPOSCHANGED, sent|optional },
1673 { WM_SHOWWINDOW, sent|wparam, 1 },
1674 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1675 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1676 { HCBT_ACTIVATE, hook },
1677 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1678
1679
1680 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1681
1682 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1683
1684 { WM_NCACTIVATE, sent },
1685 { WM_GETTEXT, sent|optional|defwinproc },
1686 { WM_GETTEXT, sent|optional|defwinproc },
1687 { WM_GETTEXT, sent|optional|defwinproc },
1688 { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
1689 { WM_ACTIVATE, sent|wparam, 1 },
1690 { WM_GETTEXT, sent|optional },
1691 { WM_KILLFOCUS, sent|parent },
1692 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1693 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1694 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1695 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1696 { WM_SETFOCUS, sent },
1697 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1698 { WM_NCPAINT, sent|wparam, 1 },
1699 { WM_GETTEXT, sent|optional|defwinproc },
1700 { WM_GETTEXT, sent|optional|defwinproc },
1701 { WM_ERASEBKGND, sent },
1702 { WM_CTLCOLORDLG, sent|optional|defwinproc },
1703 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1704 { WM_GETTEXT, sent|optional },
1705 { WM_GETTEXT, sent|optional },
1706 { WM_NCCALCSIZE, sent|optional },
1707 { WM_NCPAINT, sent|optional },
1708 { WM_GETTEXT, sent|optional|defwinproc },
1709 { WM_GETTEXT, sent|optional|defwinproc },
1710 { WM_ERASEBKGND, sent|optional },
1711 { WM_CTLCOLORDLG, sent|optional|defwinproc },
1712 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
1713 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1714 { WM_MOVE, sent },
1715 { 0 }
1716 };
1717 /* Calling EndDialog for a custom dialog (32) */
1718 static const struct message WmEndCustomDialogSeq[] = {
1719 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1720 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1721 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1722 { WM_GETTEXT, sent|optional },
1723 { HCBT_ACTIVATE, hook },
1724 { WM_NCACTIVATE, sent|wparam, 0 },
1725 { WM_GETTEXT, sent|optional|defwinproc },
1726 { WM_GETTEXT, sent|optional|defwinproc },
1727 { WM_ACTIVATE, sent|wparam, 0 },
1728 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1729 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1730 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1731 { WM_GETTEXT, sent|optional|defwinproc },
1732 { WM_GETTEXT, sent|optional|defwinproc },
1733 { HCBT_SETFOCUS, hook },
1734 { WM_KILLFOCUS, sent },
1735 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1736 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1737 { WM_IME_NOTIFY, sent|wparam|optional, 1 },
1738 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1739 { WM_SETFOCUS, sent|parent|defwinproc },
1740 { 0 }
1741 };
1742 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
1743 static const struct message WmShowCustomDialogSeq[] = {
1744 { WM_SHOWWINDOW, sent|wparam, 1 },
1745 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1746 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1747 { HCBT_ACTIVATE, hook },
1748 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1749
1750 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1751
1752 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
1753 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
1754 { WM_NCACTIVATE, sent },
1755 { WM_ACTIVATE, sent|wparam, 1 },
1756 { WM_GETTEXT, sent|optional },
1757
1758 { WM_KILLFOCUS, sent|parent },
1759 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1760 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1761 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1762 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1763 { WM_SETFOCUS, sent },
1764 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1765 { WM_NCPAINT, sent|wparam, 1 },
1766 { WM_ERASEBKGND, sent },
1767 { WM_CTLCOLORDLG, sent|defwinproc },
1768 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1769 { 0 }
1770 };
1771 /* Creation and destruction of a modal dialog (32) */
1772 static const struct message WmModalDialogSeq[] = {
1773 { WM_CANCELMODE, sent|parent },
1774 { HCBT_SETFOCUS, hook },
1775 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1776 { WM_KILLFOCUS, sent|parent },
1777 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1778 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1779 { WM_ENABLE, sent|parent|wparam, 0 },
1780 { HCBT_CREATEWND, hook },
1781 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
1782 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1783 { WM_SETFONT, sent },
1784 { WM_INITDIALOG, sent },
1785 { WM_CHANGEUISTATE, sent|optional },
1786 { WM_UPDATEUISTATE, sent|optional },
1787 { WM_SHOWWINDOW, sent },
1788 { HCBT_ACTIVATE, hook },
1789 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1790 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1791 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1792 { WM_NCACTIVATE, sent },
1793 { WM_GETTEXT, sent|optional },
1794 { WM_ACTIVATE, sent|wparam, 1 },
1795 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1796 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1797 { WM_NCPAINT, sent|optional },
1798 { WM_GETTEXT, sent|optional },
1799 { WM_ERASEBKGND, sent|optional },
1800 { WM_CTLCOLORDLG, sent|optional },
1801 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1802 { WM_GETTEXT, sent|optional },
1803 { WM_NCCALCSIZE, sent|optional },
1804 { WM_NCPAINT, sent|optional },
1805 { WM_GETTEXT, sent|optional },
1806 { WM_ERASEBKGND, sent|optional },
1807 { WM_CTLCOLORDLG, sent|optional },
1808 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
1809 { WM_PAINT, sent|optional },
1810 { WM_CTLCOLORBTN, sent|optional },
1811 { WM_GETTITLEBARINFOEX, sent|optional },
1812 { WM_ENTERIDLE, sent|parent|optional },
1813 { WM_ENTERIDLE, sent|parent|optional },
1814 { WM_ENTERIDLE, sent|parent|optional },
1815 { WM_ENTERIDLE, sent|parent|optional },
1816 { WM_ENTERIDLE, sent|parent|optional },
1817 { WM_ENTERIDLE, sent|parent|optional },
1818 { WM_ENTERIDLE, sent|parent|optional },
1819 { WM_ENTERIDLE, sent|parent|optional },
1820 { WM_ENTERIDLE, sent|parent|optional },
1821 { WM_ENTERIDLE, sent|parent|optional },
1822 { WM_ENTERIDLE, sent|parent|optional },
1823 { WM_ENTERIDLE, sent|parent|optional },
1824 { WM_ENTERIDLE, sent|parent|optional },
1825 { WM_ENTERIDLE, sent|parent|optional },
1826 { WM_ENTERIDLE, sent|parent|optional },
1827 { WM_ENTERIDLE, sent|parent|optional },
1828 { WM_ENTERIDLE, sent|parent|optional },
1829 { WM_ENTERIDLE, sent|parent|optional },
1830 { WM_ENTERIDLE, sent|parent|optional },
1831 { WM_ENTERIDLE, sent|parent|optional },
1832 { WM_TIMER, sent },
1833 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1834 { WM_ENABLE, sent|parent|wparam, 1 },
1835 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1836 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1837 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1838 { WM_GETTEXT, sent|optional },
1839 { HCBT_ACTIVATE, hook },
1840 { WM_NCACTIVATE, sent|wparam, 0 },
1841 { WM_GETTEXT, sent|optional },
1842 { WM_ACTIVATE, sent|wparam, 0 },
1843 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1844 { WM_WINDOWPOSCHANGING, sent|optional },
1845 { WM_WINDOWPOSCHANGED, sent|optional },
1846 { HCBT_SETFOCUS, hook },
1847 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1848 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1849 { WM_SETFOCUS, sent|parent|defwinproc },
1850 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1851 { HCBT_DESTROYWND, hook },
1852 { 0x0090, sent|optional },
1853 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1854 { WM_DESTROY, sent },
1855 { WM_NCDESTROY, sent },
1856 { 0 }
1857 };
1858 static const struct message WmModalDialogSeq_2[] = {
1859 { WM_CANCELMODE, sent },
1860 { HCBT_SETFOCUS, hook },
1861 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1862 { WM_KILLFOCUS, sent },
1863 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1864 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1865 { WM_ENABLE, sent|wparam, 0 },
1866 { HCBT_CREATEWND, hook },
1867 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1868 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1869 { WM_SETFONT, sent },
1870 { WM_INITDIALOG, sent },
1871 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1872 { WM_CHANGEUISTATE, sent|optional },
1873 { WM_UPDATEUISTATE, sent|optional },
1874 { WM_ENABLE, sent|wparam, 1 },
1875 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1876 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 },
1877 { WM_CHANGEUISTATE, sent|optional },
1878 { WM_UPDATEUISTATE, sent|optional },
1879 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1880 { HCBT_DESTROYWND, hook },
1881 { 0x0090, sent|optional },
1882 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1883 { WM_DESTROY, sent },
1884 { WM_NCDESTROY, sent },
1885 { 0 }
1886 };
1887 /* SetMenu for NonVisible windows with size change*/
1888 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
1889 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1890 { WM_NCCALCSIZE, sent|wparam, 1 },
1891 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1892 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
1893 { WM_MOVE, sent|defwinproc },
1894 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1895 { WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
1896 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1897 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1898 { WM_GETTEXT, sent|optional },
1899 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1900 { 0 }
1901 };
1902 /* SetMenu for NonVisible windows with no size change */
1903 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
1904 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1905 { WM_NCCALCSIZE, sent|wparam, 1 },
1906 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1907 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1908 { 0 }
1909 };
1910 /* SetMenu for Visible windows with size change */
1911 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
1912 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1913 { WM_NCCALCSIZE, sent|wparam, 1 },
1914 { 0x0093, sent|defwinproc|optional },
1915 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1916 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1917 { 0x0093, sent|defwinproc|optional },
1918 { 0x0093, sent|defwinproc|optional },
1919 { 0x0091, sent|defwinproc|optional },
1920 { 0x0092, sent|defwinproc|optional },
1921 { WM_GETTEXT, sent|defwinproc|optional },
1922 { WM_ERASEBKGND, sent|optional },
1923 { WM_ACTIVATE, sent|optional },
1924 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1925 { WM_MOVE, sent|defwinproc },
1926 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1927 { 0x0093, sent|optional },
1928 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1929 { 0x0093, sent|defwinproc|optional },
1930 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1931 { 0x0093, sent|defwinproc|optional },
1932 { 0x0093, sent|defwinproc|optional },
1933 { 0x0091, sent|defwinproc|optional },
1934 { 0x0092, sent|defwinproc|optional },
1935 { WM_ERASEBKGND, sent|optional },
1936 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1937 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1938 { 0 }
1939 };
1940 /* SetMenu for Visible windows with no size change */
1941 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
1942 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1943 { WM_NCCALCSIZE, sent|wparam, 1 },
1944 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1945 { WM_GETTEXT, sent|defwinproc|optional },
1946 { WM_ERASEBKGND, sent|optional },
1947 { WM_ACTIVATE, sent|optional },
1948 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1949 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1950 { 0 }
1951 };
1952 /* DrawMenuBar for a visible window */
1953 static const struct message WmDrawMenuBarSeq[] =
1954 {
1955 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1956 { WM_NCCALCSIZE, sent|wparam, 1 },
1957 { 0x0093, sent|defwinproc|optional },
1958 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1959 { 0x0093, sent|defwinproc|optional },
1960 { 0x0093, sent|defwinproc|optional },
1961 { 0x0091, sent|defwinproc|optional },
1962 { 0x0092, sent|defwinproc|optional },
1963 { WM_GETTEXT, sent|defwinproc|optional },
1964 { WM_ERASEBKGND, sent|optional },
1965 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1966 { 0x0093, sent|optional },
1967 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1968 { 0 }
1969 };
1970
1971 static const struct message WmSetRedrawFalseSeq[] =
1972 {
1973 { WM_SETREDRAW, sent|wparam, 0 },
1974 { 0 }
1975 };
1976
1977 static const struct message WmSetRedrawTrueSeq[] =
1978 {
1979 { WM_SETREDRAW, sent|wparam, 1 },
1980 { 0 }
1981 };
1982
1983 static const struct message WmEnableWindowSeq_1[] =
1984 {
1985 { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1986 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
1987 { HCBT_SETFOCUS, hook|optional },
1988 { WM_KILLFOCUS, sent|optional },
1989 { WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
1990 { 0 }
1991 };
1992
1993 static const struct message WmEnableWindowSeq_2[] =
1994 {
1995 { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1996 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
1997 { 0 }
1998 };
1999
2000 static const struct message WmEnableWindowSeq_3[] =
2001 {
2002 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2003 { WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
2004 { 0 }
2005 };
2006
2007 static const struct message WmEnableWindowSeq_4[] =
2008 {
2009 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win10. */
2010 { 0 }
2011 };
2012
2013 static const struct message WmGetScrollRangeSeq[] =
2014 {
2015 { SBM_GETRANGE, sent },
2016 { 0 }
2017 };
2018 static const struct message WmGetScrollInfoSeq[] =
2019 {
2020 { SBM_GETSCROLLINFO, sent },
2021 { 0 }
2022 };
2023 static const struct message WmSetScrollRangeSeq[] =
2024 {
2025 /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
2026 sends SBM_SETSCROLLINFO.
2027 */
2028 { SBM_SETSCROLLINFO, sent },
2029 { 0 }
2030 };
2031 /* SetScrollRange for a window without a non-client area */
2032 static const struct message WmSetScrollRangeHSeq_empty[] =
2033 {
2034 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_HSCROLL, 0 },
2035 { 0 }
2036 };
2037 static const struct message WmSetScrollRangeVSeq_empty[] =
2038 {
2039 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_VSCROLL, 0 },
2040 { 0 }
2041 };
2042 static const struct message WmSetScrollRangeHVSeq[] =
2043 {
2044 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
2045 { WM_NCCALCSIZE, sent|wparam, 1 },
2046 { WM_GETTEXT, sent|defwinproc|optional },
2047 { WM_ERASEBKGND, sent|optional },
2048 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2049 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2050 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
2051 { 0 }
2052 };
2053 /* SetScrollRange for a window with a non-client area */
2054 static const struct message WmSetScrollRangeHV_NC_Seq[] =
2055 {
2056 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
2057 { WM_NCCALCSIZE, sent|wparam, 1 },
2058 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2059 { WM_NCPAINT, sent|optional },
2060 { WM_STYLECHANGING, sent|defwinproc|optional },
2061 { WM_STYLECHANGED, sent|defwinproc|optional },
2062 { WM_STYLECHANGING, sent|defwinproc|optional },
2063 { WM_STYLECHANGED, sent|defwinproc|optional },
2064 { WM_STYLECHANGING, sent|defwinproc|optional },
2065 { WM_STYLECHANGED, sent|defwinproc|optional },
2066 { WM_STYLECHANGING, sent|defwinproc|optional },
2067 { WM_STYLECHANGED, sent|defwinproc|optional },
2068 { WM_GETTEXT, sent|defwinproc|optional },
2069 { WM_GETTEXT, sent|defwinproc|optional },
2070 { WM_ERASEBKGND, sent|optional },
2071 { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
2072 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOCLIENTSIZE },
2073 { WM_SIZE, sent|defwinproc|optional },
2074 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2075 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
2076 { WM_GETTEXT, sent|optional },
2077 { WM_GETTEXT, sent|optional },
2078 { WM_GETTEXT, sent|optional },
2079 { WM_GETTEXT, sent|optional },
2080 { 0 }
2081 };
2082 /* test if we receive the right sequence of messages */
2083 /* after calling ShowWindow( SW_SHOWNA) */
2084 static const struct message WmSHOWNAChildInvisParInvis[] = {
2085 { WM_SHOWWINDOW, sent|wparam, 1 },
2086 { 0 }
2087 };
2088 static const struct message WmSHOWNAChildVisParInvis[] = {
2089 { WM_SHOWWINDOW, sent|wparam, 1 },
2090 { 0 }
2091 };
2092 static const struct message WmSHOWNAChildVisParVis[] = {
2093 { WM_SHOWWINDOW, sent|wparam, 1 },
2094 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
2095 { 0 }
2096 };
2097 static const struct message WmSHOWNAChildInvisParVis[] = {
2098 { WM_SHOWWINDOW, sent|wparam, 1 },
2099 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2100 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2101 { WM_ERASEBKGND, sent|optional },
2102 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOCLIENTMOVE },
2103 { 0 }
2104 };
2105 static const struct message WmSHOWNATopVisible[] = {
2106 { WM_SHOWWINDOW, sent|wparam, 1 },
2107 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
2108 { WM_NCPAINT, sent|wparam|optional, 1 },
2109 { WM_GETTEXT, sent|defwinproc|optional },
2110 { WM_ERASEBKGND, sent|optional },
2111 { WM_WINDOWPOSCHANGED, sent|optional },
2112 { 0 }
2113 };
2114 static const struct message WmSHOWNATopInvisible[] = {
2115 { WM_NOTIFYFORMAT, sent|optional },
2116 { WM_QUERYUISTATE, sent|optional },
2117 { WM_WINDOWPOSCHANGING, sent|optional },
2118 { WM_GETMINMAXINFO, sent|optional },
2119 { WM_NCCALCSIZE, sent|optional },
2120 { WM_WINDOWPOSCHANGED, sent|optional },
2121 { WM_SHOWWINDOW, sent|wparam, 1 },
2122 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2123 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2124 { WM_NCPAINT, sent|wparam|optional, 1 },
2125 { WM_GETTEXT, sent|defwinproc|optional },
2126 { WM_ERASEBKGND, sent|optional },
2127 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2128 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2129 { WM_NCPAINT, sent|wparam|optional, 1 },
2130 { WM_ERASEBKGND, sent|optional },
2131 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends it, but Win8+ doesn't. */
2132 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2133 { WM_MOVE, sent },
2134 { 0 }
2135 };
2136
2137 static const struct message WmTrackPopupMenuMinimizeWindow[] = {
2138 { HCBT_CREATEWND, hook },
2139 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2140 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
2141 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2142 { WM_INITMENU, sent|lparam, 0, 0 },
2143 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2144 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
2145 { 0x0093, sent|optional },
2146 { 0x0094, sent|optional },
2147 { 0x0094, sent|optional },
2148 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2149 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2150 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
2151 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2152 { WM_ENTERIDLE, sent|wparam, 2 },
2153 { HCBT_MINMAX, hook },
2154 { HCBT_SETFOCUS, hook },
2155 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2156 { WM_KILLFOCUS, sent|wparam, 0 },
2157 { WM_GETTEXT, sent|optional },
2158 { WM_WINDOWPOSCHANGING, sent },
2159 { WM_GETMINMAXINFO, sent|defwinproc },
2160 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2161 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2162 { WM_WINDOWPOSCHANGED, sent },
2163 { WM_MOVE, sent|defwinproc },
2164 { WM_SIZE, sent|defwinproc },
2165 { WM_GETTEXT, sent|optional },
2166 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2167 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2168 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
2169 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2170 { WM_CANCELMODE, sent },
2171 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2172 { WM_CAPTURECHANGED, sent|defwinproc },
2173 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2174 { HCBT_DESTROYWND, hook },
2175 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2176 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2177 { WM_UNINITMENUPOPUP, sent|defwinproc|lparam, 0, 0 },
2178 { WM_MENUSELECT, sent|defwinproc|wparam|lparam, 0xffff0000, 0 },
2179 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2180 { WM_EXITMENULOOP, sent|defwinproc|wparam|lparam, 1, 0 },
2181 { WM_NCACTIVATE, sent },
2182 { WM_GETTEXT, sent|defwinproc|optional },
2183 { WM_GETTEXT, sent|defwinproc|optional },
2184 { WM_ACTIVATE, sent },
2185 { WM_ACTIVATEAPP, sent|wparam, 0 },
2186 { 0 }
2187 };
2188
2189 static const struct message WmTrackPopupMenu[] = {
2190 { HCBT_CREATEWND, hook },
2191 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2192 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
2193 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2194 { WM_INITMENU, sent|lparam, 0, 0 },
2195 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2196 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
2197 { 0x0093, sent|optional },
2198 { 0x0094, sent|optional },
2199 { 0x0094, sent|optional },
2200 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2201 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2202 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
2203 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2204 { WM_ENTERIDLE, sent|wparam, 2 },
2205 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2206 { WM_CAPTURECHANGED, sent },
2207 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2208 { HCBT_DESTROYWND, hook },
2209 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2210 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2211 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
2212 { WM_MENUSELECT, sent|wparam|lparam, 0xffff0000, 0 },
2213 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2214 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
2215 { 0 }
2216 };
2217
2218 static const struct message WmTrackPopupMenuEsc[] = {
2219 { 0 }
2220 };
2221
2222 static const struct message WmTrackPopupMenuCapture[] = {
2223 { HCBT_CREATEWND, hook },
2224 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2225 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
2226 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2227 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2228 { WM_CAPTURECHANGED, sent },
2229 { WM_INITMENU, sent|lparam, 0, 0 },
2230 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2231 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
2232 { 0x0093, sent|optional },
2233 { 0x0094, sent|optional },
2234 { 0x0094, sent|optional },
2235 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2236 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2237 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
2238 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2239 { WM_ENTERIDLE, sent|wparam, 2 },
2240 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2241 { WM_CAPTURECHANGED, sent },
2242 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2243 { HCBT_DESTROYWND, hook },
2244 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2245 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2246 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
2247 { WM_MENUSELECT, sent|wparam|lparam, 0xffff0000, 0 },
2248 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2249 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
2250 { 0 }
2251 };
2252
2253 static const struct message WmTrackPopupMenuEmpty[] = {
2254 { HCBT_CREATEWND, hook },
2255 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2256 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
2257 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2258 { WM_INITMENU, sent|lparam, 0, 0 },
2259 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2260 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
2261 { 0x0093, sent|optional },
2262 { 0x0094, sent|optional },
2263 { 0x0094, sent|optional },
2264 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2265 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2266 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2267 { WM_CAPTURECHANGED, sent },
2268 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
2269 { HCBT_DESTROYWND, hook },
2270 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2271 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
2272 { 0 }
2273 };
2274
2275 static const struct message WmTrackPopupMenuAbort[] = {
2276 { HCBT_CREATEWND, hook },
2277 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2278 { WM_ENTERMENULOOP, sent|wparam|lparam, TRUE, 0 },
2279 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2280 { WM_INITMENU, sent|lparam, 0, 0 },
2281 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2282 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
2283 { 0x0093, sent|optional },
2284 { 0x0094, sent|optional },
2285 { 0x0094, sent|optional },
2286 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2287 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2288 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
2289 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2290 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2291 { WM_CAPTURECHANGED, sent },
2292 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2293 { HCBT_DESTROYWND, hook },
2294 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2295 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2296 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
2297 { WM_MENUSELECT, sent|wparam|lparam, 0xffff0000, 0 },
2298 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2299 { WM_EXITMENULOOP, sent|wparam|lparam, 1, 0 },
2300 { 0 }
2301 };
2302
2303 static BOOL after_end_dialog, test_def_id, paint_loop_done;
2304 static int sequence_cnt, sequence_size;
2305 static struct recvd_message* sequence;
2306 static int log_all_parent_messages;
2307 static CRITICAL_SECTION sequence_cs;
2308
2309 /* user32 functions */
2310 static void (WINAPI *pNotifyWinEvent)(DWORD, HWND, LONG, LONG);
2311 static HWINEVENTHOOK (WINAPI *pSetWinEventHook)(DWORD, DWORD, HMODULE, WINEVENTPROC, DWORD, DWORD, DWORD);
2312 static BOOL (WINAPI *pTrackMouseEvent)(TRACKMOUSEEVENT*);
2313 static BOOL (WINAPI *pUnhookWinEvent)(HWINEVENTHOOK);
2314 static BOOL (WINAPI *pUpdateLayeredWindow)(HWND,HDC,POINT*,SIZE*,HDC,POINT*,COLORREF,BLENDFUNCTION*,DWORD);
2315 static UINT_PTR (WINAPI *pSetSystemTimer)(HWND, UINT_PTR, UINT, TIMERPROC);
2316 static UINT_PTR (WINAPI *pKillSystemTimer)(HWND, UINT_PTR);
2317 static UINT_PTR (WINAPI *pSetCoalescableTimer)(HWND, UINT_PTR, UINT, TIMERPROC, ULONG);
2318 /* kernel32 functions */
2319 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
2320
2321 static void init_procs(void)
2322 {
2323 HMODULE user32 = GetModuleHandleA("user32.dll");
2324 HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
2325
2326 #define GET_PROC(dll, func) \
2327 p ## func = (void*)GetProcAddress(dll, #func); \
2328 if(!p ## func) { \
2329 trace("GetProcAddress(%s) failed\n", #func); \
2330 }
2331
2332 GET_PROC(user32, NotifyWinEvent)
2333 GET_PROC(user32, SetWinEventHook)
2334 GET_PROC(user32, TrackMouseEvent)
2335 GET_PROC(user32, UnhookWinEvent)
2336 GET_PROC(user32, UpdateLayeredWindow)
2337 GET_PROC(user32, SetSystemTimer)
2338 GET_PROC(user32, KillSystemTimer)
2339 GET_PROC(user32, SetCoalescableTimer)
2340
2341 GET_PROC(kernel32, GetCPInfoExA)
2342
2343 #undef GET_PROC
2344 }
2345
2346 static const char *get_winpos_flags(UINT flags)
2347 {
2348 static char buffer[300];
2349
2350 buffer[0] = 0;
2351 #define DUMP(flag) do { if (flags & flag) { strcat( buffer, "|" #flag ); flags &= ~flag; } } while(0)
2352 DUMP( SWP_SHOWWINDOW );
2353 DUMP( SWP_HIDEWINDOW );
2354 DUMP( SWP_NOACTIVATE );
2355 DUMP( SWP_FRAMECHANGED );
2356 DUMP( SWP_NOCOPYBITS );
2357 DUMP( SWP_NOOWNERZORDER );
2358 DUMP( SWP_NOSENDCHANGING );
2359 DUMP( SWP_DEFERERASE );
2360 DUMP( SWP_ASYNCWINDOWPOS );
2361 DUMP( SWP_NOZORDER );
2362 DUMP( SWP_NOREDRAW );
2363 DUMP( SWP_NOSIZE );
2364 DUMP( SWP_NOMOVE );
2365 DUMP( SWP_NOCLIENTSIZE );
2366 DUMP( SWP_NOCLIENTMOVE );
2367 if (flags) sprintf(buffer + strlen(buffer),"|0x%04x", flags);
2368 return buffer + 1;
2369 #undef DUMP
2370 }
2371
2372 static BOOL ignore_message( UINT message )
2373 {
2374 /* these are always ignored */
2375 return (message >= 0xc000 ||
2376 message == WM_GETICON ||
2377 message == WM_GETOBJECT ||
2378 message == WM_TIMECHANGE ||
2379 message == WM_DISPLAYCHANGE ||
2380 message == WM_DEVICECHANGE ||
2381 message == WM_DWMNCRENDERINGCHANGED ||
2382 message == WM_WININICHANGE);
2383 }
2384
2385 static unsigned hash_Ly_W(const WCHAR *str)
2386 {
2387 unsigned hash = 0;
2388
2389 for (; *str; str++)
2390 hash = hash * 1664525u + (unsigned char)(*str) + 1013904223u;
2391
2392 return hash;
2393 }
2394
2395 static unsigned hash_Ly(const char *str)
2396 {
2397 unsigned hash = 0;
2398
2399 for (; *str; str++)
2400 hash = hash * 1664525u + (unsigned char)(*str) + 1013904223u;
2401
2402 return hash;
2403 }
2404
2405 #define add_message(msg) add_message_(__LINE__,msg);
2406 static void add_message_(int line, const struct recvd_message *msg)
2407 {
2408 struct recvd_message *seq;
2409
2410 EnterCriticalSection( &sequence_cs );
2411 if (!sequence)
2412 {
2413 sequence_size = 10;
2414 sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof(*sequence) );
2415 }
2416 if (sequence_cnt == sequence_size)
2417 {
2418 sequence_size *= 2;
2419 sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof(*sequence) );
2420 }
2421 assert(sequence);
2422
2423 seq = &sequence[sequence_cnt++];
2424 seq->hwnd = msg->hwnd;
2425 seq->message = msg->message;
2426 seq->flags = msg->flags;
2427 seq->wParam = msg->wParam;
2428 seq->lParam = msg->lParam;
2429 seq->line = line;
2430 seq->descr = msg->descr;
2431 seq->output[0] = 0;
2432 LeaveCriticalSection( &sequence_cs );
2433
2434 if (msg->descr)
2435 {
2436 if (msg->flags & hook)
2437 {
2438 static const char * const CBT_code_name[10] =
2439 {
2440 "HCBT_MOVESIZE",
2441 "HCBT_MINMAX",
2442 "HCBT_QS",
2443 "HCBT_CREATEWND",
2444 "HCBT_DESTROYWND",
2445 "HCBT_ACTIVATE",
2446 "HCBT_CLICKSKIPPED",
2447 "HCBT_KEYSKIPPED",
2448 "HCBT_SYSCOMMAND",
2449 "HCBT_SETFOCUS"
2450 };
2451 const char *code_name = (msg->message <= HCBT_SETFOCUS) ? CBT_code_name[msg->message] : "Unknown";
2452
2453 sprintf( seq->output, "%s: hook %d (%s) wp %08Ix lp %08Ix",
2454 msg->descr, msg->message, code_name, msg->wParam, msg->lParam );
2455 }
2456 else if (msg->flags & winevent_hook)
2457 {
2458 sprintf( seq->output, "%s: winevent %p %08x %08Ix %08Ix",
2459 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
2460 }
2461 else
2462 {
2463 switch (msg->message)
2464 {
2465 case WM_WINDOWPOSCHANGING:
2466 case WM_WINDOWPOSCHANGED:
2467 {
2468 WINDOWPOS *winpos = (WINDOWPOS *)msg->lParam;
2469
2470 sprintf( seq->output, "%s: %p WM_WINDOWPOS%s wp %08Ix lp %08Ix after %p x %d y %d cx %d cy %d flags %s",
2471 msg->descr, msg->hwnd,
2472 (msg->message == WM_WINDOWPOSCHANGING) ? "CHANGING" : "CHANGED",
2473 msg->wParam, msg->lParam, winpos->hwndInsertAfter,
2474 winpos->x, winpos->y, winpos->cx, winpos->cy,
2475 get_winpos_flags(winpos->flags) );
2476
2477 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2478 * in the high word for internal purposes
2479 */
2480 seq->wParam = winpos->flags & 0xffff;
2481 /* We are not interested in the flags that don't match under XP and Win9x */
2482 seq->wParam &= ~SWP_NOZORDER;
2483 seq->lParam = (!!winpos->cx) | ((!!winpos->cy) << 1)
2484 | ((!!winpos->x) << 2) | ((!!winpos->y) << 3);
2485 break;
2486 }
2487
2488 case WM_NCCALCSIZE:
2489 if (msg->wParam)
2490 {
2491 NCCALCSIZE_PARAMS *p = (NCCALCSIZE_PARAMS *)msg->lParam;
2492 WINDOWPOS *winpos = p->lppos;
2493
2494 sprintf(seq->output, "%s: %p WM_NCCALCSIZE: winpos->cx %u, winpos->cy %u",
2495 msg->descr, msg->hwnd, winpos->cx, winpos->cy);
2496 seq->lParam = (!!winpos->cx) | ((!!winpos->cy) << 1)
2497 | ((!!winpos->x) << 2) | ((!!winpos->y) << 3);
2498 }
2499 else
2500 {
2501 seq->lParam = 0;
2502 }
2503 break;
2504 case WM_DRAWITEM:
2505 {
2506 DRAW_ITEM_STRUCT di;
2507 DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)msg->lParam;
2508
2509 sprintf( seq->output, "%s: %p WM_DRAWITEM: type %x, ctl_id %x, item_id %x, action %x, state %x",
2510 msg->descr, msg->hwnd, dis->CtlType, dis->CtlID,
2511 dis->itemID, dis->itemAction, dis->itemState);
2512
2513 di.u.lp = 0;
2514 di.u.item.type = dis->CtlType;
2515 di.u.item.ctl_id = dis->CtlID;
2516 if (dis->CtlType == ODT_LISTBOX ||
2517 dis->CtlType == ODT_COMBOBOX ||
2518 dis->CtlType == ODT_MENU)
2519 di.u.item.item_id = dis->itemID;
2520 di.u.item.action = dis->itemAction;
2521 di.u.item.state = dis->itemState;
2522
2523 seq->lParam = di.u.lp;
2524 break;
2525 }
2526
2527 case WM_MEASUREITEM:
2528 {
2529 MEASURE_ITEM_STRUCT mi;
2530 MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)msg->lParam;
2531 BOOL is_unicode_data = TRUE;
2532
2533 sprintf( seq->output, "%s: %p WM_MEASUREITEM: CtlType %#x, CtlID %#x, itemID %#x, itemData %#Ix",
2534 msg->descr, msg->hwnd, mis->CtlType, mis->CtlID,
2535 mis->itemID, mis->itemData);
2536
2537 if (mis->CtlType == ODT_LISTBOX)
2538 {
2539 HWND ctrl = GetDlgItem(msg->hwnd, mis->CtlID);
2540 is_unicode_data = GetWindowLongA(ctrl, GWL_STYLE) & LBS_HASSTRINGS;
2541 }
2542
2543 mi.u.wp = 0;
2544 mi.u.item.CtlType = mis->CtlType;
2545 mi.u.item.CtlID = mis->CtlID;
2546 mi.u.item.itemID = mis->itemID;
2547 mi.u.item.wParam = msg->wParam;
2548 seq->wParam = mi.u.wp;
2549 if (is_unicode_data)
2550 seq->lParam = mis->itemData ? hash_Ly_W((const WCHAR *)mis->itemData) : 0;
2551 else
2552 seq->lParam = mis->itemData ? hash_Ly((const char *)mis->itemData) : 0;
2553 break;
2554 }
2555
2556 case WM_COMPAREITEM:
2557 {
2558 COMPAREITEMSTRUCT *cis = (COMPAREITEMSTRUCT *)msg->lParam;
2559 HWND ctrl = GetDlgItem(msg->hwnd, cis->CtlID);
2560 BOOL is_unicode_data = TRUE;
2561
2562 ok(msg->wParam == cis->CtlID, "expected %#x, got %#Ix\n", cis->CtlID, msg->wParam);
2563 ok(cis->hwndItem == ctrl, "expected %p, got %p\n", ctrl, cis->hwndItem);
2564 ok((int)cis->itemID1 >= 0, "expected >= 0, got %d\n", cis->itemID1);
2565 ok((int)cis->itemID2 == -1, "expected -1, got %d\n", cis->itemID2);
2566
2567 sprintf( seq->output, "%s: %p WM_COMPAREITEM: CtlType %#x, CtlID %#x, itemID1 %#x, itemData1 %#Ix, itemID2 %#x, itemData2 %#Ix",
2568 msg->descr, msg->hwnd, cis->CtlType, cis->CtlID,
2569 cis->itemID1, cis->itemData1, cis->itemID2, cis->itemData2);
2570
2571 if (cis->CtlType == ODT_LISTBOX)
2572 is_unicode_data = GetWindowLongA(ctrl, GWL_STYLE) & LBS_HASSTRINGS;
2573
2574 if (is_unicode_data)
2575 {
2576 seq->wParam = cis->itemData1 ? hash_Ly_W((const WCHAR *)cis->itemData1) : 0;
2577 seq->lParam = cis->itemData2 ? hash_Ly_W((const WCHAR *)cis->itemData2) : 0;
2578 }
2579 else
2580 {
2581 seq->wParam = cis->itemData1 ? hash_Ly((const char *)cis->itemData1) : 0;
2582 seq->lParam = cis->itemData2 ? hash_Ly((const char *)cis->itemData2) : 0;
2583 }
2584 break;
2585 }
2586
2587 default:
2588 if (msg->message >= 0xc000) return; /* ignore registered messages */
2589 sprintf( seq->output, "%s: %p %04x wp %08Ix lp %08Ix",
2590 msg->descr, msg->hwnd, msg->message, msg->wParam, msg->lParam );
2591 }
2592 if (msg->flags & (sent|posted|parent|defwinproc|beginpaint))
2593 sprintf( seq->output + strlen(seq->output), " (flags %x)", msg->flags );
2594 }
2595 }
2596 }
2597
2598 /* try to make sure pending X events have been processed before continuing */
2599 static void flush_events(void)
2600 {
2601 MSG msg;
2602 int diff = 200;
2603 int min_timeout = 100;
2604 DWORD time = GetTickCount() + diff;
2605
2606 while (diff > 0)
2607 {
2608 if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
2609 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
2610 diff = time - GetTickCount();
2611 }
2612 }
2613
2614 static void flush_sequence(void)
2615 {
2616 EnterCriticalSection( &sequence_cs );
2617 HeapFree(GetProcessHeap(), 0, sequence);
2618 sequence = 0;
2619 sequence_cnt = sequence_size = 0;
2620 LeaveCriticalSection( &sequence_cs );
2621 }
2622
2623 static void dump_sequence(const struct message *expected, const char *context, const char *file, int line)
2624 {
2625 const struct recvd_message *actual = sequence;
2626 unsigned int count = 0;
2627
2628 trace_(file, line)("Failed sequence %s:\n", context );
2629 while (expected->message && actual->message)
2630 {
2631 if (actual->output[0])
2632 {
2633 if (expected->flags & hook)
2634 {
2635 trace_(file, line)( " %u: expected: hook %04x - actual: %s\n",
2636 count, expected->message, actual->output );
2637 }
2638 else if (expected->flags & winevent_hook)
2639 {
2640 trace_(file, line)( " %u: expected: winevent %04x - actual: %s\n",
2641 count, expected->message, actual->output );
2642 }
2643 else if (expected->flags & kbd_hook)
2644 {
2645 trace_(file, line)( " %u: expected: kbd %04x - actual: %s\n",
2646 count, expected->message, actual->output );
2647 }
2648 else
2649 {
2650 trace_(file, line)( " %u: expected: msg %04x - actual: %s\n",
2651 count, expected->message, actual->output );
2652 }
2653 }
2654
2655 if (expected->message == actual->message)
2656 {
2657 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) &&
2658 (expected->flags & optional))
2659 {
2660 /* don't match messages if their defwinproc status differs */
2661 expected++;
2662 }
2663 else
2664 {
2665 expected++;
2666 actual++;
2667 }
2668 }
2669 /* silently drop winevent messages if there is no support for them */
2670 else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook) ||
2671 ((expected->flags & winevent_hook_todo) && !strcmp(winetest_platform, "wine")))
2672 expected++;
2673 else
2674 {
2675 expected++;
2676 actual++;
2677 }
2678 count++;
2679 }
2680
2681 /* optional trailing messages */
2682 while (expected->message && ((expected->flags & optional) ||
2683 ((expected->flags & winevent_hook) && !hEvent_hook)))
2684 {
2685 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
2686 expected++;
2687 count++;
2688 }
2689
2690 if (expected->message)
2691 {
2692 trace_(file, line)( " %u: expected: msg %04x - actual: nothing\n", count, expected->message );
2693 return;
2694 }
2695
2696 while (actual->message && actual->output[0])
2697 {
2698 trace_(file, line)( " %u: expected: nothing - actual: %s\n", count, actual->output );
2699 actual++;
2700 count++;
2701 }
2702 }
2703
2704 #define ok_sequence( exp, contx, todo) \
2705 ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
2706
2707
2708 static void ok_sequence_(const struct message *expected_list, const char *context, BOOL todo,
2709 const char *file, int line)
2710 {
2711 static const struct recvd_message end_of_sequence;
2712 const struct message *expected = expected_list;
2713 const struct recvd_message *actual;
2714 int failcount = 0, dump = 0;
2715 unsigned int count = 0;
2716 BOOL is_wine = !strcmp(winetest_platform, "wine");
2717
2718 add_message(&end_of_sequence);
2719
2720 actual = sequence;
2721
2722 while (expected->message && actual->message)
2723 {
2724 if (expected->message == actual->message &&
2725 !((expected->flags ^ actual->flags) & (hook|winevent_hook|kbd_hook)))
2726 {
2727 if (expected->flags & wparam)
2728 {
2729 if (((expected->wParam ^ actual->wParam) & ~expected->wp_mask) && todo)
2730 {
2731 todo_wine {
2732 failcount ++;
2733 dump++;
2734 ok_( file, line) (FALSE,
2735 "%s: %u: in msg 0x%04x expecting wParam 0x%Ix got 0x%Ix\n",
2736 context, count, expected->message, expected->wParam, actual->wParam);
2737 }
2738 if (is_wine) goto done;
2739 }
2740 else
2741 {
2742 ok_( file, line)( ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) == 0,
2743 "%s: %u: in msg 0x%04x expecting wParam 0x%Ix got 0x%Ix\n",
2744 context, count, expected->message, expected->wParam, actual->wParam);
2745 if ((expected->wParam ^ actual->wParam) & ~expected->wp_mask) dump++;
2746 }
2747
2748 }
2749 if (expected->flags & lparam)
2750 {
2751 if (((expected->lParam ^ actual->lParam) & ~expected->lp_mask) && todo)
2752 {
2753 todo_wine {
2754 failcount ++;
2755 dump++;
2756 ok_( file, line) (FALSE,
2757 "%s: %u: in msg 0x%04x expecting lParam 0x%Ix got 0x%Ix\n",
2758 context, count, expected->message, expected->lParam, actual->lParam);
2759 }
2760 if (is_wine) goto done;
2761 }
2762 else
2763 {
2764 ok_( file, line)(((expected->lParam ^ actual->lParam) & ~expected->lp_mask) == 0,
2765 "%s: %u: in msg 0x%04x expecting lParam 0x%Ix got 0x%Ix\n",
2766 context, count, expected->message, expected->lParam, actual->lParam);
2767 if ((expected->lParam ^ actual->lParam) & ~expected->lp_mask) dump++;
2768 }
2769 }
2770 if ((expected->flags & optional) &&
2771 ((expected->flags ^ actual->flags) & (defwinproc|parent)))
2772 {
2773 /* don't match optional messages if their defwinproc or parent status differs */
2774 expected++;
2775 count++;
2776 continue;
2777 }
2778 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
2779 {
2780 todo_wine {
2781 failcount ++;
2782 dump++;
2783 ok_( file, line) (FALSE,
2784 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2785 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2786 }
2787 if (is_wine) goto done;
2788 }
2789 else
2790 {
2791 ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
2792 "%s: %u: the msg 0x%04x should %shave been sent by DefWindowProc\n",
2793 context, count, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
2794 if ((expected->flags & defwinproc) != (actual->flags & defwinproc)) dump++;
2795 }
2796
2797 ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
2798 "%s: %u: the msg 0x%04x should %shave been sent by BeginPaint\n",
2799 context, count, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
2800 if ((expected->flags & beginpaint) != (actual->flags & beginpaint)) dump++;
2801
2802 ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
2803 "%s: %u: the msg 0x%04x should have been %s\n",
2804 context, count, expected->message, (expected->flags & posted) ? "posted" : "sent");
2805 if ((expected->flags & (sent|posted)) != (actual->flags & (sent|posted))) dump++;
2806
2807 ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
2808 "%s: %u: the msg 0x%04x was expected in %s\n",
2809 context, count, expected->message, (expected->flags & parent) ? "parent" : "child");
2810 if ((expected->flags & parent) != (actual->flags & parent)) dump++;
2811
2812 ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
2813 "%s: %u: the msg 0x%04x should have been sent by a hook\n",
2814 context, count, expected->message);
2815 if ((expected->flags & hook) != (actual->flags & hook)) dump++;
2816
2817 ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
2818 "%s: %u: the msg 0x%04x should have been sent by a winevent hook\n",
2819 context, count, expected->message);
2820 if ((expected->flags & winevent_hook) != (actual->flags & winevent_hook)) dump++;
2821
2822 ok_( file, line) ((expected->flags & kbd_hook) == (actual->flags & kbd_hook),
2823 "%s: %u: the msg 0x%04x should have been sent by a keyboard hook\n",
2824 context, count, expected->message);
2825 if ((expected->flags & kbd_hook) != (actual->flags & kbd_hook)) dump++;
2826
2827 expected++;
2828 actual++;
2829 }
2830 /*
2831 * silently drop hook messages if there is no support for them, mark
2832 * winevent todo's.
2833 */
2834 else if ((expected->flags & optional) ||
2835 ((expected->flags & hook) && !hCBT_hook) ||
2836 ((expected->flags & winevent_hook) && !hEvent_hook) ||
2837 ((expected->flags & kbd_hook) && !hKBD_hook) ||
2838 ((expected->flags & winevent_hook_todo) && is_wine))
2839 {
2840 if ((expected->flags & winevent_hook_todo) && hEvent_hook)
2841 {
2842 static int reported;
2843 if (!reported++) todo_wine {
2844 ok_( file, line) (FALSE,
2845 "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2846 context, count, expected->message, actual->message);
2847 }
2848 }
2849 expected++;
2850 goto done;
2851 }
2852 else if (todo)
2853 {
2854 failcount++;
2855 todo_wine {
2856 dump++;
2857 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2858 context, count, expected->message, actual->message);
2859 }
2860 goto done;
2861 }
2862 else
2863 {
2864 ok_( file, line) (FALSE, "%s: %u: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
2865 context, count, expected->message, actual->message);
2866 dump++;
2867 expected++;
2868 actual++;
2869 }
2870 count++;
2871 }
2872
2873 /* skip all optional trailing messages, check for winevent todo's. */
2874 while (expected->message && ((expected->flags & optional) ||
2875 ((expected->flags & hook) && !hCBT_hook) ||
2876 ((expected->flags & winevent_hook) && !hEvent_hook) ||
2877 ((expected->flags & winevent_hook_todo) && is_wine)))
2878 {
2879 if ((expected->flags & winevent_hook_todo) && hEvent_hook)
2880 {
2881 todo_wine {
2882 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected 0x%04x - actual 0x%04x\n",
2883 context, count, expected->message, actual->message);
2884 }
2885 }
2886 expected++;
2887 goto done;
2888 }
2889
2890 if (todo)
2891 {
2892 todo_wine {
2893 if (expected->message || actual->message) {
2894 failcount++;
2895 dump++;
2896 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2897 context, count, expected->message, actual->message);
2898 }
2899 }
2900 if (is_wine) goto done;
2901 }
2902 else
2903 {
2904 if (expected->message || actual->message)
2905 {
2906 dump++;
2907 ok_( file, line) (FALSE, "%s: %u: the msg sequence is not complete: expected %04x - actual %04x\n",
2908 context, count, expected->message, actual->message);
2909 }
2910 }
2911 if( todo && !failcount) /* succeeded yet marked todo */
2912 todo_wine {
2913 dump++;
2914 ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
2915 }
2916
2917 done:
2918 if (dump && (!is_wine || winetest_debug > 1)) dump_sequence(expected_list, context, file, line);
2919 flush_sequence();
2920 }
2921
2922 #define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %ld\n", (EXPECTED), (GOT))
2923
2924 /******************************** MDI test **********************************/
2925
2926 /* CreateWindow for MDI frame window, initially visible */
2927 static const struct message WmCreateMDIframeSeq[] = {
2928 { HCBT_CREATEWND, hook },
2929 { WM_GETMINMAXINFO, sent },
2930 { WM_NCCREATE, sent },
2931 { WM_NCCALCSIZE, sent|wparam, 0 },
2932 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win8+. */
2933 { WM_CREATE, sent },
2934 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2935 { WM_NOTIFYFORMAT, sent|optional },
2936 { WM_QUERYUISTATE, sent|optional },
2937 { WM_WINDOWPOSCHANGING, sent|optional },
2938 { WM_GETMINMAXINFO, sent|optional },
2939 { WM_NCCALCSIZE, sent|optional },
2940 { WM_WINDOWPOSCHANGED, sent|optional },
2941 { WM_SHOWWINDOW, sent|wparam, 1 },
2942 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2943 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2944 { HCBT_ACTIVATE, hook },
2945 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2946 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
2947 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* XP */
2948 { WM_ACTIVATEAPP, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
2949 { WM_NCACTIVATE, sent },
2950 { WM_GETTEXT, sent|defwinproc|optional },
2951 { WM_ACTIVATE, sent|wparam, 1 },
2952 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x */
2953 { HCBT_SETFOCUS, hook },
2954 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2955 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
2956 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
2957 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
2958 /* Win9x adds SWP_NOZORDER below */
2959 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2960 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2961 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win8+. */
2962 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2963 { WM_MOVE, sent },
2964 { 0 }
2965 };
2966 /* DestroyWindow for MDI frame window, initially visible */
2967 static const struct message WmDestroyMDIframeSeq[] = {
2968 { HCBT_DESTROYWND, hook },
2969 { 0x0090, sent|optional },
2970 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2971 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2972 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2973 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2974 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* XP */
2975 { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
2976 { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
2977 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
2978 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2979 { WM_DESTROY, sent },
2980 { WM_NCDESTROY, sent },
2981 { 0 }
2982 };
2983 /* CreateWindow for MDI client window, initially visible */
2984 static const struct message WmCreateMDIclientSeq[] = {
2985 { HCBT_CREATEWND, hook },
2986 { WM_NCCREATE, sent },
2987 { WM_NCCALCSIZE, sent|wparam, 0 },
2988 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2989 { WM_CREATE, sent },
2990 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
2991 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2992 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2993 { WM_MOVE, sent },
2994 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
2995 { WM_SHOWWINDOW, sent|wparam, 1 },
2996 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2997 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
2998 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2999 { 0 }
3000 };
3001 /* ShowWindow(SW_SHOW) for MDI client window */
3002 static const struct message WmShowMDIclientSeq[] = {
3003 { WM_SHOWWINDOW, sent|wparam, 1 },
3004 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3005 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3006 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3007 { 0 }
3008 };
3009 /* ShowWindow(SW_HIDE) for MDI client window */
3010 static const struct message WmHideMDIclientSeq[] = {
3011 { WM_SHOWWINDOW, sent|wparam, 0 },
3012 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3013 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* win2000 */
3014 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP */
3015 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3016 { 0 }
3017 };
3018 /* DestroyWindow for MDI client window, initially visible */
3019 static const struct message WmDestroyMDIclientSeq[] = {
3020 { HCBT_DESTROYWND, hook },
3021 { 0x0090, sent|optional },
3022 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
3023 { WM_SHOWWINDOW, sent|wparam, 0 },
3024 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3025 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3026 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3027 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3028 { WM_DESTROY, sent },
3029 { WM_NCDESTROY, sent },
3030 { 0 }
3031 };
3032 /* CreateWindow for MDI child window, initially visible */
3033 static const struct message WmCreateMDIchildVisibleSeq[] = {
3034 { HCBT_CREATEWND, hook },
3035 { WM_NCCREATE, sent },
3036 { WM_NCCALCSIZE, sent|wparam, 0 },
3037 { WM_CREATE, sent },
3038 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3039 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3040 { WM_MOVE, sent },
3041 /* Win2k sends wparam set to
3042 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
3043 * while Win9x doesn't bother to set child window id according to
3044 * CLIENTCREATESTRUCT.idFirstChild
3045 */
3046 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3047 { WM_SHOWWINDOW, sent|wparam, 1 },
3048 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3049 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3050 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3051 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
3052 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
3053 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3054 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3055
3056 /* Win9x: message sequence terminates here. */
3057
3058 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
3059 { HCBT_SETFOCUS, hook }, /* in MDI client */
3060 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3061 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
3062 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3063 { WM_SETFOCUS, sent }, /* in MDI client */
3064 { HCBT_SETFOCUS, hook },
3065 { WM_KILLFOCUS, sent }, /* in MDI client */
3066 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3067 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3068 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3069 { WM_SETFOCUS, sent|defwinproc },
3070 { WM_MDIACTIVATE, sent|defwinproc },
3071 { 0 }
3072 };
3073 /* WM_CHILDACTIVATE sent to disabled window */
3074 static const struct message WmChildActivateDisabledWindowSeq[] = {
3075 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3076 { 0 }
3077 };
3078 /* WM_CHILDACTIVATE sent to enabled window */
3079 static const struct message WmChildActivateWindowSeq[] = {
3080 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3081 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 },
3082 { WM_MDIACTIVATE, sent|defwinproc },
3083 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3084 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3085 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3086 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
3087 { HCBT_SETFOCUS, hook },
3088 { WM_KILLFOCUS, sent|defwinproc },
3089 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3090 { WM_SETFOCUS, sent },
3091 { HCBT_SETFOCUS, hook },
3092 { WM_KILLFOCUS, sent },
3093 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3094 { WM_SETFOCUS, sent|defwinproc },
3095 { WM_MDIACTIVATE, sent|defwinproc },
3096 { 0 }
3097 };
3098 /* CreateWindow for MDI child window with invisible parent */
3099 static const struct message WmCreateMDIchildInvisibleParentSeq[] = {
3100 { HCBT_CREATEWND, hook },
3101 { WM_GETMINMAXINFO, sent },
3102 { WM_NCCREATE, sent },
3103 { WM_NCCALCSIZE, sent|wparam, 0 },
3104 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
3105 { WM_CREATE, sent },
3106 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3107 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3108 { WM_MOVE, sent },
3109 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3110 { WM_SHOWWINDOW, sent|wparam, 1 },
3111 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
3112 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
3113 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3114 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3115
3116 /* Win9x: message sequence terminates here. */
3117
3118 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
3119 { HCBT_SETFOCUS, hook }, /* in MDI client */
3120 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3121 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
3122 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3123 { WM_SETFOCUS, sent }, /* in MDI client */
3124 { HCBT_SETFOCUS, hook },
3125 { WM_KILLFOCUS, sent }, /* in MDI client */
3126 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3127 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3128 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3129 { WM_SETFOCUS, sent|defwinproc },
3130 { WM_MDIACTIVATE, sent|defwinproc },
3131 { 0 }
3132 };
3133 /* DestroyWindow for MDI child window, initially visible */
3134 static const struct message WmDestroyMDIchildVisibleSeq[] = {
3135 { HCBT_DESTROYWND, hook },
3136 /* Win2k sends wparam set to
3137 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
3138 * while Win9x doesn't bother to set child window id according to
3139 * CLIENTCREATESTRUCT.idFirstChild
3140 */
3141 { 0x0090, sent|optional },
3142 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
3143 { WM_SHOWWINDOW, sent|wparam, 0 },
3144 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3145 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3146 { WM_ERASEBKGND, sent|parent|optional },
3147 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3148
3149 /* { WM_DESTROY, sent }
3150 * Win9x: message sequence terminates here.
3151 */
3152
3153 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
3154 { WM_KILLFOCUS, sent },
3155 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3156 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3157 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3158 { WM_SETFOCUS, sent }, /* in MDI client */
3159
3160 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
3161 { WM_KILLFOCUS, sent }, /* in MDI client */
3162 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3163 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3164 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3165 { WM_SETFOCUS, sent }, /* in MDI client */
3166
3167 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3168
3169 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
3170 { WM_KILLFOCUS, sent },
3171 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3172 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3173 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3174 { WM_SETFOCUS, sent }, /* in MDI client */
3175
3176 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
3177 { WM_KILLFOCUS, sent }, /* in MDI client */
3178 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3179 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3180 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3181 { WM_SETFOCUS, sent }, /* in MDI client */
3182
3183 { WM_DESTROY, sent },
3184
3185 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
3186 { WM_KILLFOCUS, sent },
3187 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3188 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3189 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3190 { WM_SETFOCUS, sent }, /* in MDI client */
3191
3192 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
3193 { WM_KILLFOCUS, sent }, /* in MDI client */
3194 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3195 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3196 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3197 { WM_SETFOCUS, sent }, /* in MDI client */
3198
3199 { WM_NCDESTROY, sent },
3200 { 0 }
3201 };
3202 /* CreateWindow for MDI child window, initially invisible */
3203 static const struct message WmCreateMDIchildInvisibleSeq[] = {
3204 { HCBT_CREATEWND, hook },
3205 { WM_NCCREATE, sent },
3206 { WM_NCCALCSIZE, sent|wparam, 0 },
3207 { WM_CREATE, sent },
3208 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3209 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3210 { WM_MOVE, sent },
3211 /* Win2k sends wparam set to
3212 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
3213 * while Win9x doesn't bother to set child window id according to
3214 * CLIENTCREATESTRUCT.idFirstChild
3215 */
3216 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3217 { 0 }
3218 };
3219 /* DestroyWindow for MDI child window, initially invisible */
3220 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
3221 { HCBT_DESTROYWND, hook },
3222 /* Win2k sends wparam set to
3223 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
3224 * while Win9x doesn't bother to set child window id according to
3225 * CLIENTCREATESTRUCT.idFirstChild
3226 */
3227 { 0x0090, sent|optional },
3228 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
3229 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3230 { WM_DESTROY, sent },
3231 { WM_NCDESTROY, sent },
3232 /* FIXME: Wine destroys an icon/title window while Windows doesn't */
3233 { WM_PARENTNOTIFY, sent|wparam|optional, WM_DESTROY }, /* MDI client */
3234 { 0 }
3235 };
3236 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
3237 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
3238 { HCBT_CREATEWND, hook },
3239 { WM_NCCREATE, sent },
3240 { WM_NCCALCSIZE, sent|wparam, 0 },
3241 { WM_CREATE, sent },
3242 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3243 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3244 { WM_MOVE, sent },
3245 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3246 { WM_GETMINMAXINFO, sent },
3247 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
3248 { WM_NCCALCSIZE, sent|wparam, 1 },
3249 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3250 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3251 /* in MDI frame */
3252 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3253 { WM_NCCALCSIZE, sent|wparam, 1 },
3254 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3255 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3256 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3257 /* Win2k sends wparam set to
3258 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
3259 * while Win9x doesn't bother to set child window id according to
3260 * CLIENTCREATESTRUCT.idFirstChild
3261 */
3262 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3263 { WM_SHOWWINDOW, sent|wparam, 1 },
3264 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3265 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3266 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3267 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
3268 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
3269 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3270 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_FRAMECHANGED },
3271
3272 /* Win9x: message sequence terminates here. */
3273
3274 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
3275 { HCBT_SETFOCUS, hook|optional }, /* in MDI client */
3276 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3277 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
3278 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3279 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3280 { HCBT_SETFOCUS, hook|optional },
3281 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3282 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3283 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3284 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3285 { WM_SETFOCUS, sent|defwinproc|optional },
3286 { WM_MDIACTIVATE, sent|defwinproc|optional },
3287 /* in MDI frame */
3288 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3289 { WM_NCCALCSIZE, sent|wparam, 1 },
3290 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3291 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3292 { 0 }
3293 };
3294 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
3295 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
3296 /* restore the 1st MDI child */
3297 { WM_SETREDRAW, sent|wparam, 0 },
3298 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
3299 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3300 { WM_NCCALCSIZE, sent|wparam, 1 },
3301 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3302 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3303 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3304 /* in MDI frame */
3305 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3306 { WM_NCCALCSIZE, sent|wparam, 1 },
3307 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3308 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3309 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3310 { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
3311 /* create the 2nd MDI child */
3312 { HCBT_CREATEWND, hook },
3313 { WM_NCCREATE, sent },
3314 { WM_NCCALCSIZE, sent|wparam, 0 },
3315 { WM_CREATE, sent },
3316 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3317 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3318 { WM_MOVE, sent },
3319 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3320 { WM_GETMINMAXINFO, sent },
3321 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
3322 { WM_NCCALCSIZE, sent|wparam, 1 },
3323 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3324 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3325 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3326 /* in MDI frame */
3327 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3328 { WM_NCCALCSIZE, sent|wparam, 1 },
3329 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3330 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3331 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3332 /* Win2k sends wparam set to
3333 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
3334 * while Win9x doesn't bother to set child window id according to
3335 * CLIENTCREATESTRUCT.idFirstChild
3336 */
3337 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3338 { WM_SHOWWINDOW, sent|wparam, 1 },
3339 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3340 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3341 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3342 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
3343 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
3344 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3345
3346 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
3347 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
3348
3349 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3350
3351 /* Win9x: message sequence terminates here. */
3352
3353 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
3354 { HCBT_SETFOCUS, hook },
3355 { WM_KILLFOCUS, sent|defwinproc|optional }, /* in the 1st MDI child */
3356 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
3357 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3358 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3359 { WM_SETFOCUS, sent }, /* in MDI client */
3360 { HCBT_SETFOCUS, hook },
3361 { WM_KILLFOCUS, sent }, /* in MDI client */
3362 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3363 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3364 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3365 { WM_SETFOCUS, sent|defwinproc },
3366
3367 { WM_MDIACTIVATE, sent|defwinproc },
3368 /* in MDI frame */
3369 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3370 { WM_NCCALCSIZE, sent|wparam, 1 },
3371 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3372 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3373 { 0 }
3374 };
3375 /* WM_MDICREATE MDI child window, initially visible and maximized */
3376 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
3377 { WM_MDICREATE, sent },
3378 { HCBT_CREATEWND, hook },
3379 { WM_NCCREATE, sent },
3380 { WM_NCCALCSIZE, sent|wparam, 0 },
3381 { WM_CREATE, sent },
3382 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3383 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3384 { WM_MOVE, sent },
3385 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3386 { WM_GETMINMAXINFO, sent },
3387 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
3388 { WM_NCCALCSIZE, sent|wparam, 1 },
3389 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3390 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3391
3392 /* in MDI frame */
3393 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3394 { WM_NCCALCSIZE, sent|wparam, 1 },
3395 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3396 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3397 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3398
3399 /* Win2k sends wparam set to
3400 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
3401 * while Win9x doesn't bother to set child window id according to
3402 * CLIENTCREATESTRUCT.idFirstChild
3403 */
3404 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3405 { WM_SHOWWINDOW, sent|wparam, 1 },
3406 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3407
3408 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3409
3410 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3411 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
3412 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
3413
3414 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3415 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3416
3417 /* Win9x: message sequence terminates here. */
3418
3419 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
3420 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3421 { HCBT_SETFOCUS, hook }, /* in MDI client */
3422 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3423 { WM_IME_NOTIFY, sent|wparam|optional, 2 },
3424 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
3425 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3426 { HCBT_SETFOCUS, hook|optional },
3427 { WM_KILLFOCUS, sent }, /* in MDI client */
3428 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3429 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3430 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3431 { WM_SETFOCUS, sent|defwinproc },
3432
3433 { WM_MDIACTIVATE, sent|defwinproc },
3434
3435 /* in MDI child */
3436 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3437 { WM_NCCALCSIZE, sent|wparam, 1 },
3438 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3439 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3440
3441 /* in MDI frame */
3442 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3443 { WM_NCCALCSIZE, sent|wparam, 1 },
3444 { 0x0093, sent|defwinproc|optional },
3445 { 0x0093, sent|defwinproc|optional },
3446 { 0x0093, sent|defwinproc|optional },
3447 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3448 { WM_MOVE, sent|defwinproc },
3449 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3450
3451 /* in MDI client */
3452 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3453 { WM_NCCALCSIZE, sent|wparam, 1 },
3454 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3455 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3456
3457 /* in MDI child */
3458 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3459 { WM_NCCALCSIZE, sent|wparam, 1 },
3460 { 0x0093, sent|optional },
3461 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3462 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3463
3464 { 0x0093, sent|optional },
3465 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3466 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client, not sent on Win7. */
3467 { 0x0093, sent|optional }, /* Win8+ sends an extra. */
3468 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
3469 { 0x0093, sent|defwinproc|optional },
3470 { 0x0093, sent|defwinproc|optional },
3471 { 0x0093, sent|defwinproc|optional },
3472 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3473 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
3474
3475 { 0 }
3476 };
3477 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
3478 static const struct message WmCreateMDIchildInvisibleMaxSeq4[] = {
3479 { HCBT_CREATEWND, hook },
3480 { WM_GETMINMAXINFO, sent },
3481 { WM_NCCREATE, sent },
3482 { WM_NCCALCSIZE, sent|wparam, 0 },
3483 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not sent on Win8+. */
3484 { WM_CREATE, sent },
3485 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3486 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3487 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOZORDER }, /* MDI frame */
3488 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI frame */
3489 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOZORDER }, /* MDI frame */
3490 { WM_MOVE, sent },
3491 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3492 { WM_GETMINMAXINFO, sent },
3493 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
3494 { WM_GETMINMAXINFO, sent|defwinproc },
3495 { WM_NCCALCSIZE, sent|wparam, 1 },
3496 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_STATECHANGED },
3497 { WM_MOVE, sent|defwinproc },
3498 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3499 /* in MDI frame */
3500 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3501 { WM_NCCALCSIZE, sent|wparam, 1 },
3502 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3503 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3504 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI child */
3505 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3506 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3507 /* Win2k sends wparam set to
3508 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
3509 * while Win9x doesn't bother to set child window id according to
3510 * CLIENTCREATESTRUCT.idFirstChild
3511 */
3512 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
3513 { 0 }
3514 };
3515 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
3516 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
3517 { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
3518 { HCBT_SYSCOMMAND, hook },
3519 { WM_CLOSE, sent|defwinproc },
3520 { WM_MDIDESTROY, sent }, /* in MDI client */
3521
3522 /* bring the 1st MDI child to top */
3523 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
3524 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
3525
3526 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3527
3528 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
3529 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
3530 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
3531
3532 /* maximize the 1st MDI child */
3533 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3534 { WM_GETMINMAXINFO, sent|defwinproc },
3535 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED },
3536 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
3537 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
3538 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3539 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3540
3541 /* restore the 2nd MDI child */
3542 { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
3543 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
3544 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
3545 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
3546
3547 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3548
3549 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3550 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3551
3552 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3553
3554 { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
3555 /* in MDI frame */
3556 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3557 { WM_NCCALCSIZE, sent|wparam, 1 },
3558 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3559 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3560 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3561
3562 /* bring the 1st MDI child to top */
3563 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3564 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
3565 { HCBT_SETFOCUS, hook },
3566 { WM_KILLFOCUS, sent|defwinproc },
3567 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
3568 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3569 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3570 { WM_SETFOCUS, sent }, /* in MDI client */
3571 { HCBT_SETFOCUS, hook },
3572 { WM_KILLFOCUS, sent }, /* in MDI client */
3573 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3574 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3575 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3576 { WM_SETFOCUS, sent|defwinproc },
3577 { WM_MDIACTIVATE, sent|defwinproc },
3578 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3579
3580 /* apparently ShowWindow(SW_SHOW) on an MDI client */
3581 { WM_SHOWWINDOW, sent|wparam, 1 },
3582 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3583 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3584 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3585 { WM_MDIREFRESHMENU, sent },
3586
3587 { HCBT_DESTROYWND, hook },
3588 /* Win2k sends wparam set to
3589 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
3590 * while Win9x doesn't bother to set child window id according to
3591 * CLIENTCREATESTRUCT.idFirstChild
3592 */
3593 { 0x0090, sent|defwinproc|optional },
3594 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
3595 { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
3596 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3597 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3598 { WM_ERASEBKGND, sent|parent|optional },
3599 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3600
3601 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3602 { WM_DESTROY, sent|defwinproc },
3603 { WM_NCDESTROY, sent|defwinproc },
3604 { 0 }
3605 };
3606 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
3607 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
3608 { WM_MDIDESTROY, sent }, /* in MDI client */
3609 { WM_SHOWWINDOW, sent|wparam, 0 },
3610 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3611 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3612 { WM_ERASEBKGND, sent|parent|optional },
3613 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3614
3615 { HCBT_SETFOCUS, hook },
3616 { WM_KILLFOCUS, sent },
3617 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3618 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3619 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3620 { WM_SETFOCUS, sent }, /* in MDI client */
3621 { HCBT_SETFOCUS, hook },
3622 { WM_KILLFOCUS, sent }, /* in MDI client */
3623 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3624 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3625 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3626 { WM_SETFOCUS, sent },
3627
3628 /* in MDI child */
3629 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3630 { WM_NCCALCSIZE, sent|wparam, 1 },
3631 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3632 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3633
3634 /* in MDI frame */
3635 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3636 { WM_NCCALCSIZE, sent|wparam, 1 },
3637 { 0x0093, sent|defwinproc|optional },
3638 { 0x0093, sent|defwinproc|optional },
3639 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3640 { WM_MOVE, sent|defwinproc },
3641 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3642
3643 /* in MDI client */
3644 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3645 { WM_NCCALCSIZE, sent|wparam, 1 },
3646 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3647 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3648
3649 /* in MDI child */
3650 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3651 { WM_NCCALCSIZE, sent|wparam, 1 },
3652 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3653 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3654
3655 /* in MDI child */
3656 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3657 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3658 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3659 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3660
3661 /* in MDI frame */
3662 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3663 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3664 { 0x0093, sent|defwinproc|optional },
3665 { 0x0093, sent|defwinproc|optional },
3666 { 0x0093, sent|defwinproc|optional },
3667 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3668 { WM_MOVE, sent|defwinproc },
3669 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3670
3671 /* in MDI client */
3672 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3673 { WM_NCCALCSIZE, sent|wparam, 1 },
3674 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3675 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3676
3677 /* in MDI child */
3678 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
3679 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3680 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3681 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3682 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3683 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI client */
3684
3685 { 0x0093, sent|defwinproc|optional },
3686 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
3687 { 0x0093, sent|defwinproc|optional },
3688 { 0x0093, sent|defwinproc|optional },
3689 { 0x0093, sent|defwinproc|optional },
3690 { 0x0093, sent|optional },
3691
3692 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3693 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3694 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI client */
3695 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame */
3696 { 0x0093, sent|optional }, /* Win8+ sends an extra. */
3697 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
3698
3699 /* in MDI frame */
3700 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3701 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
3702 { 0x0093, sent|defwinproc|optional },
3703 { 0x0093, sent|defwinproc|optional },
3704 { 0x0093, sent|defwinproc|optional },
3705 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3706 { 0x0093, sent|optional }, /* Win8+ sends an extra. */
3707 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3708 { 0x0093, sent|optional },
3709
3710 { WM_NCACTIVATE, sent|wparam, 0 },
3711 { WM_MDIACTIVATE, sent },
3712
3713 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
3714 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
3715 { WM_NCCALCSIZE, sent|wparam, 1 },
3716
3717 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3718
3719 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3720 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3721 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3722
3723 /* in MDI child */
3724 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3725 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3726 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3727 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3728
3729 /* in MDI frame */
3730 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3731 { WM_NCCALCSIZE, sent|wparam, 1 },
3732 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3733 { WM_MOVE, sent|defwinproc },
3734 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3735
3736 /* in MDI client */
3737 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3738 { WM_NCCALCSIZE, sent|wparam, 1 },
3739 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
3740 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3741 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3742 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
3743 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI client */
3744 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3745 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
3746
3747 { HCBT_SETFOCUS, hook },
3748 { WM_KILLFOCUS, sent },
3749 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3750 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3751 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3752 { WM_SETFOCUS, sent }, /* in MDI client */
3753
3754 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
3755
3756 { HCBT_DESTROYWND, hook },
3757 /* Win2k sends wparam set to
3758 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
3759 * while Win9x doesn't bother to set child window id according to
3760 * CLIENTCREATESTRUCT.idFirstChild
3761 */
3762 { 0x0090, sent|optional },
3763 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
3764
3765 { WM_SHOWWINDOW, sent|wparam, 0 },
3766 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3767 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3768 { WM_ERASEBKGND, sent|parent|optional },
3769 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3770
3771 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3772 { WM_DESTROY, sent },
3773 { WM_NCDESTROY, sent },
3774 { 0 }
3775 };
3776 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
3777 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
3778 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3779 { WM_GETMINMAXINFO, sent },
3780 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3781 { WM_NCCALCSIZE, sent|wparam, 1 },
3782 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3783 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3784
3785 { WM_WINDOWPOSCHANGING, sent|wparam|optional|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3786 { WM_NCACTIVATE, sent|wparam|optional|defwinproc, 1 },
3787 { HCBT_SETFOCUS, hook|optional },
3788 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3789 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3790 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3791 { HCBT_SETFOCUS, hook|optional },
3792 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3793 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3794 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3795 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3796 { WM_SETFOCUS, sent|optional|defwinproc },
3797 { WM_MDIACTIVATE, sent|optional|defwinproc },
3798 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3799 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3800 /* in MDI frame */
3801 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3802 { WM_NCCALCSIZE, sent|wparam, 1 },
3803 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3804 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3805 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3806 { 0 }
3807 };
3808 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
3809 static const struct message WmMaximizeMDIchildInvisibleSeq2[] = {
3810 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3811 { WM_GETMINMAXINFO, sent },
3812 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED, 0, SWP_STATECHANGED /* w1064v1809 */ },
3813 { WM_GETMINMAXINFO, sent|defwinproc },
3814 { WM_NCCALCSIZE, sent|wparam, 1 },
3815 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3816 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3817
3818 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3819 { WM_NCACTIVATE, sent|wparam|defwinproc|optional, 1 },
3820 { HCBT_SETFOCUS, hook|optional },
3821 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
3822 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3823 { WM_SETFOCUS, sent|optional }, /* in MDI client */
3824 { HCBT_SETFOCUS, hook|optional },
3825 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
3826 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
3827 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3828 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3829 { WM_SETFOCUS, sent|defwinproc|optional },
3830 { WM_MDIACTIVATE, sent|defwinproc|optional },
3831 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_STATECHANGED /* w1064v1809 */ },
3832 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child, not sent on Win8+. */
3833 { WM_SIZE, sent|defwinproc|optional },
3834 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* w1064v1809. */
3835 { 0 }
3836 };
3837 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
3838 static const struct message WmMaximizeMDIchildInvisibleParentSeq[] = {
3839 { WM_MDIMAXIMIZE, sent }, /* in MDI client */
3840 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3841 { WM_GETMINMAXINFO, sent },
3842 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3843 { WM_GETMINMAXINFO, sent|defwinproc },
3844 { WM_NCCALCSIZE, sent|wparam, 1 },
3845 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP doesn't send it */
3846 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3847 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
3848 { WM_MOVE, sent|defwinproc },
3849 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3850
3851 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3852 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3853 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3854 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3855 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3856 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3857 /* in MDI frame */
3858 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3859 { WM_NCCALCSIZE, sent|wparam, 1 },
3860 { 0x0093, sent|defwinproc|optional },
3861 { 0x0094, sent|defwinproc|optional },
3862 { 0x0094, sent|defwinproc|optional },
3863 { 0x0094, sent|defwinproc|optional },
3864 { 0x0094, sent|defwinproc|optional },
3865 { 0x0093, sent|defwinproc|optional },
3866 { 0x0093, sent|defwinproc|optional },
3867 { 0x0091, sent|defwinproc|optional },
3868 { 0x0092, sent|defwinproc|optional },
3869 { 0x0092, sent|defwinproc|optional },
3870 { 0x0092, sent|defwinproc|optional },
3871 { 0x0092, sent|defwinproc|optional },
3872 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3873 { WM_MOVE, sent|defwinproc },
3874 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3875 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame win2000 */
3876 /* in MDI client */
3877 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
3878 { WM_NCCALCSIZE, sent|wparam, 1 },
3879 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3880 { WM_SIZE, sent|wparam, SIZE_RESTORED },
3881 /* in MDI child */
3882 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
3883 { WM_GETMINMAXINFO, sent|defwinproc },
3884 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
3885 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
3886 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3887 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child win2000 */
3888 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
3889 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3890 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3891 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
3892 /* in MDI frame */
3893 { 0x0093, sent|optional },
3894 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
3895 { 0x0093, sent|defwinproc|optional },
3896 { 0x0093, sent|defwinproc|optional },
3897 { 0x0093, sent|defwinproc|optional },
3898 { 0x0091, sent|defwinproc|optional },
3899 { 0x0092, sent|defwinproc|optional },
3900 { 0x0092, sent|defwinproc|optional },
3901 { 0x0092, sent|defwinproc|optional },
3902 { 0x0092, sent|defwinproc|optional },
3903 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3904 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
3905 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
3906 { 0 }
3907 };
3908 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
3909 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
3910 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
3911 { WM_GETMINMAXINFO, sent },
3912 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3913 { WM_NCCALCSIZE, sent|wparam, 1 },
3914 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3915 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3916 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
3917 /* in MDI frame */
3918 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3919 { WM_NCCALCSIZE, sent|wparam, 1 },
3920 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3921 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3922 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3923 { 0 }
3924 };
3925 /* ShowWindow(SW_RESTORE) for a visible maximized MDI child window */
3926 static const struct message WmRestoreMDIchildVisibleSeq[] = {
3927 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3928 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
3929 { WM_NCCALCSIZE, sent|wparam, 1 },
3930 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3931 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3932 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3933 /* in MDI frame */
3934 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3935 { WM_NCCALCSIZE, sent|wparam, 1 },
3936 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3937 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3938 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3939 { 0 }
3940 };
3941 /* ShowWindow(SW_RESTORE) for a visible minimized MDI child window */
3942 static const struct message WmRestoreMDIchildVisibleSeq_2[] = {
3943 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3944 { WM_QUERYOPEN, sent|wparam|lparam, 0, 0 },
3945 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3946 { WM_NCCALCSIZE, sent|wparam, 1 },
3947 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3948 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
3949 { WM_MOVE, sent|defwinproc },
3950 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3951 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3952 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3953 { HCBT_SETFOCUS, hook },
3954 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3955 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
3956 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
3957 { WM_SETFOCUS, sent },
3958 { 0 }
3959 };
3960 /* ShowWindow(SW_MINIMIZE) for a visible restored MDI child window */
3961 static const struct message WmMinimizeMDIchildVisibleSeq[] = {
3962 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
3963 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3964 { WM_NCCALCSIZE, sent|wparam, 1 },
3965 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
3966 { WM_MOVE, sent|defwinproc },
3967 { WM_SIZE, sent|defwinproc|wparam|lparam, SIZE_MINIMIZED, 0 },
3968 { WM_CHILDACTIVATE, sent|wparam|lparam|defwinproc, 0, 0 },
3969 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3970 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3971 /* FIXME: Wine creates an icon/title window while Windows doesn't */
3972 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE }, /* MDI client */
3973 { 0 }
3974 };
3975 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
3976 static const struct message WmRestoreMDIchildInvisibleSeq[] = {
3977 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
3978 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
3979 { WM_NCCALCSIZE, sent|wparam, 1 },
3980 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
3981 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
3982 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
3983 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
3984 /* in MDI frame */
3985 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
3986 { WM_NCCALCSIZE, sent|wparam, 1 },
3987 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
3988 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI frame */
3989 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* MDI child */
3990 { 0 }
3991 };
3992
3993 static HWND mdi_client;
3994 static WNDPROC old_mdi_client_proc;
3995
3996 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3997 {
3998 struct recvd_message msg;
3999
4000 /* do not log painting messages */
4001 if (message != WM_PAINT &&
4002 message != WM_NCPAINT &&
4003 message != WM_SYNCPAINT &&
4004 message != WM_ERASEBKGND &&
4005 message != WM_NCHITTEST &&
4006 message != WM_GETTEXT &&
4007 message != WM_MDIGETACTIVE &&
4008 !ignore_message( message ))
4009 {
4010 msg.hwnd = hwnd;
4011 msg.message = message;
4012 msg.flags = sent|wparam|lparam;
4013 msg.wParam = wParam;
4014 msg.lParam = lParam;
4015 msg.descr = "mdi client";
4016 add_message(&msg);
4017 }
4018
4019 return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
4020 }
4021
4022 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4023 {
4024 static LONG defwndproc_counter = 0;
4025 LRESULT ret;
4026 struct recvd_message msg;
4027
4028 /* do not log painting messages */
4029 if (message != WM_PAINT &&
4030 message != WM_NCPAINT &&
4031 message != WM_SYNCPAINT &&
4032 message != WM_ERASEBKGND &&
4033 message != WM_NCHITTEST &&
4034 message != WM_GETTEXT &&
4035 !ignore_message( message ))
4036 {
4037 switch (message)
4038 {
4039 case WM_MDIACTIVATE:
4040 {
4041 HWND active, client = GetParent(hwnd);
4042
4043 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
4044
4045 if (hwnd == (HWND)lParam) /* if we are being activated */
4046 ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
4047 else
4048 ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
4049 break;
4050 }
4051 }
4052
4053 msg.hwnd = hwnd;
4054 msg.message = message;
4055 msg.flags = sent|wparam|lparam;
4056 if (defwndproc_counter) msg.flags |= defwinproc;
4057 msg.wParam = wParam;
4058 msg.lParam = lParam;
4059 msg.descr = "mdi child";
4060 add_message(&msg);
4061 }
4062
4063 defwndproc_counter++;
4064 ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
4065 defwndproc_counter--;
4066
4067 return ret;
4068 }
4069
4070 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4071 {
4072 static LONG defwndproc_counter = 0;
4073 LRESULT ret;
4074 struct recvd_message msg;
4075
4076 /* do not log painting messages */
4077 if (message != WM_PAINT &&
4078 message != WM_NCPAINT &&
4079 message != WM_SYNCPAINT &&
4080 message != WM_ERASEBKGND &&
4081 message != WM_NCHITTEST &&
4082 message != WM_GETTEXT &&
4083 !ignore_message( message ))
4084 {
4085 msg.hwnd = hwnd;
4086 msg.message = message;
4087 msg.flags = sent|wparam|lparam;
4088 if (defwndproc_counter) msg.flags |= defwinproc;
4089 msg.wParam = wParam;
4090 msg.lParam = lParam;
4091 msg.descr = "mdi frame";
4092 add_message(&msg);
4093 }
4094
4095 defwndproc_counter++;
4096 ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
4097 defwndproc_counter--;
4098
4099 return ret;
4100 }
4101
4102 static BOOL mdi_RegisterWindowClasses(void)
4103 {
4104 WNDCLASSA cls;
4105
4106 cls.style = 0;
4107 cls.lpfnWndProc = mdi_frame_wnd_proc;
4108 cls.cbClsExtra = 0;
4109 cls.cbWndExtra = 0;
4110 cls.hInstance = GetModuleHandleA(0);
4111 cls.hIcon = 0;
4112 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
4113 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
4114 cls.lpszMenuName = NULL;
4115 cls.lpszClassName = "MDI_frame_class";
4116 if (!RegisterClassA(&cls)) return FALSE;
4117
4118 cls.lpfnWndProc = mdi_child_wnd_proc;
4119 cls.lpszClassName = "MDI_child_class";
4120 if (!RegisterClassA(&cls)) return FALSE;
4121
4122 if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
4123 old_mdi_client_proc = cls.lpfnWndProc;
4124 cls.hInstance = GetModuleHandleA(0);
4125 cls.lpfnWndProc = mdi_client_hook_proc;
4126 cls.lpszClassName = "MDI_client_class";
4127 if (!RegisterClassA(&cls)) assert(0);
4128
4129 return TRUE;
4130 }
4131
4132 static void test_mdi_messages(void)
4133 {
4134 MDICREATESTRUCTA mdi_cs;
4135 CLIENTCREATESTRUCT client_cs;
4136 HWND mdi_frame, mdi_child, mdi_child2, active_child;
4137 BOOL zoomed;
4138 RECT rc;
4139 HMENU hMenu = CreateMenu();
4140 LONG val;
4141
4142 if (!mdi_RegisterWindowClasses()) assert(0);
4143
4144 flush_sequence();
4145
4146 if (winetest_debug > 1) trace("creating MDI frame window\n");
4147 mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
4148 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
4149 WS_MAXIMIZEBOX | WS_VISIBLE,
4150 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
4151 GetDesktopWindow(), hMenu,
4152 GetModuleHandleA(0), NULL);
4153 assert(mdi_frame);
4154 ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
4155
4156 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4157 ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
4158
4159 if (winetest_debug > 1) trace("creating MDI client window\n");
4160 GetClientRect(mdi_frame, &rc);
4161 client_cs.hWindowMenu = 0;
4162 client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
4163 mdi_client = CreateWindowExA(0, "MDI_client_class",
4164 NULL,
4165 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
4166 rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
4167 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
4168 assert(mdi_client);
4169 SetWindowLongA(mdi_client, 0, 0xdeadbeef);
4170
4171 ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
4172 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4173 ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
4174
4175 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4176 ok(!active_child, "wrong active MDI child %p\n", active_child);
4177 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4178
4179 SetFocus(0);
4180 flush_sequence();
4181
4182 if (winetest_debug > 1) trace("creating invisible MDI child window\n");
4183 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4184 WS_CHILD,
4185 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4186 mdi_client, 0, GetModuleHandleA(0), NULL);
4187 assert(mdi_child);
4188
4189 flush_sequence();
4190 ShowWindow(mdi_child, SW_SHOWNORMAL);
4191 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
4192
4193 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
4194 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
4195
4196 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4197 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4198
4199 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4200 ok(!active_child, "wrong active MDI child %p\n", active_child);
4201 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4202
4203 ShowWindow(mdi_child, SW_HIDE);
4204 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
4205 flush_sequence();
4206
4207 ShowWindow(mdi_child, SW_SHOW);
4208 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
4209
4210 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
4211 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
4212
4213 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4214 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4215
4216 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4217 ok(!active_child, "wrong active MDI child %p\n", active_child);
4218 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4219
4220 DestroyWindow(mdi_child);
4221 flush_sequence();
4222
4223 if (winetest_debug > 1) trace("creating visible MDI child window\n");
4224 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4225 WS_CHILD | WS_VISIBLE,
4226 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4227 mdi_client, 0, GetModuleHandleA(0), NULL);
4228 assert(mdi_child);
4229 ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
4230
4231 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
4232 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
4233
4234 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4235 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
4236
4237 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4238 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
4239 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4240 flush_sequence();
4241
4242 DestroyWindow(mdi_child);
4243 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
4244
4245 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4246 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4247
4248 /* Win2k: MDI client still returns a just destroyed child as active
4249 * Win9x: MDI client returns 0
4250 */
4251 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4252 ok(active_child == mdi_child || /* win2k */
4253 !active_child, /* win9x */
4254 "wrong active MDI child %p\n", active_child);
4255 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4256
4257 flush_sequence();
4258
4259 if (winetest_debug > 1) trace("creating invisible MDI child window\n");
4260 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4261 WS_CHILD,
4262 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4263 mdi_client, 0, GetModuleHandleA(0), NULL);
4264 assert(mdi_child2);
4265 ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
4266
4267 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
4268 ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
4269
4270 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4271 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4272
4273 /* Win2k: MDI client still returns a just destroyed child as active
4274 * Win9x: MDI client returns mdi_child2
4275 */
4276 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4277 ok(active_child == mdi_child || /* win2k */
4278 active_child == mdi_child2, /* win9x */
4279 "wrong active MDI child %p\n", active_child);
4280 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4281 flush_sequence();
4282
4283 ShowWindow(mdi_child2, SW_MAXIMIZE);
4284 ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
4285
4286 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
4287 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
4288
4289 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4290 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4291 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4292 flush_sequence();
4293
4294 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4295 ok(GetFocus() == mdi_child2 || /* win2k */
4296 GetFocus() == 0, /* win9x */
4297 "wrong focus window %p\n", GetFocus());
4298
4299 SetFocus(0);
4300 flush_sequence();
4301
4302 ShowWindow(mdi_child2, SW_HIDE);
4303 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
4304
4305 ShowWindow(mdi_child2, SW_RESTORE);
4306 ok_sequence(WmRestoreMDIchildInvisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
4307 flush_sequence();
4308
4309 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
4310 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
4311
4312 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4313 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4314 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4315 flush_sequence();
4316
4317 SetFocus(0);
4318 flush_sequence();
4319
4320 ShowWindow(mdi_child2, SW_HIDE);
4321 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
4322
4323 ShowWindow(mdi_child2, SW_SHOW);
4324 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
4325
4326 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4327 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4328
4329 ShowWindow(mdi_child2, SW_MAXIMIZE);
4330 ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
4331
4332 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4333 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4334
4335 ShowWindow(mdi_child2, SW_RESTORE);
4336 ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
4337
4338 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4339 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4340
4341 ShowWindow(mdi_child2, SW_MINIMIZE);
4342 ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", FALSE);
4343
4344 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4345 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4346
4347 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4348 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4349 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4350 flush_sequence();
4351
4352 ShowWindow(mdi_child2, SW_RESTORE);
4353 ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", FALSE);
4354
4355 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4356 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
4357
4358 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4359 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4360 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4361 flush_sequence();
4362
4363 SetFocus(0);
4364 flush_sequence();
4365
4366 ShowWindow(mdi_child2, SW_HIDE);
4367 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
4368
4369 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4370 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4371
4372 DestroyWindow(mdi_child2);
4373 ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
4374
4375 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4376 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4377
4378 if (winetest_debug > 1) trace("Testing WM_CHILDACTIVATE\n");
4379
4380 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4381 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_DISABLED,
4382 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4383 mdi_client, 0, GetModuleHandleA(0), NULL);
4384
4385 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4386 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX,
4387 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4388 mdi_client, 0, GetModuleHandleA(0), NULL);
4389
4390 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4391 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4392 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4393
4394 flush_sequence();
4395 SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
4396 ok_sequence(WmChildActivateDisabledWindowSeq, "WM_CHILDACTIVATE sent to disabled window", FALSE);
4397
4398 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4399 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4400 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4401 flush_sequence();
4402
4403 EnableWindow(mdi_child, TRUE);
4404
4405 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4406 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4407 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4408
4409 flush_sequence();
4410 SendMessageW(mdi_child, WM_CHILDACTIVATE, 0, 0);
4411 ok_sequence(WmChildActivateWindowSeq, "WM_CHILDACTIVATE sent to enabled window", FALSE);
4412
4413 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4414 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
4415 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
4416 flush_sequence();
4417
4418 DestroyWindow(mdi_child);
4419 DestroyWindow(mdi_child2);
4420 flush_sequence();
4421
4422 /* test for maximized MDI children */
4423 if (winetest_debug > 1) trace("creating maximized visible MDI child window 1\n");
4424 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4425 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
4426 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4427 mdi_client, 0, GetModuleHandleA(0), NULL);
4428 assert(mdi_child);
4429 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
4430 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
4431
4432 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4433 ok(GetFocus() == mdi_child || /* win2k */
4434 GetFocus() == 0, /* win9x */
4435 "wrong focus window %p\n", GetFocus());
4436
4437 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4438 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
4439 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4440 flush_sequence();
4441
4442 if (winetest_debug > 1) trace("creating maximized visible MDI child window 2\n");
4443 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4444 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
4445 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4446 mdi_client, 0, GetModuleHandleA(0), NULL);
4447 assert(mdi_child2);
4448 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
4449 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
4450 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
4451
4452 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4453 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
4454
4455 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4456 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4457 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4458 flush_sequence();
4459
4460 if (winetest_debug > 1) trace("destroying maximized visible MDI child window 2\n");
4461 DestroyWindow(mdi_child2);
4462 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
4463
4464 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
4465
4466 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4467 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4468
4469 /* Win2k: MDI client still returns a just destroyed child as active
4470 * Win9x: MDI client returns 0
4471 */
4472 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4473 ok(active_child == mdi_child2 || /* win2k */
4474 !active_child, /* win9x */
4475 "wrong active MDI child %p\n", active_child);
4476 flush_sequence();
4477
4478 ShowWindow(mdi_child, SW_MAXIMIZE);
4479 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
4480 flush_sequence();
4481
4482 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4483 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
4484
4485 if (winetest_debug > 1) trace("re-creating maximized visible MDI child window 2\n");
4486 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4487 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
4488 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4489 mdi_client, 0, GetModuleHandleA(0), NULL);
4490 assert(mdi_child2);
4491 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
4492 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
4493 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
4494
4495 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4496 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
4497
4498 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4499 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4500 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4501 flush_sequence();
4502
4503 SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
4504 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
4505 ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
4506
4507 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
4508 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4509 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
4510
4511 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4512 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
4513 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4514 flush_sequence();
4515
4516 DestroyWindow(mdi_child);
4517 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
4518
4519 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4520 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
4521
4522 /* Win2k: MDI client still returns a just destroyed child as active
4523 * Win9x: MDI client returns 0
4524 */
4525 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4526 ok(active_child == mdi_child || /* win2k */
4527 !active_child, /* win9x */
4528 "wrong active MDI child %p\n", active_child);
4529 flush_sequence();
4530
4531 if (winetest_debug > 1) trace("creating maximized invisible MDI child window\n");
4532 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4533 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
4534 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4535 mdi_client, 0, GetModuleHandleA(0), NULL);
4536 assert(mdi_child2);
4537 ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", FALSE);
4538 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
4539 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
4540 ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
4541
4542 /* Win2k: MDI client still returns a just destroyed child as active
4543 * Win9x: MDI client returns 0
4544 */
4545 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4546 ok(active_child == mdi_child || /* win2k */
4547 !active_child || active_child == mdi_child2, /* win9x */
4548 "wrong active MDI child %p\n", active_child);
4549 flush_sequence();
4550
4551 if (winetest_debug > 1) trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
4552 ShowWindow(mdi_child2, SW_MAXIMIZE);
4553 ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
4554 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
4555 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
4556 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
4557
4558 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4559 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
4560 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4561 flush_sequence();
4562
4563 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
4564 flush_sequence();
4565
4566 /* end of test for maximized MDI children */
4567 SetFocus(0);
4568 flush_sequence();
4569 if (winetest_debug > 1) trace("creating maximized visible MDI child window 1(Switch test)\n");
4570 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4571 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
4572 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4573 mdi_client, 0, GetModuleHandleA(0), NULL);
4574 assert(mdi_child);
4575 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
4576 ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
4577
4578 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
4579 ok(GetFocus() == mdi_child || /* win2k */
4580 GetFocus() == 0, /* win9x */
4581 "wrong focus window %p(Switch test)\n", GetFocus());
4582
4583 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4584 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
4585 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
4586 flush_sequence();
4587
4588 if (winetest_debug > 1) trace("creating maximized visible MDI child window 2(Switch test)\n");
4589 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4590 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
4591 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
4592 mdi_client, 0, GetModuleHandleA(0), NULL);
4593 assert(mdi_child2);
4594 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child window (Switch test)", TRUE);
4595
4596 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
4597 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
4598
4599 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
4600 ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
4601
4602 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4603 ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
4604 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
4605 flush_sequence();
4606
4607 if (winetest_debug > 1) trace("Switch child window.\n");
4608 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
4609 ok_sequence(WmSwitchChild, "Child did not switch correctly", TRUE);
4610 if (winetest_debug > 1) trace("end of test for switch maximized MDI children\n");
4611 flush_sequence();
4612
4613 /* Prepare for switching test of not maximized MDI children */
4614 ShowWindow( mdi_child, SW_NORMAL );
4615 ok(!IsZoomed(mdi_child), "wrong zoomed state for %p(Switch test)\n", mdi_child);
4616 ok(!IsZoomed(mdi_child2), "wrong zoomed state for %p(Switch test)\n", mdi_child2);
4617 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, 0);
4618 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
4619 flush_sequence();
4620
4621 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child2, 0);
4622 ok_sequence(WmSwitchNotMaximizedChild, "Not maximized child did not switch correctly", FALSE);
4623 if (winetest_debug > 1) trace("end of test for switch not maximized MDI children\n");
4624 flush_sequence();
4625
4626 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
4627 flush_sequence();
4628
4629 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
4630 flush_sequence();
4631
4632 SetFocus(0);
4633 flush_sequence();
4634 /* end of tests for switch maximized/not maximized MDI children */
4635
4636 mdi_cs.szClass = "MDI_child_Class";
4637 mdi_cs.szTitle = "MDI child";
4638 mdi_cs.hOwner = GetModuleHandleA(0);
4639 mdi_cs.x = 0;
4640 mdi_cs.y = 0;
4641 mdi_cs.cx = CW_USEDEFAULT;
4642 mdi_cs.cy = CW_USEDEFAULT;
4643 mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
4644 mdi_cs.lParam = 0;
4645 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
4646 ok(mdi_child != 0, "MDI child creation failed\n");
4647 ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
4648
4649 ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
4650
4651 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4652 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
4653
4654 ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
4655 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
4656 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
4657
4658 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4659 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
4660 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4661 flush_sequence();
4662
4663 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
4664 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
4665
4666 ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
4667 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
4668 ok(!active_child, "wrong active MDI child %p\n", active_child);
4669
4670 SetFocus(0);
4671 flush_sequence();
4672
4673 val = GetWindowLongA(mdi_client, 0);
4674 ok(val == 0xdeadbeef || broken(val == 0) /* >= Win Vista */, "Expected 0xdeadbeef, got 0x%lx\n", val);
4675 DestroyWindow(mdi_client);
4676 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
4677
4678 /* test maximization of MDI child with invisible parent */
4679 client_cs.hWindowMenu = 0;
4680 mdi_client = CreateWindowA("MDI_client_class",
4681 NULL,
4682 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
4683 0, 0, 660, 430,
4684 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
4685 ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
4686
4687 ShowWindow(mdi_client, SW_HIDE);
4688 ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
4689
4690 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
4691 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
4692 0, 0, 650, 440,
4693 mdi_client, 0, GetModuleHandleA(0), NULL);
4694 ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
4695
4696 SendMessageA(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
4697 ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
4698 zoomed = IsZoomed(mdi_child);
4699 ok(zoomed, "wrong zoomed state %d\n", zoomed);
4700
4701 ShowWindow(mdi_client, SW_SHOW);
4702 ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
4703
4704 DestroyWindow(mdi_child);
4705 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
4706
4707 /* end of test for maximization of MDI child with invisible parent */
4708
4709 DestroyWindow(mdi_client);
4710 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
4711
4712 DestroyWindow(mdi_frame);
4713 ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
4714 }
4715 /************************* End of MDI test **********************************/
4716
4717 static void test_WM_SETREDRAW(HWND hwnd)
4718 {
4719 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
4720
4721 flush_events();
4722 flush_sequence();
4723
4724 SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
4725 ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
4726
4727 ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
4728 ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
4729
4730 flush_sequence();
4731 SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
4732 ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
4733
4734 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4735 ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
4736
4737 /* restore original WS_VISIBLE state */
4738 SetWindowLongA(hwnd, GWL_STYLE, style);
4739
4740 flush_events();
4741 flush_sequence();
4742 }
4743
4744 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4745 {
4746 struct recvd_message msg;
4747
4748 if (ignore_message( message )) return 0;
4749
4750 switch (message)
4751 {
4752 /* ignore */
4753 case WM_MOUSEMOVE:
4754 case WM_NCMOUSEMOVE:
4755 case WM_NCMOUSELEAVE:
4756 case WM_SETCURSOR:
4757 return 0;
4758 case WM_NCHITTEST:
4759 return HTCLIENT;
4760 }
4761
4762 msg.hwnd = hwnd;
4763 msg.message = message;
4764 msg.flags = sent|wparam|lparam;
4765 msg.wParam = wParam;
4766 msg.lParam = lParam;
4767 msg.descr = "dialog";
4768 add_message(&msg);
4769
4770 if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
4771 if (message == WM_TIMER) EndDialog( hwnd, 0 );
4772 return 0;
4773 }
4774
4775 static INT_PTR CALLBACK TestModalDlgProc2(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4776 {
4777 struct recvd_message msg;
4778
4779 if (ignore_message( message )) return 0;
4780
4781 switch (message)
4782 {
4783 /* ignore */
4784 case WM_MOUSEMOVE:
4785 case WM_NCMOUSEMOVE:
4786 case WM_NCMOUSELEAVE:
4787 case WM_SETCURSOR:
4788 return 0;
4789 case WM_NCHITTEST:
4790 return HTCLIENT;
4791 }
4792
4793 msg.hwnd = hwnd;
4794 msg.message = message;
4795 msg.flags = sent|wparam|lparam;
4796 msg.wParam = wParam;
4797 msg.lParam = lParam;
4798 msg.descr = "dialog";
4799 add_message(&msg);
4800
4801 if (message == WM_INITDIALOG) EndDialog( hwnd, 0 );
4802 return 0;
4803 }
4804
4805 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
4806 {
4807 DWORD style, exstyle;
4808 INT xmin, xmax;
4809 BOOL ret;
4810
4811 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
4812 style = GetWindowLongA(hwnd, GWL_STYLE);
4813 /* do not be confused by WS_DLGFRAME set */
4814 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
4815
4816 if (clear) ok(style & clear, "style %08lx should be set\n", clear);
4817 if (set) ok(!(style & set), "style %08lx should not be set\n", set);
4818
4819 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
4820 ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
4821 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
4822 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
4823 else
4824 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
4825
4826 style = GetWindowLongA(hwnd, GWL_STYLE);
4827 if (set) ok(style & set, "style %08lx should be set\n", set);
4828 if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
4829
4830 /* a subsequent call should do nothing */
4831 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
4832 ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
4833 ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4834
4835 xmin = 0xdeadbeef;
4836 xmax = 0xdeadbeef;
4837 ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
4838 ok( ret, "GetScrollRange(%d) error %ld\n", ctl, GetLastError());
4839 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4840 ok(xmin == min, "unexpected min scroll value %d\n", xmin);
4841 ok(xmax == max, "unexpected max scroll value %d\n", xmax);
4842 }
4843
4844 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
4845 {
4846 DWORD style, exstyle;
4847 SCROLLINFO si;
4848 BOOL ret;
4849
4850 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
4851 style = GetWindowLongA(hwnd, GWL_STYLE);
4852 /* do not be confused by WS_DLGFRAME set */
4853 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
4854
4855 if (clear) ok(style & clear, "style %08lx should be set\n", clear);
4856 if (set) ok(!(style & set), "style %08lx should not be set\n", set);
4857
4858 si.cbSize = sizeof(si);
4859 si.fMask = SIF_RANGE;
4860 si.nMin = min;
4861 si.nMax = max;
4862 SetScrollInfo(hwnd, ctl, &si, TRUE);
4863 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
4864 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
4865 else
4866 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
4867
4868 style = GetWindowLongA(hwnd, GWL_STYLE);
4869 if (set) ok(style & set, "style %08lx should be set\n", set);
4870 if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
4871
4872 /* a subsequent call should do nothing */
4873 SetScrollInfo(hwnd, ctl, &si, TRUE);
4874 if (style & WS_HSCROLL)
4875 ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4876 else if (style & WS_VSCROLL)
4877 ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4878 else
4879 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4880
4881 si.fMask = SIF_PAGE;
4882 si.nPage = 5;
4883 SetScrollInfo(hwnd, ctl, &si, FALSE);
4884 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4885
4886 si.fMask = SIF_POS;
4887 si.nPos = max - 1;
4888 SetScrollInfo(hwnd, ctl, &si, FALSE);
4889 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
4890
4891 si.fMask = SIF_RANGE;
4892 si.nMin = 0xdeadbeef;
4893 si.nMax = 0xdeadbeef;
4894 ret = GetScrollInfo(hwnd, ctl, &si);
4895 ok( ret, "GetScrollInfo error %ld\n", GetLastError());
4896 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
4897 ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
4898 ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
4899 }
4900
4901 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
4902 static void test_scroll_messages(HWND hwnd)
4903 {
4904 SCROLLINFO si;
4905 INT min, max;
4906 BOOL ret;
4907
4908 flush_events();
4909 flush_sequence();
4910
4911 min = 0xdeadbeef;
4912 max = 0xdeadbeef;
4913 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4914 ok( ret, "GetScrollRange error %ld\n", GetLastError());
4915 if (sequence->message != WmGetScrollRangeSeq[0].message)
4916 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4917 /* values of min and max are undefined */
4918 flush_sequence();
4919
4920 ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
4921 ok( ret, "SetScrollRange error %ld\n", GetLastError());
4922 if (sequence->message != WmSetScrollRangeSeq[0].message)
4923 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4924 flush_sequence();
4925
4926 min = 0xdeadbeef;
4927 max = 0xdeadbeef;
4928 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
4929 ok( ret, "GetScrollRange error %ld\n", GetLastError());
4930 if (sequence->message != WmGetScrollRangeSeq[0].message)
4931 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
4932 /* values of min and max are undefined */
4933 flush_sequence();
4934
4935 si.cbSize = sizeof(si);
4936 si.fMask = SIF_RANGE;
4937 si.nMin = 20;
4938 si.nMax = 160;
4939 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4940 if (sequence->message != WmSetScrollRangeSeq[0].message)
4941 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4942 flush_sequence();
4943
4944 si.fMask = SIF_PAGE;
4945 si.nPage = 10;
4946 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4947 if (sequence->message != WmSetScrollRangeSeq[0].message)
4948 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4949 flush_sequence();
4950
4951 si.fMask = SIF_POS;
4952 si.nPos = 20;
4953 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
4954 if (sequence->message != WmSetScrollRangeSeq[0].message)
4955 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4956 flush_sequence();
4957
4958 si.fMask = SIF_RANGE;
4959 si.nMin = 0xdeadbeef;
4960 si.nMax = 0xdeadbeef;
4961 ret = GetScrollInfo(hwnd, SB_CTL, &si);
4962 ok( ret, "GetScrollInfo error %ld\n", GetLastError());
4963 if (sequence->message != WmGetScrollInfoSeq[0].message)
4964 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
4965 /* values of min and max are undefined */
4966 flush_sequence();
4967
4968 /* set WS_HSCROLL */
4969 test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4970 /* clear WS_HSCROLL */
4971 test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4972
4973 /* set WS_HSCROLL */
4974 test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
4975 /* clear WS_HSCROLL */
4976 test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
4977
4978 /* set WS_VSCROLL */
4979 test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4980 /* clear WS_VSCROLL */
4981 test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4982
4983 /* set WS_VSCROLL */
4984 test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
4985 /* clear WS_VSCROLL */
4986 test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
4987 }
4988
4989 static void test_showwindow(void)
4990 {
4991 HWND hwnd, hwnd2, hchild;
4992 RECT rc;
4993
4994 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4995 100, 100, 200, 200, 0, 0, 0, NULL);
4996 ok (hwnd != 0, "Failed to create overlapped window\n");
4997 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4998 0, 0, 10, 10, hwnd, 0, 0, NULL);
4999 ok (hchild != 0, "Failed to create child\n");
5000 flush_sequence();
5001
5002 /* ShowWindow( SW_SHOWNA) for invisible top level window */
5003 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
5004 ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
5005 ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", FALSE);
5006
5007 /* ShowWindow( SW_SHOWNA) for now visible top level window */
5008 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
5009 ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
5010 ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
5011 /* back to invisible */
5012 ShowWindow(hchild, SW_HIDE);
5013 ShowWindow(hwnd, SW_HIDE);
5014 flush_sequence();
5015 /* ShowWindow(SW_SHOWNA) with child and parent invisible */
5016 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
5017 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
5018 ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
5019 /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
5020 ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
5021 flush_sequence();
5022 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
5023 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
5024 ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
5025 /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
5026 ShowWindow( hwnd, SW_SHOW);
5027 flush_sequence();
5028 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
5029 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
5030 ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
5031
5032 /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
5033 ShowWindow( hchild, SW_HIDE);
5034 flush_sequence();
5035 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
5036 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
5037 ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
5038
5039 SetCapture(hchild);
5040 ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
5041 DestroyWindow(hchild);
5042 ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
5043
5044 DestroyWindow(hwnd);
5045 flush_sequence();
5046
5047 /* Popup windows */
5048 /* Test 1:
5049 * 1. Create invisible maximized popup window.
5050 * 2. Move and resize it.
5051 * 3. Show it maximized.
5052 */
5053 if (winetest_debug > 1) trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
5054 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
5055 100, 100, 200, 200, 0, 0, 0, NULL);
5056 ok (hwnd != 0, "Failed to create popup window\n");
5057 ok(IsZoomed(hwnd), "window should be maximized\n");
5058 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
5059
5060 GetWindowRect(hwnd, &rc);
5061 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
5062 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
5063 "Invalid maximized size before ShowWindow %s\n", wine_dbgstr_rect( &rc ));
5064 /* Reset window's size & position */
5065 SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
5066 ok(IsZoomed(hwnd), "window should be maximized\n");
5067 flush_sequence();
5068
5069 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
5070 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
5071 ok(IsZoomed(hwnd), "window should be maximized\n");
5072 ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE);
5073
5074 GetWindowRect(hwnd, &rc);
5075 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
5076 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
5077 "Invalid maximized size after ShowWindow %s\n", wine_dbgstr_rect( &rc ));
5078 DestroyWindow(hwnd);
5079 flush_sequence();
5080
5081 /* Test 2:
5082 * 1. Create invisible maximized popup window.
5083 * 2. Show it maximized.
5084 */
5085 if (winetest_debug > 1) trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
5086 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
5087 100, 100, 200, 200, 0, 0, 0, NULL);
5088 ok (hwnd != 0, "Failed to create popup window\n");
5089 ok(IsZoomed(hwnd), "window should be maximized\n");
5090 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
5091
5092 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
5093 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
5094 ok(IsZoomed(hwnd), "window should be maximized\n");
5095 ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE);
5096 DestroyWindow(hwnd);
5097 flush_sequence();
5098
5099 /* Test 3:
5100 * 1. Create visible maximized popup window.
5101 */
5102 if (winetest_debug > 1) trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
5103 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
5104 100, 100, 200, 200, 0, 0, 0, NULL);
5105 ok (hwnd != 0, "Failed to create popup window\n");
5106 ok(IsZoomed(hwnd), "window should be maximized\n");
5107 ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
5108 DestroyWindow(hwnd);
5109 flush_sequence();
5110
5111 /* Test 4:
5112 * 1. Create visible popup window.
5113 * 2. Maximize it.
5114 */
5115 if (winetest_debug > 1) trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
5116 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
5117 100, 100, 200, 200, 0, 0, 0, NULL);
5118 ok (hwnd != 0, "Failed to create popup window\n");
5119 ok(!IsZoomed(hwnd), "window should NOT be maximized\n");
5120 ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", FALSE);
5121
5122 if (winetest_debug > 1) trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
5123 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
5124 ok(IsZoomed(hwnd), "window should be maximized\n");
5125 ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
5126 DestroyWindow(hwnd);
5127 flush_sequence();
5128
5129 /* Test 5:
5130 * 1. Restoring a minimized window.
5131 */
5132 hwnd = CreateWindowA("TestWindowClass", "window1", WS_VISIBLE | WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0);
5133 ok(hwnd != NULL, "Failed to create window\n");
5134
5135 hwnd2 = CreateWindowA("static", "window2", WS_VISIBLE | WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0);
5136 ok(hwnd2 != NULL, "Failed to create window\n");
5137
5138 ShowWindow(hwnd, SW_MINIMIZE);
5139 SetActiveWindow(hwnd2);
5140 ok(GetActiveWindow() == hwnd2, "Unexpected active window\n");
5141 flush_events();
5142 flush_sequence();
5143 ShowWindow(hwnd, SW_RESTORE);
5144 flush_events();
5145 ok_sequence(WmShowRestoreMinimizedOverlappedSeq,
5146 "ShowWindow(hwnd, SW_RESTORE): minimized overlapped", TRUE);
5147
5148 ShowWindow(hwnd, SW_MINIMIZE);
5149 SetActiveWindow(hwnd2);
5150 ok(GetActiveWindow() == hwnd2, "Unexpected active window\n");
5151 flush_events();
5152 flush_sequence();
5153 ShowWindow(hwnd, SW_SHOWNOACTIVATE);
5154 flush_events();
5155 ok_sequence(WmShowNoActivateMinimizedOverlappedSeq,
5156 "ShowWindow(hwnd, SW_SHOWNOACTIVATE): minimized overlapped", TRUE);
5157
5158 DestroyWindow(hwnd2);
5159 DestroyWindow(hwnd);
5160 flush_sequence();
5161
5162 /* Test 6:
5163 * 1. Restoring a minimized but active window.
5164 */
5165 hwnd = CreateWindowA("TestWindowClass", "parent", WS_VISIBLE | WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0);
5166 ok(hwnd != NULL, "Failed to create window\n");
5167
5168 ShowWindow(hwnd, SW_MINIMIZE);
5169 SetActiveWindow(hwnd);
5170 ok(GetActiveWindow() == hwnd, "Unexpected active window\n");
5171 flush_events();
5172 flush_sequence();
5173 ShowWindow(hwnd, SW_RESTORE);
5174 flush_events();
5175 ok_sequence(WmShowRestoreActiveMinimizedOverlappedSeq,
5176 "ShowWindow(hwnd, SW_RESTORE): active minimized overlapped", TRUE);
5177
5178 ShowWindow(hwnd, SW_MINIMIZE);
5179 SetActiveWindow(hwnd);
5180 ok(GetActiveWindow() == hwnd, "Unexpected active window\n");
5181 flush_events();
5182 flush_sequence();
5183 ShowWindow(hwnd, SW_SHOWNOACTIVATE);
5184 flush_events();
5185 ok_sequence(WmShowNoActivateActiveMinimizedOverlappedSeq,
5186 "ShowWindow(hwnd, SW_SHOWNOACTIVATE): active minimized overlapped", TRUE);
5187
5188 DestroyWindow(hwnd);
5189 flush_sequence();
5190 }
5191
5192 static void test_sys_menu(void)
5193 {
5194 HWND hwnd;
5195 HMENU hmenu;
5196 UINT state;
5197
5198 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
5199 100, 100, 200, 200, 0, 0, 0, NULL);
5200 ok (hwnd != 0, "Failed to create overlapped window\n");
5201
5202 flush_sequence();
5203
5204 /* test existing window without CS_NOCLOSE style */
5205 hmenu = GetSystemMenu(hwnd, FALSE);
5206 ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
5207
5208 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
5209 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
5210 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
5211
5212 EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
5213 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
5214
5215 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
5216 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
5217 ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
5218
5219 EnableMenuItem(hmenu, SC_CLOSE, 0);
5220 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
5221
5222 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
5223 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
5224 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
5225
5226 /* test whether removing WS_SYSMENU destroys a system menu */
5227 SetWindowLongW(hwnd, GWL_STYLE, WS_POPUP);
5228 SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
5229 flush_sequence();
5230 hmenu = GetSystemMenu(hwnd, FALSE);
5231 ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
5232
5233 DestroyWindow(hwnd);
5234
5235 /* test new window with CS_NOCLOSE style */
5236 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
5237 100, 100, 200, 200, 0, 0, 0, NULL);
5238 ok (hwnd != 0, "Failed to create overlapped window\n");
5239
5240 hmenu = GetSystemMenu(hwnd, FALSE);
5241 ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
5242
5243 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
5244 ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
5245
5246 DestroyWindow(hwnd);
5247
5248 /* test new window without WS_SYSMENU style */
5249 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU,
5250 100, 100, 200, 200, 0, 0, 0, NULL);
5251 ok(hwnd != 0, "Failed to create overlapped window\n");
5252
5253 hmenu = GetSystemMenu(hwnd, FALSE);
5254 ok(!hmenu, "GetSystemMenu error %ld\n", GetLastError());
5255
5256 DestroyWindow(hwnd);
5257 }
5258
5259 /* For shown WS_OVERLAPPEDWINDOW */
5260 static const struct message WmSetIcon_1[] = {
5261 { WM_SETICON, sent },
5262 { 0x00AE, sent|defwinproc|optional }, /* XP */
5263 { WM_GETTEXT, sent|defwinproc|optional },
5264 { WM_GETTEXT, sent|defwinproc|optional }, /* XP sends a duplicate */
5265 { 0 }
5266 };
5267
5268 /* For WS_POPUP and hidden WS_OVERLAPPEDWINDOW */
5269 static const struct message WmSetIcon_2[] = {
5270 { WM_SETICON, sent },
5271 { 0 }
5272 };
5273
5274 /* Sending undocumented 0x3B message with wparam = 0x8000000b */
5275 static const struct message WmInitEndSession[] = {
5276 { 0x003B, sent },
5277 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
5278 { 0 }
5279 };
5280
5281 /* Sending undocumented 0x3B message with wparam = 0x0000000b */
5282 static const struct message WmInitEndSession_2[] = {
5283 { 0x003B, sent },
5284 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
5285 { 0 }
5286 };
5287
5288 /* Sending undocumented 0x3B message with wparam = 0x80000008 */
5289 static const struct message WmInitEndSession_3[] = {
5290 { 0x003B, sent },
5291 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
5292 { 0 }
5293 };
5294
5295 /* Sending undocumented 0x3B message with wparam = 0x00000008 */
5296 static const struct message WmInitEndSession_4[] = {
5297 { 0x003B, sent },
5298 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
5299 { 0 }
5300 };
5301
5302 /* Sending undocumented 0x3B message with wparam = 0x80000001 */
5303 static const struct message WmInitEndSession_5[] = {
5304 { 0x003B, sent },
5305 { WM_ENDSESSION, sent|defwinproc/*|wparam*/|lparam, 1, ENDSESSION_LOGOFF },
5306 { 0 }
5307 };
5308
5309 static const struct message WmOptionalPaint[] = {
5310 { WM_PAINT, sent|optional },
5311 { WM_NCPAINT, sent|beginpaint|optional },
5312 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5313 { WM_ERASEBKGND, sent|beginpaint|optional },
5314 { 0 }
5315 };
5316
5317 static const struct message WmZOrder[] = {
5318 { WM_WINDOWPOSCHANGING, sent|wparam, 0, 0 },
5319 { WM_GETMINMAXINFO, sent|defwinproc|wparam, 0, 0 },
5320 { HCBT_ACTIVATE, hook },
5321 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
5322 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
5323 { WM_WINDOWPOSCHANGING, sent|wparam, 3, 0 },
5324 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0 },
5325 { WM_GETTEXT, sent|optional },
5326 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
5327 { WM_ACTIVATEAPP, sent|wparam, 1, 0 },
5328 { WM_NCACTIVATE, sent|lparam, 1, 0 },
5329 { WM_GETTEXT, sent|defwinproc|optional },
5330 { WM_GETTEXT, sent|defwinproc|optional },
5331 { WM_ACTIVATE, sent|wparam|lparam, 1, 0 },
5332 { HCBT_SETFOCUS, hook },
5333 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
5334 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
5335 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
5336 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
5337 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
5338 { WM_GETTEXT, sent|optional },
5339 { WM_NCCALCSIZE, sent|optional },
5340 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends it, but Win8+ doesn't. */
5341 { 0 }
5342 };
5343
5344 static void CALLBACK apc_test_proc(ULONG_PTR param)
5345 {
5346 /* nothing */
5347 }
5348
5349 static void test_MsgWaitForMultipleObjects(HWND hwnd)
5350 {
5351 DWORD ret;
5352 MSG msg;
5353
5354 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5355 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
5356
5357 PostMessageA(hwnd, WM_USER, 0, 0);
5358
5359 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5360 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
5361
5362 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
5363 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5364
5365 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5366 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
5367
5368 PostMessageA(hwnd, WM_USER, 0, 0);
5369
5370 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5371 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
5372
5373 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
5374 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5375
5376 /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
5377 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5378 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
5379
5380 PostMessageA(hwnd, WM_USER, 0, 0);
5381
5382 /* new incoming message causes it to become signaled again */
5383 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5384 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
5385
5386 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
5387 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5388 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
5389 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5390
5391 /* MWMO_INPUTAVAILABLE should succeed even if the message was already seen */
5392 PostMessageA( hwnd, WM_USER, 0, 0 );
5393 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
5394 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5395
5396 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_INPUTAVAILABLE );
5397 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
5398
5399 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
5400 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5401
5402 /* without MWMO_ALERTABLE the result is never WAIT_IO_COMPLETION */
5403 ret = QueueUserAPC( apc_test_proc, GetCurrentThread(), 0 );
5404 ok(ret, "QueueUserAPC failed %lu\n", GetLastError());
5405
5406 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, 0 );
5407 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
5408
5409 /* but even with MWMO_ALERTABLE window events are preferred */
5410 PostMessageA( hwnd, WM_USER, 0, 0 );
5411
5412 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
5413 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
5414
5415 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
5416 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
5417
5418 /* the APC call is still queued */
5419 ret = MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_POSTMESSAGE, MWMO_ALERTABLE );
5420 ok(ret == WAIT_IO_COMPLETION, "MsgWaitForMultipleObjectsEx returned %lx\n", ret);
5421 }
5422
5423 static void test_WM_DEVICECHANGE(HWND hwnd)
5424 {
5425 DWORD ret;
5426 MSG msg;
5427 int i;
5428 static const WPARAM wparams[] = {0,
5429 DBT_DEVNODES_CHANGED,
5430 DBT_QUERYCHANGECONFIG,
5431 DBT_CONFIGCHANGED,
5432 DBT_CONFIGCHANGECANCELED,
5433 DBT_NO_DISK_SPACE,
5434 DBT_LOW_DISK_SPACE,
5435 DBT_CONFIGMGPRIVATE, /* 0x7fff */
5436 DBT_DEVICEARRIVAL, /* 0x8000 */
5437 DBT_DEVICEQUERYREMOVE,
5438 DBT_DEVICEQUERYREMOVEFAILED,
5439 DBT_DEVICEREMOVEPENDING,
5440 DBT_DEVICEREMOVECOMPLETE,
5441 DBT_DEVICETYPESPECIFIC,
5442 DBT_CUSTOMEVENT};
5443
5444 for (i = 0; i < ARRAY_SIZE(wparams); i++)
5445 {
5446 SetLastError(0xdeadbeef);
5447 ret = PostMessageA(hwnd, WM_DEVICECHANGE, wparams[i], 0);
5448 if (wparams[i] & 0x8000)
5449 {
5450 ok(ret == FALSE, "PostMessage returned %ld\n", ret);
5451 ok(GetLastError() == ERROR_MESSAGE_SYNC_ONLY, "PostMessage error %08lx\n", GetLastError());
5452 }
5453 else
5454 {
5455 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
5456 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
5457 memset(&msg, 0, sizeof(msg));
5458 ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should succeed\n");
5459 ok(msg.message == WM_DEVICECHANGE, "got %04x instead of WM_DEVICECHANGE\n", msg.message);
5460 }
5461 }
5462 }
5463
5464 static DWORD CALLBACK hide_window_thread( LPVOID arg )
5465 {
5466 HWND hwnd = arg;
5467
5468 /* function will not return if ShowWindow(SW_HIDE) calls SendMessage() */
5469 ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
5470
5471 return 0;
5472 }
5473
5474 static DWORD CALLBACK show_window_thread( LPVOID arg )
5475 {
5476 HWND hwnd = arg;
5477
5478 /* function will not return if ShowWindow(SW_SHOW) calls SendMessage() */
5479 ok( ShowWindow( hwnd, SW_SHOW ), "ShowWindow(SW_SHOW) expected TRUE\n" ); /* actually it's 24... */
5480
5481 return 0;
5482 }
5483
5484 /* Helper function to easier test SetWindowPos messages */
5485 #define test_msg_setpos( expected_list, flags, todo ) \
5486 test_msg_setpos_( (expected_list), (flags), (todo), __FILE__, __LINE__)
5487 static void test_msg_setpos_(const struct message *expected_list, UINT flags, BOOL todo, const char *file, int line)
5488 {
5489 HWND hwnd;
5490
5491 flush_events();
5492 flush_sequence();
5493 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP,
5494 10, 10, 100, 100, NULL, 0, 0, NULL );
5495 ok (hwnd != 0, "Failed to create popup window\n");
5496 SetWindowPos(hwnd, NULL, 0, 0, 100, 100, flags);
5497 ok_sequence_(expected_list, "SetWindowPos:show_popup_first_show_window", todo, file, line);
5498 DestroyWindow(hwnd);
5499 }
5500
5501 /* test if we receive the right sequence of messages */
5502 static void test_messages(void)
5503 {
5504 DWORD tid;
5505 HANDLE hthread;
5506 HWND hwnd, hparent, hchild;
5507 HWND hchild2, hbutton;
5508 HMENU hmenu;
5509 MSG msg;
5510 LRESULT res;
5511 POINT pos;
5512 BOOL ret;
5513
5514 flush_sequence();
5515
5516 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
5517 100, 100, 200, 200, 0, 0, 0, NULL);
5518 ok (hwnd != 0, "Failed to create overlapped window\n");
5519 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
5520
5521 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
5522 ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
5523 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
5524
5525 /* test WM_SETREDRAW on a not visible top level window */
5526 test_WM_SETREDRAW(hwnd);
5527
5528 SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
5529 flush_events();
5530 ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
5531 ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
5532
5533 ok(GetActiveWindow() == hwnd, "window should be active\n");
5534 ok(GetFocus() == hwnd, "window should have input focus\n");
5535 ShowWindow(hwnd, SW_HIDE);
5536 flush_events();
5537 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
5538
5539 /* test ShowWindow(SW_HIDE) on a hidden window - single threaded */
5540 ok(ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow(SW_HIDE) expected FALSE\n");
5541 flush_events();
5542 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
5543
5544 /* test ShowWindow(SW_HIDE) on a hidden window - multi-threaded */
5545 hthread = CreateThread( NULL, 0, hide_window_thread, hwnd, 0, &tid );
5546 ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
5547 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5548 CloseHandle(hthread);
5549 flush_events();
5550 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
5551
5552 ShowWindow(hwnd, SW_SHOW);
5553 flush_events();
5554 ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
5555
5556 /* test ShowWindow(SW_SHOW) on a visible window - multi-threaded */
5557 hthread = CreateThread( NULL, 0, show_window_thread, hwnd, 0, &tid );
5558 ok( hthread != NULL, "CreateThread failed, error %ld\n", GetLastError() );
5559 ok( WaitForSingleObject( hthread, INFINITE ) == WAIT_OBJECT_0, "WaitForSingleObject failed\n" );
5560 CloseHandle( hthread );
5561 flush_events();
5562 ok_sequence( WmEmptySeq, "ShowWindow(SW_SHOW):overlapped", FALSE );
5563
5564 ShowWindow(hwnd, SW_HIDE);
5565 flush_events();
5566 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
5567
5568 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
5569 flush_events();
5570 ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
5571 flush_sequence();
5572
5573 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZE)
5574 {
5575 ShowWindow(hwnd, SW_RESTORE);
5576 flush_events();
5577 ok_sequence(WmShowRestoreMaxOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
5578 flush_sequence();
5579 }
5580
5581 ShowWindow(hwnd, SW_MINIMIZE);
5582 flush_events();
5583 ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", FALSE);
5584 flush_sequence();
5585
5586 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MINIMIZE)
5587 {
5588 ShowWindow(hwnd, SW_RESTORE);
5589 flush_events();
5590 ok_sequence(WmShowRestoreMinOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", FALSE);
5591 flush_sequence();
5592 }
5593
5594 ShowWindow(hwnd, SW_SHOW);
5595 flush_events();
5596 ok_sequence(WmOptionalPaint, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
5597
5598 SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
5599 ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
5600 ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
5601 ok(GetActiveWindow() == hwnd, "window should still be active\n");
5602
5603 /* test WM_SETREDRAW on a visible top level window */
5604 ShowWindow(hwnd, SW_SHOW);
5605 flush_events();
5606 test_WM_SETREDRAW(hwnd);
5607
5608 if (winetest_debug > 1) trace("testing scroll APIs on a visible top level window %p\n", hwnd);
5609 test_scroll_messages(hwnd);
5610
5611 /* test resizing and moving */
5612 SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
5613 ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
5614 flush_events();
5615 flush_sequence();
5616 SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
5617 ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
5618 flush_events();
5619 flush_sequence();
5620 SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER|SWP_NOACTIVATE );
5621 ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
5622 flush_events();
5623 flush_sequence();
5624
5625 /* popups don't get WM_GETMINMAXINFO */
5626 SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
5627 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
5628 flush_sequence();
5629 SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
5630 ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
5631
5632 DestroyWindow(hwnd);
5633 ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
5634
5635 /* Test if windows are correctly drawn when first shown */
5636
5637 /* Visible, redraw */
5638 flush_events();
5639 flush_sequence();
5640 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP | WS_VISIBLE,
5641 10, 10, 100, 100, NULL, 0, 0, NULL );
5642 ok (hwnd != 0, "Failed to create popup window\n");
5643 RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
5644 ok_sequence(WmShowPopupFirstDrawSeq_1, "RedrawWindow:show_popup_first_draw_visible", FALSE);
5645 DestroyWindow(hwnd);
5646
5647 /* Invisible, show, message */
5648 flush_events();
5649 flush_sequence();
5650 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP,
5651 10, 10, 100, 100, NULL, 0, 0, NULL );
5652 ok (hwnd != 0, "Failed to create popup window\n");
5653 ShowWindow(hwnd, SW_SHOW);
5654 SendMessageW(hwnd, WM_PAINT, 0, 0);
5655 ok_sequence(WmShowPopupFirstDrawSeq_1, "RedrawWindow:show_popup_first_draw_show", FALSE);
5656 DestroyWindow(hwnd);
5657
5658 /* Invisible, show maximized, redraw */
5659 flush_events();
5660 flush_sequence();
5661 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP,
5662 10, 10, 100, 100, NULL, 0, 0, NULL );
5663 ok (hwnd != 0, "Failed to create popup window\n");
5664 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
5665 RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
5666 ok_sequence(WmShowPopupFirstDrawSeq_2, "RedrawWindow:show_popup_first_draw_show_maximized", FALSE);
5667 DestroyWindow(hwnd);
5668
5669 /* Test SetWindowPos */
5670 test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW, FALSE);
5671 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, 0, FALSE);
5672 test_msg_setpos(WmFirstDrawSetWindowPosSeq3,
5673 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER, FALSE);
5674
5675 test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOSIZE, FALSE);
5676 test_msg_setpos(WmFirstDrawSetWindowPosSeq4, SWP_SHOWWINDOW | SWP_NOMOVE, FALSE);
5677 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCLIENTSIZE, FALSE);
5678 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCLIENTMOVE, FALSE);
5679 test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOZORDER, FALSE);
5680
5681 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_DEFERERASE, FALSE);
5682 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOCLIENTMOVE, FALSE);
5683 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOCLIENTSIZE, FALSE);
5684 test_msg_setpos(WmFirstDrawSetWindowPosSeq5, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOMOVE, FALSE);
5685 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOSIZE, FALSE);
5686 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_DEFERERASE | SWP_NOZORDER, FALSE);
5687
5688 test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOCOPYBITS, FALSE);
5689 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOCLIENTMOVE, FALSE);
5690 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOCLIENTSIZE, FALSE);
5691 test_msg_setpos(WmFirstDrawSetWindowPosSeq4, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOMOVE, FALSE);
5692 test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOSIZE, FALSE);
5693 test_msg_setpos(WmFirstDrawSetWindowPosSeq1, SWP_SHOWWINDOW | SWP_NOCOPYBITS | SWP_NOZORDER, FALSE);
5694
5695 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_NOREDRAW, FALSE);
5696 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOCLIENTMOVE, FALSE);
5697 test_msg_setpos(WmFirstDrawSetWindowPosSeq3, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOCLIENTSIZE, FALSE);
5698 test_msg_setpos(WmFirstDrawSetWindowPosSeq5, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOMOVE, FALSE);
5699 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOSIZE, FALSE);
5700 test_msg_setpos(WmFirstDrawSetWindowPosSeq2, SWP_SHOWWINDOW | SWP_NOREDRAW | SWP_NOZORDER, FALSE);
5701
5702 /* Test SetWindowPos with child windows */
5703 flush_events();
5704 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5705 100, 100, 200, 200, 0, 0, 0, NULL);
5706 ok (hparent != 0, "Failed to create parent window\n");
5707
5708 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
5709 0, 0, 10, 10, hparent, 0, 0, NULL);
5710 ok (hchild != 0, "Failed to create child window\n");
5711 flush_sequence();
5712 SetWindowPos(hparent, NULL, 0, 0, 100, 100, SWP_SHOWWINDOW);
5713 ok_sequence(WmFirstDrawChildSeq1, /* Expect no messages for the child */
5714 "SetWindowPos:show_popup_first_show_window_child1", FALSE);
5715 DestroyWindow(hchild);
5716 DestroyWindow(hparent);
5717
5718 flush_events();
5719 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
5720 100, 100, 200, 200, 0, 0, 0, NULL);
5721 ok (hparent != 0, "Failed to create parent window\n");
5722
5723 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
5724 0, 0, 10, 10, hparent, 0, 0, NULL);
5725 ok (hchild != 0, "Failed to create child window\n");
5726 flush_sequence();
5727 SetWindowPos(hparent, NULL, 0, 0, 100, 100, SWP_SHOWWINDOW);
5728 ok_sequence(WmFirstDrawChildSeq2, /* Expect child to be redrawn */
5729 "SetWindowPos:show_popup_first_show_window_child2", FALSE);
5730 DestroyWindow(hchild);
5731 DestroyWindow(hparent);
5732
5733 /* Test message sequence for extreme position and size */
5734
5735 flush_sequence();
5736 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Popup", WS_POPUP | WS_VISIBLE,
5737 -10, -10, 10000, 10000, NULL, 0, 0, NULL );
5738 ok (hwnd != 0, "Failed to create popup window\n");
5739 ok_sequence(WmShowPopupExtremeLocationSeq, "RedrawWindow:show_popup_extreme_location", FALSE);
5740 DestroyWindow(hwnd);
5741
5742
5743 /* Test child windows */
5744
5745 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5746 100, 100, 200, 200, 0, 0, 0, NULL);
5747 ok (hparent != 0, "Failed to create parent window\n");
5748 flush_sequence();
5749
5750 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
5751 0, 0, 10, 10, hparent, 0, 0, NULL);
5752 ok (hchild != 0, "Failed to create child window\n");
5753 ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
5754 DestroyWindow(hchild);
5755 flush_sequence();
5756
5757 /* visible child window with a caption */
5758 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
5759 WS_CHILD | WS_VISIBLE | WS_CAPTION,
5760 0, 0, 10, 10, hparent, 0, 0, NULL);
5761 ok (hchild != 0, "Failed to create child window\n");
5762 ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
5763
5764 if (winetest_debug > 1) trace("testing scroll APIs on a visible child window %p\n", hchild);
5765 test_scroll_messages(hchild);
5766
5767 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
5768 ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
5769
5770 DestroyWindow(hchild);
5771 flush_sequence();
5772
5773 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
5774 0, 0, 10, 10, hparent, 0, 0, NULL);
5775 ok (hchild != 0, "Failed to create child window\n");
5776 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
5777
5778 hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
5779 100, 100, 50, 50, hparent, 0, 0, NULL);
5780 ok (hchild2 != 0, "Failed to create child2 window\n");
5781 flush_sequence();
5782
5783 hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
5784 0, 100, 50, 50, hchild, 0, 0, NULL);
5785 ok (hbutton != 0, "Failed to create button window\n");
5786
5787 /* test WM_SETREDRAW on a not visible child window */
5788 test_WM_SETREDRAW(hchild);
5789
5790 ShowWindow(hchild, SW_SHOW);
5791 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
5792
5793 /* check parent messages too */
5794 log_all_parent_messages++;
5795 ShowWindow(hchild, SW_HIDE);
5796 ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
5797 log_all_parent_messages--;
5798
5799 ShowWindow(hchild, SW_SHOW);
5800 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
5801
5802 ShowWindow(hchild, SW_HIDE);
5803 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
5804
5805 ShowWindow(hchild, SW_SHOW);
5806 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
5807
5808 /* test WM_SETREDRAW on a visible child window */
5809 test_WM_SETREDRAW(hchild);
5810
5811 log_all_parent_messages++;
5812 MoveWindow(hchild, 10, 10, 20, 20, TRUE);
5813 ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
5814 log_all_parent_messages--;
5815
5816 ShowWindow(hchild, SW_HIDE);
5817 flush_sequence();
5818 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
5819 ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
5820
5821 ShowWindow(hchild, SW_HIDE);
5822 flush_sequence();
5823 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
5824 ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
5825
5826 /* DestroyWindow sequence below expects that a child has focus */
5827 SetFocus(hchild);
5828 flush_sequence();
5829
5830 DestroyWindow(hchild);
5831 ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
5832 DestroyWindow(hchild2);
5833 DestroyWindow(hbutton);
5834
5835 flush_sequence();
5836 hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
5837 0, 0, 100, 100, hparent, 0, 0, NULL);
5838 ok (hchild != 0, "Failed to create child popup window\n");
5839 ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
5840 DestroyWindow(hchild);
5841
5842 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
5843 flush_sequence();
5844 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
5845 0, 0, 100, 100, hparent, 0, 0, NULL);
5846 ok (hchild != 0, "Failed to create popup window\n");
5847 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
5848 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5849 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
5850 flush_sequence();
5851 ShowWindow(hchild, SW_SHOW);
5852 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
5853 flush_sequence();
5854 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5855 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
5856 flush_sequence();
5857 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
5858 ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
5859 DestroyWindow(hchild);
5860
5861 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
5862 * changes nothing in message sequences.
5863 */
5864 flush_sequence();
5865 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
5866 0, 0, 100, 100, hparent, 0, 0, NULL);
5867 ok (hchild != 0, "Failed to create popup window\n");
5868 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
5869 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
5870 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
5871 flush_sequence();
5872 ShowWindow(hchild, SW_SHOW);
5873 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
5874 flush_sequence();
5875 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
5876 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
5877 DestroyWindow(hchild);
5878
5879 flush_sequence();
5880 hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
5881 0, 0, 100, 100, hparent, 0, 0, NULL);
5882 ok(hwnd != 0, "Failed to create custom dialog window\n");
5883 ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
5884
5885 if(0) {
5886 if (winetest_debug > 1) trace("testing scroll APIs on a visible dialog %p\n", hwnd);
5887 test_scroll_messages(hwnd);
5888 }
5889
5890 flush_sequence();
5891
5892 test_def_id = TRUE;
5893 SendMessageA(hwnd, WM_NULL, 0, 0);
5894
5895 flush_sequence();
5896 after_end_dialog = TRUE;
5897 EndDialog( hwnd, 0 );
5898 ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
5899
5900 DestroyWindow(hwnd);
5901 after_end_dialog = FALSE;
5902 test_def_id = FALSE;
5903
5904 ok(GetCursorPos(&pos), "GetCursorPos failed\n");
5905 ok(SetCursorPos(109, 109), "SetCursorPos failed\n");
5906
5907 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP|WS_CHILD,
5908 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
5909 ok(hwnd != 0, "Failed to create custom dialog window\n");
5910 flush_sequence();
5911 if (winetest_debug > 1) trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
5912 ShowWindow(hwnd, SW_SHOW);
5913 ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
5914
5915 flush_events();
5916 flush_sequence();
5917 ret = DrawMenuBar(hwnd);
5918 ok(ret, "DrawMenuBar failed: %ld\n", GetLastError());
5919 flush_events();
5920 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
5921 ok(SetCursorPos(pos.x, pos.y), "SetCursorPos failed\n");
5922
5923 DestroyWindow(hwnd);
5924
5925 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_CHILD|WS_VISIBLE,
5926 0, 0, 100, 100, hparent, 0, GetModuleHandleA(0), NULL);
5927 ok(hwnd != 0, "Failed to create custom dialog window\n");
5928 flush_events();
5929 flush_sequence();
5930 ret = DrawMenuBar(hwnd);
5931 ok(ret, "DrawMenuBar failed: %ld\n", GetLastError());
5932 flush_events();
5933 ok_sequence(WmEmptySeq, "DrawMenuBar for a child window", FALSE);
5934
5935 DestroyWindow(hwnd);
5936
5937 flush_sequence();
5938 DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
5939 ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
5940
5941 DestroyWindow(hparent);
5942 flush_sequence();
5943
5944 /* Message sequence for SetMenu */
5945 ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a destroyed window\n");
5946 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "last error is %ld\n", GetLastError());
5947 ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
5948
5949 hmenu = CreateMenu();
5950 ok (hmenu != 0, "Failed to create menu\n");
5951 ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
5952 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
5953 100, 100, 200, 200, 0, hmenu, 0, NULL);
5954 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
5955 ok (SetMenu(hwnd, 0), "SetMenu\n");
5956 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
5957 ok (SetMenu(hwnd, 0), "SetMenu\n");
5958 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
5959 ShowWindow(hwnd, SW_SHOW);
5960 UpdateWindow( hwnd );
5961 flush_events();
5962 flush_sequence();
5963 ok (SetMenu(hwnd, 0), "SetMenu\n");
5964 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
5965 ok (SetMenu(hwnd, hmenu), "SetMenu\n");
5966 ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
5967
5968 UpdateWindow( hwnd );
5969 flush_events();
5970 flush_sequence();
5971 ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
5972 flush_events();
5973 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
5974
5975 DestroyWindow(hwnd);
5976 flush_sequence();
5977
5978 /* Message sequence for EnableWindow */
5979 hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5980 100, 100, 200, 200, 0, 0, 0, NULL);
5981 ok (hparent != 0, "Failed to create parent window\n");
5982 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
5983 0, 0, 10, 10, hparent, 0, 0, NULL);
5984 ok (hchild != 0, "Failed to create child window\n");
5985
5986 SetFocus(hchild);
5987 flush_events();
5988 flush_sequence();
5989
5990 EnableWindow(hparent, FALSE);
5991 ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
5992
5993 EnableWindow(hparent, FALSE);
5994 ok_sequence(WmEnableWindowSeq_2, "EnableWindow(FALSE)", FALSE);
5995
5996 EnableWindow(hparent, TRUE);
5997 ok_sequence(WmEnableWindowSeq_3, "EnableWindow(TRUE)", FALSE);
5998
5999 EnableWindow(hparent, TRUE);
6000 ok_sequence(WmEnableWindowSeq_4, "EnableWindow(TRUE)", FALSE);
6001
6002 flush_events();
6003 flush_sequence();
6004
6005 test_MsgWaitForMultipleObjects(hparent);
6006 test_WM_DEVICECHANGE(hparent);
6007
6008 /* the following test causes an exception in user.exe under win9x */
6009 if (!PostMessageW( hparent, WM_USER, 0, 0 ))
6010 {
6011 DestroyWindow(hparent);
6012 flush_sequence();
6013 return;
6014 }
6015 PostMessageW( hparent, WM_USER+1, 0, 0 );
6016 /* PeekMessage(NULL) fails, but still removes the message */
6017 SetLastError(0xdeadbeef);
6018 ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
6019 ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
6020 GetLastError() == 0xdeadbeef, /* NT4 */
6021 "last error is %ld\n", GetLastError() );
6022 ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
6023 ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
6024
6025 DestroyWindow(hchild);
6026 DestroyWindow(hparent);
6027 flush_sequence();
6028
6029 /* Message sequences for WM_SETICON */
6030 if (winetest_debug > 1) trace("testing WM_SETICON\n");
6031 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
6032 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
6033 NULL, NULL, 0);
6034 ShowWindow(hwnd, SW_SHOW);
6035 UpdateWindow(hwnd);
6036 flush_events();
6037 flush_sequence();
6038 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
6039 ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
6040
6041 ShowWindow(hwnd, SW_HIDE);
6042 flush_events();
6043 flush_sequence();
6044 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
6045 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
6046 DestroyWindow(hwnd);
6047 flush_sequence();
6048
6049 hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
6050 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
6051 NULL, NULL, 0);
6052 ShowWindow(hwnd, SW_SHOW);
6053 UpdateWindow(hwnd);
6054 flush_events();
6055 flush_sequence();
6056 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
6057 ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
6058
6059 ShowWindow(hwnd, SW_HIDE);
6060 flush_events();
6061 flush_sequence();
6062 SendMessageA(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIconA(0, (LPCSTR)IDI_APPLICATION));
6063 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
6064
6065 flush_sequence();
6066 res = SendMessageA(hwnd, 0x3B, 0x8000000b, 0);
6067 if (!res)
6068 {
6069 todo_wine win_skip( "Message 0x3b not supported\n" );
6070 goto done;
6071 }
6072 ok_sequence(WmInitEndSession, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x8000000b", TRUE);
6073 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x8000000b, 0) should have returned 1 instead of %Id\n", res);
6074 res = SendMessageA(hwnd, 0x3B, 0x0000000b, 0);
6075 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000b", TRUE);
6076 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000b, 0) should have returned 1 instead of %Id\n", res);
6077 res = SendMessageA(hwnd, 0x3B, 0x0000000f, 0);
6078 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000f", TRUE);
6079 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000f, 0) should have returned 1 instead of %Id\n", res);
6080
6081 flush_sequence();
6082 res = SendMessageA(hwnd, 0x3B, 0x80000008, 0);
6083 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000008", TRUE);
6084 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000008, 0) should have returned 2 instead of %Id\n", res);
6085 res = SendMessageA(hwnd, 0x3B, 0x00000008, 0);
6086 ok_sequence(WmInitEndSession_4, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x00000008", TRUE);
6087 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x00000008, 0) should have returned 2 instead of %Id\n", res);
6088
6089 res = SendMessageA(hwnd, 0x3B, 0x80000004, 0);
6090 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000004", TRUE);
6091 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000004, 0) should have returned 2 instead of %Id\n", res);
6092
6093 res = SendMessageA(hwnd, 0x3B, 0x80000001, 0);
6094 ok_sequence(WmInitEndSession_5, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000001", TRUE);
6095 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000001, 0) should have returned 2 instead of %Id\n", res);
6096
6097 done:
6098 DestroyWindow(hwnd);
6099 flush_sequence();
6100 }
6101
6102 static const struct message WmFrameChanged[] = {
6103 { WM_WINDOWPOSCHANGING, sent|wparam|lparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE, 0 },
6104 { WM_NCCALCSIZE, sent|wparam|lparam, 1, 0xf },
6105 { WM_WINDOWPOSCHANGED, sent|wparam|lparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW
6106 |SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0xf },
6107 { WM_GETTEXT, sent|optional },
6108 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6109 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
6110 { 0 }
6111 };
6112
6113 static const struct message WmFrameChanged_move[] = {
6114 { WM_WINDOWPOSCHANGING, sent|wparam|lparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE, 0 },
6115 { WM_NCCALCSIZE, sent|wparam|lparam, 1, 0x3 },
6116 { WM_WINDOWPOSCHANGED, sent|wparam|lparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW
6117 |SWP_NOSIZE|SWP_NOCLIENTSIZE, 0x3 },
6118 { WM_MOVE, sent|defwinproc, 0 },
6119 { WM_GETTEXT, sent|optional },
6120 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6121 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
6122 { 0 }
6123 };
6124
6125 static void test_setwindowpos(void)
6126 {
6127 HWND hwnd;
6128 RECT rc;
6129 LRESULT res;
6130 const INT X = 50;
6131 const INT Y = 50;
6132 const INT winX = 100;
6133 const INT winY = 100;
6134 const INT sysX = GetSystemMetrics(SM_CXMINTRACK);
6135
6136 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
6137 X, Y, winX, winY, 0,
6138 NULL, NULL, 0);
6139
6140 GetWindowRect(hwnd, &rc);
6141 expect(sysX + X, rc.right);
6142 expect(winY + Y, rc.bottom);
6143
6144 flush_events();
6145 flush_sequence();
6146 res = SetWindowPos(hwnd, HWND_TOPMOST, 50, 50, winX, winY, 0);
6147 ok_sequence(WmZOrder, "Z-Order", TRUE);
6148 ok(res == TRUE, "SetWindowPos expected TRUE, got %Id\n", res);
6149
6150 GetWindowRect(hwnd, &rc);
6151 expect(sysX + X, rc.right);
6152 expect(winY + Y, rc.bottom);
6153
6154 res = SetWindowPos( hwnd, 0, 0, 0, 0, 0,
6155 SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
6156 ok_sequence(WmFrameChanged, "FrameChanged", FALSE);
6157 ok(res == TRUE, "SetWindowPos expected TRUE, got %Id.\n", res);
6158
6159 GetWindowRect(hwnd, &rc);
6160 expect(sysX + X, rc.right);
6161 expect(winY + Y, rc.bottom);
6162
6163 res = SetWindowPos( hwnd, 0, 0, 0, 0, 0,
6164 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
6165 ok_sequence(WmFrameChanged_move, "FrameChanged", FALSE);
6166 ok(res == TRUE, "SetWindowPos expected TRUE, got %Id.\n", res);
6167
6168 GetWindowRect(hwnd, &rc);
6169 expect(sysX, rc.right);
6170 expect(winY, rc.bottom);
6171
6172 DestroyWindow(hwnd);
6173 }
6174
6175 static void invisible_parent_tests(void)
6176 {
6177 HWND hparent, hchild;
6178
6179 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
6180 100, 100, 200, 200, 0, 0, 0, NULL);
6181 ok (hparent != 0, "Failed to create parent window\n");
6182 flush_sequence();
6183
6184 /* test showing child with hidden parent */
6185
6186 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6187 0, 0, 10, 10, hparent, 0, 0, NULL);
6188 ok (hchild != 0, "Failed to create child window\n");
6189 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
6190
6191 ShowWindow( hchild, SW_MINIMIZE );
6192 ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
6193 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6194 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6195
6196 /* repeat */
6197 flush_events();
6198 flush_sequence();
6199 ShowWindow( hchild, SW_MINIMIZE );
6200 ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
6201
6202 DestroyWindow(hchild);
6203 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6204 0, 0, 10, 10, hparent, 0, 0, NULL);
6205 flush_sequence();
6206
6207 ShowWindow( hchild, SW_MAXIMIZE );
6208 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
6209 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6210 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6211
6212 /* repeat */
6213 flush_events();
6214 flush_sequence();
6215 ShowWindow( hchild, SW_MAXIMIZE );
6216 ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
6217
6218 DestroyWindow(hchild);
6219 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6220 0, 0, 10, 10, hparent, 0, 0, NULL);
6221 flush_sequence();
6222
6223 ShowWindow( hchild, SW_RESTORE );
6224 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
6225 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6226 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6227
6228 DestroyWindow(hchild);
6229 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6230 0, 0, 10, 10, hparent, 0, 0, NULL);
6231 flush_sequence();
6232
6233 ShowWindow( hchild, SW_SHOWMINIMIZED );
6234 ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
6235 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6236 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6237
6238 /* repeat */
6239 flush_events();
6240 flush_sequence();
6241 ShowWindow( hchild, SW_SHOWMINIMIZED );
6242 ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
6243
6244 DestroyWindow(hchild);
6245 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6246 0, 0, 10, 10, hparent, 0, 0, NULL);
6247 flush_sequence();
6248
6249 /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
6250 ShowWindow( hchild, SW_SHOWMAXIMIZED );
6251 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
6252 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6253 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6254
6255 DestroyWindow(hchild);
6256 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6257 0, 0, 10, 10, hparent, 0, 0, NULL);
6258 flush_sequence();
6259
6260 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
6261 ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
6262 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6263 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6264
6265 /* repeat */
6266 flush_events();
6267 flush_sequence();
6268 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
6269 ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
6270
6271 DestroyWindow(hchild);
6272 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6273 0, 0, 10, 10, hparent, 0, 0, NULL);
6274 flush_sequence();
6275
6276 /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
6277 ShowWindow( hchild, SW_FORCEMINIMIZE );
6278 ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
6279 todo_wine {
6280 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
6281 }
6282 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6283
6284 DestroyWindow(hchild);
6285 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6286 0, 0, 10, 10, hparent, 0, 0, NULL);
6287 flush_sequence();
6288
6289 ShowWindow( hchild, SW_SHOWNA );
6290 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
6291 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6292 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6293
6294 /* repeat */
6295 flush_events();
6296 flush_sequence();
6297 ShowWindow( hchild, SW_SHOWNA );
6298 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
6299
6300 DestroyWindow(hchild);
6301 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
6302 0, 0, 10, 10, hparent, 0, 0, NULL);
6303 flush_sequence();
6304
6305 ShowWindow( hchild, SW_SHOW );
6306 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
6307 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6308 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6309
6310 /* repeat */
6311 flush_events();
6312 flush_sequence();
6313 ShowWindow( hchild, SW_SHOW );
6314 ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
6315
6316 ShowWindow( hchild, SW_HIDE );
6317 ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
6318 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
6319 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6320
6321 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
6322 ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
6323 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
6324 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6325
6326 SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
6327 ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
6328 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
6329 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
6330
6331 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
6332 flush_sequence();
6333 DestroyWindow(hchild);
6334 ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
6335
6336 DestroyWindow(hparent);
6337 flush_sequence();
6338 }
6339
6340 /****************** button message test *************************/
6341 #define ID_BUTTON 0x000e
6342
6343 static const struct message WmSetFocusButtonSeq[] =
6344 {
6345 { HCBT_SETFOCUS, hook },
6346 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
6347 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
6348 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6349 { WM_SETFOCUS, sent|wparam, 0 },
6350 { WM_CTLCOLORBTN, sent|parent },
6351 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
6352 { WM_APP, sent|wparam|lparam, 0, 0 },
6353 { 0 }
6354 };
6355 static const struct message WmKillFocusButtonSeq[] =
6356 {
6357 { HCBT_SETFOCUS, hook },
6358 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6359 { WM_KILLFOCUS, sent|wparam, 0 },
6360 { WM_CTLCOLORBTN, sent|parent },
6361 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
6362 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
6363 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
6364 { WM_APP, sent|wparam|lparam, 0, 0 },
6365 { WM_PAINT, sent },
6366 { WM_CTLCOLORBTN, sent|parent },
6367 { 0 }
6368 };
6369 static const struct message WmSetFocusStaticSeq[] =
6370 {
6371 { HCBT_SETFOCUS, hook },
6372 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
6373 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
6374 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6375 { WM_SETFOCUS, sent|wparam, 0 },
6376 { WM_CTLCOLORSTATIC, sent|parent },
6377 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
6378 { WM_COMMAND, sent|wparam|parent|optional, MAKEWPARAM(ID_BUTTON, BN_CLICKED) }, /* radio button */
6379 { WM_APP, sent|wparam|lparam, 0, 0 },
6380 { 0 }
6381 };
6382 static const struct message WmKillFocusStaticSeq[] =
6383 {
6384 { HCBT_SETFOCUS, hook },
6385 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6386 { WM_KILLFOCUS, sent|wparam, 0 },
6387 { WM_CTLCOLORSTATIC, sent|parent },
6388 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
6389 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
6390 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
6391 { WM_APP, sent|wparam|lparam, 0, 0 },
6392 { WM_PAINT, sent },
6393 { WM_CTLCOLORSTATIC, sent|parent },
6394 { 0 }
6395 };
6396 static const struct message WmSetFocusOwnerdrawSeq[] =
6397 {
6398 { HCBT_SETFOCUS, hook },
6399 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
6400 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
6401 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6402 { WM_SETFOCUS, sent|wparam, 0 },
6403 { WM_CTLCOLORBTN, sent|parent },
6404 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x001040e4 },
6405 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
6406 { WM_APP, sent|wparam|lparam, 0, 0 },
6407 { 0 }
6408 };
6409 static const struct message WmKillFocusOwnerdrawSeq[] =
6410 {
6411 { HCBT_SETFOCUS, hook },
6412 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6413 { WM_KILLFOCUS, sent|wparam, 0 },
6414 { WM_CTLCOLORBTN, sent|parent },
6415 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000040e4 },
6416 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
6417 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
6418 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
6419 { WM_APP, sent|wparam|lparam, 0, 0 },
6420 { WM_PAINT, sent },
6421 { WM_CTLCOLORBTN, sent|parent },
6422 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000010e4 },
6423 { 0 }
6424 };
6425 static const struct message WmLButtonDownSeq[] =
6426 {
6427 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
6428 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6429 { HCBT_SETFOCUS, hook },
6430 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
6431 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
6432 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6433 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
6434 { WM_CTLCOLORBTN, sent|defwinproc },
6435 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
6436 { WM_CTLCOLORBTN, sent|defwinproc },
6437 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6438 { 0 }
6439 };
6440 static const struct message WmLButtonDownStaticSeq[] =
6441 {
6442 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
6443 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6444 { HCBT_SETFOCUS, hook },
6445 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
6446 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
6447 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6448 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
6449 { WM_CTLCOLORSTATIC, sent|defwinproc },
6450 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
6451 { WM_CTLCOLORSTATIC, sent|defwinproc },
6452 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6453 { 0 }
6454 };
6455 static const struct message WmLButtonUpSeq[] =
6456 {
6457 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
6458 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
6459 { WM_CTLCOLORBTN, sent|defwinproc },
6460 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6461 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6462 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
6463 { 0 }
6464 };
6465 static const struct message WmLButtonUpStaticSeq[] =
6466 {
6467 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
6468 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
6469 { WM_CTLCOLORSTATIC, sent|defwinproc },
6470 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6471 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6472 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
6473 { 0 }
6474 };
6475 static const struct message WmLButtonUpAutoSeq[] =
6476 {
6477 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
6478 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
6479 { WM_CTLCOLORSTATIC, sent|defwinproc },
6480 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6481 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|optional, 0, 0 },
6482 { BM_SETCHECK, sent|defwinproc },
6483 { WM_CTLCOLORSTATIC, sent|defwinproc|optional, 0, 0 }, /* Sent here on Win7. */
6484 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6485 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6486 { WM_CTLCOLORSTATIC, sent|defwinproc|optional, 0, 0 }, /* Sent here on Win8+. */
6487 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
6488 { 0 }
6489 };
6490 static const struct message WmLButtonUpBrokenSeq[] =
6491 {
6492 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
6493 { 0 }
6494 };
6495 static const struct message WmSetFontButtonSeq[] =
6496 {
6497 { WM_SETFONT, sent },
6498 { WM_PAINT, sent },
6499 { WM_ERASEBKGND, sent|defwinproc|optional },
6500 { WM_CTLCOLORBTN, sent|defwinproc },
6501 { WM_CTLCOLORBTN, sent|defwinproc|optional }, /* FIXME: Wine sends it twice for BS_OWNERDRAW */
6502 { 0 }
6503 };
6504 static const struct message WmSetFontStaticSeq[] =
6505 {
6506 { WM_SETFONT, sent },
6507 { WM_PAINT, sent },
6508 { WM_ERASEBKGND, sent|defwinproc|optional },
6509 { WM_CTLCOLORSTATIC, sent|defwinproc },
6510 { 0 }
6511 };
6512 static const struct message WmSetTextButtonSeq[] =
6513 {
6514 { WM_SETTEXT, sent },
6515 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6516 { WM_CTLCOLORBTN, sent|parent },
6517 { WM_CTLCOLORBTN, sent|parent },
6518 { WM_COMMAND, sent|parent|optional },
6519 { WM_DRAWITEM, sent|parent|optional },
6520 { 0 }
6521 };
6522 static const struct message WmSetTextStaticSeq[] =
6523 {
6524 { WM_SETTEXT, sent },
6525 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6526 { WM_CTLCOLORSTATIC, sent|parent },
6527 { WM_CTLCOLORSTATIC, sent|parent },
6528 { 0 }
6529 };
6530 static const struct message WmSetTextGroupSeq[] =
6531 {
6532 { WM_SETTEXT, sent },
6533 { WM_CTLCOLORSTATIC, sent|parent },
6534 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6535 { WM_CTLCOLORSTATIC, sent|parent|optional }, /* FIXME: Missing in Wine */
6536 { WM_CTLCOLORSTATIC, sent|parent|optional }, /* FIXME: Missing in Wine */
6537 { 0 }
6538 };
6539 static const struct message WmSetTextInvisibleSeq[] =
6540 {
6541 { WM_SETTEXT, sent },
6542 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6543 { 0 }
6544 };
6545 static const struct message WmSetStyleButtonSeq[] =
6546 {
6547 { BM_SETSTYLE, sent },
6548 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6549 { WM_APP, sent|wparam|lparam, 0, 0 },
6550 { WM_PAINT, sent },
6551 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
6552 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
6553 { WM_CTLCOLORBTN, sent|parent },
6554 { 0 }
6555 };
6556 static const struct message WmSetStyleStaticSeq[] =
6557 {
6558 { BM_SETSTYLE, sent },
6559 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6560 { WM_APP, sent|wparam|lparam, 0, 0 },
6561 { WM_PAINT, sent },
6562 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
6563 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
6564 { WM_CTLCOLORSTATIC, sent|parent },
6565 { 0 }
6566 };
6567 static const struct message WmSetStyleUserSeq[] =
6568 {
6569 { BM_SETSTYLE, sent },
6570 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6571 { WM_APP, sent|wparam|lparam, 0, 0 },
6572 { WM_PAINT, sent },
6573 { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
6574 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
6575 { WM_CTLCOLORBTN, sent|parent },
6576 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_PAINT) },
6577 { 0 }
6578 };
6579 static const struct message WmSetStyleOwnerdrawSeq[] =
6580 {
6581 { BM_SETSTYLE, sent },
6582 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6583 { WM_APP, sent|wparam|lparam, 0, 0 },
6584 { WM_PAINT, sent },
6585 { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
6586 { WM_ERASEBKGND, sent|defwinproc|optional }, /* Win9x doesn't send it */
6587 { WM_CTLCOLORBTN, sent|parent },
6588 { WM_CTLCOLORBTN, sent|parent|optional }, /* Win9x doesn't send it */
6589 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000010e4 },
6590 { 0 }
6591 };
6592 static const struct message WmSetStateButtonSeq[] =
6593 {
6594 { BM_SETSTATE, sent },
6595 { WM_CTLCOLORBTN, sent|parent },
6596 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6597 { WM_APP, sent|wparam|lparam, 0, 0 },
6598 { 0 }
6599 };
6600 static const struct message WmSetStateStaticSeq[] =
6601 {
6602 { BM_SETSTATE, sent },
6603 { WM_CTLCOLORSTATIC, sent|parent },
6604 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6605 { WM_APP, sent|wparam|lparam, 0, 0 },
6606 { 0 }
6607 };
6608 static const struct message WmSetStateUserSeq[] =
6609 {
6610 { BM_SETSTATE, sent },
6611 { WM_CTLCOLORBTN, sent|parent },
6612 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_HILITE) },
6613 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6614 { WM_APP, sent|wparam|lparam, 0, 0 },
6615 { 0 }
6616 };
6617 static const struct message WmSetStateOwnerdrawSeq[] =
6618 {
6619 { BM_SETSTATE, sent },
6620 { WM_CTLCOLORBTN, sent|parent },
6621 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000120e4 },
6622 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6623 { WM_APP, sent|wparam|lparam, 0, 0 },
6624 { 0 }
6625 };
6626 static const struct message WmClearStateButtonSeq[] =
6627 {
6628 { BM_SETSTATE, sent },
6629 { WM_CTLCOLORBTN, sent|parent },
6630 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_UNHILITE) },
6631 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6632 { WM_APP, sent|wparam|lparam, 0, 0 },
6633 { 0 }
6634 };
6635 static const struct message WmDisableButtonSeq[] =
6636 {
6637 { WM_LBUTTONDOWN, sent },
6638 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6639 { BM_SETSTATE, sent|defwinproc },
6640 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
6641 { WM_CTLCOLORBTN, sent|optional },
6642 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6643 { WM_LBUTTONUP, sent },
6644 { BM_SETSTATE, sent|defwinproc },
6645 { WM_CTLCOLORBTN, sent|defwinproc|optional },
6646 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
6647 { BM_SETCHECK, sent|defwinproc|optional },
6648 { WM_CTLCOLORBTN, sent|optional },
6649 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6650 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
6651 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
6652 { WM_CAPTURECHANGED, sent|defwinproc },
6653 { WM_COMMAND, sent },
6654 { 0 }
6655 };
6656 static const struct message WmClearStateOwnerdrawSeq[] =
6657 {
6658 { BM_SETSTATE, sent },
6659 { WM_CTLCOLORBTN, sent|parent },
6660 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_BUTTON, 0x000020e4 },
6661 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
6662 { WM_APP, sent|wparam|lparam, 0, 0 },
6663 { 0 }
6664 };
6665 static const struct message WmSetCheckIgnoredSeq[] =
6666 {
6667 { BM_SETCHECK, sent },
6668 { WM_APP, sent|wparam|lparam, 0, 0 },
6669 { 0 }
6670 };
6671 static const struct message WmSetCheckStaticSeq[] =
6672 {
6673 { BM_SETCHECK, sent },
6674 { WM_CTLCOLORSTATIC, sent|parent },
6675 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
6676 { WM_APP, sent|wparam|lparam, 0, 0 },
6677 { 0 }
6678 };
6679
6680 static WNDPROC old_button_proc;
6681
6682 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6683 {
6684 static LONG defwndproc_counter = 0;
6685 LRESULT ret;
6686 struct recvd_message msg;
6687
6688 if (ignore_message( message )) return 0;
6689
6690 switch (message)
6691 {
6692 case WM_SYNCPAINT:
6693 break;
6694 case BM_SETSTATE:
6695 if (GetCapture())
6696 ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
6697
6698 lParam = (ULONG_PTR)GetMenu(hwnd);
6699 goto log_it;
6700
6701 case WM_GETDLGCODE:
6702 if (lParam)
6703 {
6704 MSG *msg = (MSG *)lParam;
6705 lParam = MAKELPARAM(msg->message, msg->wParam);
6706 }
6707 wParam = (ULONG_PTR)GetMenu(hwnd);
6708 goto log_it;
6709
6710 case BM_SETCHECK:
6711 case BM_GETCHECK:
6712 lParam = (ULONG_PTR)GetMenu(hwnd);
6713 /* fall through */
6714 log_it:
6715 default:
6716 msg.hwnd = hwnd;
6717 msg.message = message;
6718 msg.flags = sent|wparam|lparam;
6719 if (defwndproc_counter) msg.flags |= defwinproc;
6720 msg.wParam = wParam;
6721 msg.lParam = lParam;
6722 msg.descr = "button";
6723 add_message(&msg);
6724 }
6725
6726 defwndproc_counter++;
6727 ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
6728 defwndproc_counter--;
6729
6730 return ret;
6731 }
6732
6733 static void subclass_button(void)
6734 {
6735 WNDCLASSA cls;
6736
6737 if (!GetClassInfoA(0, "button", &cls)) assert(0);
6738
6739 old_button_proc = cls.lpfnWndProc;
6740
6741 cls.hInstance = GetModuleHandleA(NULL);
6742 cls.lpfnWndProc = button_hook_proc;
6743 cls.lpszClassName = "my_button_class";
6744 UnregisterClassA(cls.lpszClassName, cls.hInstance);
6745 if (!RegisterClassA(&cls)) assert(0);
6746 }
6747
6748 static void test_button_messages(void)
6749 {
6750 static const struct
6751 {
6752 DWORD style;
6753 DWORD dlg_code;
6754 const struct message *setfocus;
6755 const struct message *killfocus;
6756 const struct message *setstyle;
6757 const struct message *setstate;
6758 const struct message *clearstate;
6759 const struct message *setcheck;
6760 const struct message *lbuttondown;
6761 const struct message *lbuttonup;
6762 const struct message *setfont;
6763 const struct message *settext;
6764 } button[] = {
6765 { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
6766 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
6767 WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
6768 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
6769 WmSetTextButtonSeq },
6770 { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
6771 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleButtonSeq,
6772 WmSetStateButtonSeq, WmSetStateButtonSeq, WmSetCheckIgnoredSeq,
6773 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
6774 WmSetTextButtonSeq },
6775 { BS_CHECKBOX, DLGC_BUTTON,
6776 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6777 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
6778 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
6779 WmSetTextStaticSeq },
6780 { BS_AUTOCHECKBOX, DLGC_BUTTON,
6781 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6782 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
6783 WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq,
6784 WmSetTextStaticSeq },
6785 { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
6786 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6787 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
6788 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
6789 WmSetTextStaticSeq },
6790 { BS_3STATE, DLGC_BUTTON,
6791 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6792 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
6793 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
6794 WmSetTextStaticSeq },
6795 { BS_AUTO3STATE, DLGC_BUTTON,
6796 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6797 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
6798 WmLButtonDownStaticSeq, WmLButtonUpAutoSeq, WmSetFontStaticSeq,
6799 WmSetTextStaticSeq },
6800 { BS_GROUPBOX, DLGC_STATIC,
6801 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6802 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckIgnoredSeq,
6803 WmLButtonDownStaticSeq, WmLButtonUpStaticSeq, WmSetFontStaticSeq,
6804 WmSetTextGroupSeq },
6805 { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
6806 WmSetFocusButtonSeq, WmKillFocusButtonSeq, WmSetStyleUserSeq,
6807 WmSetStateUserSeq, WmClearStateButtonSeq, WmSetCheckIgnoredSeq,
6808 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
6809 WmSetTextButtonSeq },
6810 { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
6811 WmSetFocusStaticSeq, WmKillFocusStaticSeq, WmSetStyleStaticSeq,
6812 WmSetStateStaticSeq, WmSetStateStaticSeq, WmSetCheckStaticSeq,
6813 NULL /* avoid infinite loop */, WmLButtonUpBrokenSeq, WmSetFontStaticSeq,
6814 WmSetTextStaticSeq },
6815 { BS_OWNERDRAW, DLGC_BUTTON,
6816 WmSetFocusOwnerdrawSeq, WmKillFocusOwnerdrawSeq, WmSetStyleOwnerdrawSeq,
6817 WmSetStateOwnerdrawSeq, WmClearStateOwnerdrawSeq, WmSetCheckIgnoredSeq,
6818 WmLButtonDownSeq, WmLButtonUpSeq, WmSetFontButtonSeq,
6819 WmSetTextButtonSeq },
6820 };
6821 LOGFONTA logfont = { 0 };
6822 HFONT zfont, hfont2;
6823 unsigned int i;
6824 HWND hwnd, parent;
6825 DWORD dlg_code;
6826
6827 /* selection with VK_SPACE should capture button window */
6828 hwnd = CreateWindowExA(0, "button", "test", BS_CHECKBOX | WS_VISIBLE | WS_POPUP,
6829 0, 0, 50, 14, 0, 0, 0, NULL);
6830 ok(hwnd != 0, "Failed to create button window\n");
6831 ReleaseCapture();
6832 SetFocus(hwnd);
6833 SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
6834 ok(GetCapture() == hwnd, "Should be captured on VK_SPACE WM_KEYDOWN\n");
6835 SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
6836 DestroyWindow(hwnd);
6837
6838 subclass_button();
6839
6840 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6841 100, 100, 200, 200, 0, 0, 0, NULL);
6842 ok(parent != 0, "Failed to create parent window\n");
6843
6844 memset(&logfont, 0, sizeof(logfont));
6845 logfont.lfHeight = -12;
6846 logfont.lfWeight = FW_NORMAL;
6847 strcpy(logfont.lfFaceName, "Tahoma");
6848
6849 hfont2 = CreateFontIndirectA(&logfont);
6850 ok(hfont2 != NULL, "Failed to create Tahoma font\n");
6851
6852 for (i = 0; i < ARRAY_SIZE(button); i++)
6853 {
6854 MSG msg;
6855 DWORD style, state;
6856 HFONT prevfont;
6857 char desc[64];
6858 HDC hdc;
6859
6860 if (winetest_debug > 1) trace("button style %08lx\n", button[i].style);
6861
6862 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_CHILD | BS_NOTIFY,
6863 0, 0, 50, 14, parent, (HMENU)ID_BUTTON, 0, NULL);
6864 ok(hwnd != 0, "Failed to create button window\n");
6865
6866 style = GetWindowLongA(hwnd, GWL_STYLE);
6867 style &= ~(WS_CHILD | BS_NOTIFY);
6868 /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
6869 if (button[i].style == BS_USERBUTTON)
6870 ok(style == BS_PUSHBUTTON, "expected style BS_PUSHBUTTON got %lx\n", style);
6871 else
6872 ok(style == button[i].style, "expected style %lx got %lx\n", button[i].style, style);
6873
6874 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
6875 ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08lx\n", i, dlg_code);
6876
6877 ShowWindow(hwnd, SW_SHOW);
6878 UpdateWindow(hwnd);
6879 SetFocus(0);
6880 flush_events();
6881 SetFocus(0);
6882 flush_sequence();
6883
6884 log_all_parent_messages++;
6885
6886 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
6887 SetFocus(hwnd);
6888 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6889 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6890 ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
6891
6892 SetFocus(0);
6893 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6894 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6895 ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
6896
6897 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
6898
6899 SendMessageA(hwnd, BM_SETSTYLE, button[i].style | BS_BOTTOM, TRUE);
6900 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6901 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6902 ok_sequence(button[i].setstyle, "BM_SETSTYLE on a button", FALSE);
6903
6904 style = GetWindowLongA(hwnd, GWL_STYLE);
6905 style &= ~(WS_VISIBLE | WS_CHILD | BS_NOTIFY);
6906 /* XP doesn't turn a BS_USERBUTTON into BS_PUSHBUTTON here! */
6907 ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
6908
6909 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
6910 ok(state == 0, "expected state 0, got %04lx\n", state);
6911
6912 flush_sequence();
6913
6914 SendMessageA(hwnd, BM_SETSTATE, TRUE, 0);
6915 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6916 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6917 ok_sequence(button[i].setstate, "BM_SETSTATE/TRUE on a button", FALSE);
6918
6919 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
6920 ok(state == 0x0004, "expected state 0x0004, got %04lx\n", state);
6921
6922 style = GetWindowLongA(hwnd, GWL_STYLE);
6923 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
6924 ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
6925
6926 flush_sequence();
6927
6928 SendMessageA(hwnd, BM_SETSTATE, FALSE, 0);
6929 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6930 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6931 ok_sequence(button[i].clearstate, "BM_SETSTATE/FALSE on a button", FALSE);
6932
6933 state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
6934 ok(state == 0, "expected state 0, got %04lx\n", state);
6935
6936 style = GetWindowLongA(hwnd, GWL_STYLE);
6937 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
6938 ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
6939
6940 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
6941 ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04lx\n", state);
6942
6943 flush_sequence();
6944
6945 SendMessageA(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
6946 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6947 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6948 ok_sequence(WmSetCheckIgnoredSeq, "BM_SETCHECK on a button", FALSE);
6949
6950 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
6951 ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04lx\n", state);
6952
6953 style = GetWindowLongA(hwnd, GWL_STYLE);
6954 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
6955 ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
6956
6957 flush_sequence();
6958
6959 SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0);
6960 SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
6961 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6962 ok_sequence(button[i].setcheck, "BM_SETCHECK on a button", FALSE);
6963
6964 SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 1");
6965 sprintf(desc, "button[%i]: WM_SETTEXT on a visible button", i);
6966 ok_sequence(button[i].settext, desc, FALSE);
6967
6968 ShowWindow(hwnd, SW_HIDE);
6969 flush_events();
6970 flush_sequence();
6971
6972 SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 2");
6973 sprintf(desc, "button[%i]: WM_SETTEXT on an invisible button", i);
6974 ok_sequence(WmSetTextInvisibleSeq, desc, FALSE);
6975
6976 ShowWindow(hwnd, SW_SHOW);
6977 ShowWindow(parent, SW_HIDE);
6978 flush_events();
6979 flush_sequence();
6980
6981 SendMessageA(hwnd, WM_SETTEXT, 0, (LPARAM)"Text 3");
6982 sprintf(desc, "button[%i]: WM_SETTEXT on an invisible button", i);
6983 ok_sequence(WmSetTextInvisibleSeq, desc, FALSE);
6984
6985 ShowWindow(parent, SW_SHOW);
6986 flush_events();
6987
6988 state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
6989 if (button[i].style == BS_PUSHBUTTON ||
6990 button[i].style == BS_DEFPUSHBUTTON ||
6991 button[i].style == BS_GROUPBOX ||
6992 button[i].style == BS_USERBUTTON ||
6993 button[i].style == BS_OWNERDRAW)
6994 ok(state == BST_UNCHECKED, "expected check 0, got %04lx\n", state);
6995 else
6996 ok(state == BST_CHECKED, "expected check 1, got %04lx\n", state);
6997
6998 style = GetWindowLongA(hwnd, GWL_STYLE);
6999 style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
7000 if (button[i].style == BS_RADIOBUTTON ||
7001 button[i].style == BS_AUTORADIOBUTTON)
7002 ok(style == (button[i].style | WS_TABSTOP), "expected style %04lx | WS_TABSTOP got %04lx\n", button[i].style, style);
7003 else
7004 ok(style == button[i].style, "expected style %04lx got %04lx\n", button[i].style, style);
7005
7006 log_all_parent_messages--;
7007
7008 DestroyWindow(hwnd);
7009
7010 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP | WS_VISIBLE,
7011 0, 0, 50, 14, 0, 0, 0, NULL);
7012 ok(hwnd != 0, "Failed to create button window\n");
7013
7014 SetForegroundWindow(hwnd);
7015 flush_events();
7016
7017 SetActiveWindow(hwnd);
7018 SetFocus(0);
7019 flush_sequence();
7020
7021 if (button[i].lbuttondown)
7022 {
7023 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
7024 sprintf(desc, "button[%i]: WM_LBUTTONDOWN on a button", i);
7025 ok_sequence(button[i].lbuttondown, desc, FALSE);
7026 }
7027
7028 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
7029 sprintf(desc, "button[%i]: WM_LBUTTONUP on a button", i);
7030 ok_sequence(button[i].lbuttonup, desc, FALSE);
7031
7032 flush_sequence();
7033 zfont = GetStockObject(DEFAULT_GUI_FONT);
7034 SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
7035 UpdateWindow(hwnd);
7036 sprintf(desc, "button[%i]: WM_SETFONT on a button", i);
7037 ok_sequence(button[i].setfont, desc, FALSE);
7038
7039 /* Test that original font is not selected back after painting */
7040 hdc = CreateCompatibleDC(0);
7041
7042 prevfont = SelectObject(hdc, hfont2);
7043 ok(prevfont == GetStockObject(SYSTEM_FONT), "Unexpected default font\n");
7044 SendMessageA(hwnd, WM_PRINTCLIENT, (WPARAM)hdc, 0);
7045 ok(hfont2 != GetCurrentObject(hdc, OBJ_FONT), "button[%u]: unexpected font selected after WM_PRINTCLIENT\n", i);
7046 SelectObject(hdc, prevfont);
7047
7048 prevfont = SelectObject(hdc, hfont2);
7049 ok(prevfont == GetStockObject(SYSTEM_FONT), "Unexpected default font\n");
7050 SendMessageA(hwnd, WM_PAINT, (WPARAM)hdc, 0);
7051 ok(hfont2 != GetCurrentObject(hdc, OBJ_FONT), "button[%u]: unexpected font selected after WM_PAINT\n", i);
7052 SelectObject(hdc, prevfont);
7053
7054 DeleteDC(hdc);
7055
7056 DestroyWindow(hwnd);
7057 }
7058
7059 DeleteObject(hfont2);
7060 DestroyWindow(parent);
7061
7062 /* Test if WM_LBUTTONDOWN and WM_LBUTTONUP to a disabled button leads to a WM_COMMAND for the parent */
7063
7064 parent = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7065 100, 100, 200, 200, 0, 0, 0, NULL);
7066 ok (hwnd != 0, "Failed to create overlapped window\n");
7067
7068 hwnd = CreateWindowExA(0, "my_button_class", "test", BS_DEFPUSHBUTTON | WS_VISIBLE | WS_CHILD,
7069 0, 0, 50, 14, parent, 0, 0, NULL);
7070
7071 EnableWindow(hwnd, FALSE);
7072 flush_sequence();
7073 SendMessageA(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, 0);
7074 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
7075 ok_sequence(WmDisableButtonSeq, "Mouseclick on a disabled button", FALSE);
7076
7077 DestroyWindow(hwnd);
7078 DestroyWindow(parent);
7079 }
7080
7081 static void test_button_bm_get_set_image(void)
7082 {
7083 HWND hwnd;
7084 HDC hdc;
7085 HBITMAP hbmp1x1;
7086 HBITMAP hbmp2x2;
7087 HBITMAP hmask2x2;
7088 ICONINFO icon_info2x2;
7089 HICON hicon2x2;
7090 HBITMAP hbmp;
7091 HICON hicon;
7092 ICONINFO icon_info;
7093 BITMAP bm;
7094 DWORD default_style = BS_PUSHBUTTON | WS_TABSTOP | WS_POPUP | WS_VISIBLE;
7095 LRESULT ret;
7096
7097 hdc = GetDC(0);
7098 hbmp1x1 = CreateCompatibleBitmap(hdc, 1, 1);
7099 hbmp2x2 = CreateCompatibleBitmap(hdc, 2, 2);
7100 ZeroMemory(&bm, sizeof(bm));
7101 ok(GetObjectW(hbmp1x1, sizeof(bm), &bm), "Expect GetObjectW() success\n");
7102 ok(bm.bmWidth == 1 && bm.bmHeight == 1, "Expect bitmap size: %d,%d, got: %d,%d\n", 1, 1,
7103 bm.bmWidth, bm.bmHeight);
7104 ZeroMemory(&bm, sizeof(bm));
7105 ok(GetObjectW(hbmp2x2, sizeof(bm), &bm), "Expect GetObjectW() success\n");
7106 ok(bm.bmWidth == 2 && bm.bmHeight == 2, "Expect bitmap size: %d,%d, got: %d,%d\n", 2, 2,
7107 bm.bmWidth, bm.bmHeight);
7108
7109 hmask2x2 = CreateCompatibleBitmap(hdc, 2, 2);
7110 ZeroMemory(&icon_info2x2, sizeof(icon_info2x2));
7111 icon_info2x2.fIcon = TRUE;
7112 icon_info2x2.hbmMask = hmask2x2;
7113 icon_info2x2.hbmColor = hbmp2x2;
7114 hicon2x2 = CreateIconIndirect(&icon_info2x2);
7115
7116 ZeroMemory(&icon_info, sizeof(icon_info));
7117 ok(GetIconInfo(hicon2x2, &icon_info), "Expect GetIconInfo() success\n");
7118 ZeroMemory(&bm, sizeof(bm));
7119 ok(GetObjectW(icon_info.hbmColor, sizeof(bm), &bm), "Expect GetObjectW() success\n");
7120 ok(bm.bmWidth == 2 && bm.bmHeight == 2, "Expect bitmap size: %d,%d, got: %d,%d\n", 2, 2,
7121 bm.bmWidth, bm.bmHeight);
7122 DeleteObject(icon_info.hbmColor);
7123 DeleteObject(icon_info.hbmMask);
7124
7125 /* Set bitmap with BS_BITMAP */
7126 hwnd = CreateWindowA("Button", "test", default_style | BS_BITMAP, 0, 0, 100, 100, 0, 0, 0, 0);
7127 ok(hwnd != NULL, "Expect hwnd not NULL\n");
7128 SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp1x1);
7129 hbmp = (HBITMAP)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_BITMAP, 0);
7130 ok(hbmp != 0, "Expect hbmp not 0\n");
7131 ZeroMemory(&bm, sizeof(bm));
7132 ok(GetObjectW(hbmp, sizeof(bm), &bm), "Expect GetObjectW() success\n");
7133 ok(bm.bmWidth == 1 && bm.bmHeight == 1, "Expect bitmap size: %d,%d, got: %d,%d\n", 1, 1,
7134 bm.bmWidth, bm.bmHeight);
7135 DestroyWindow(hwnd);
7136
7137 /* Set bitmap without BS_BITMAP */
7138 hwnd = CreateWindowA("Button", "test", default_style, 0, 0, 100, 100, 0, 0, 0, 0);
7139 ok(hwnd != NULL, "Expect hwnd not NULL\n");
7140 ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp1x1);
7141 ok(ret == 0, "Expect ret to be 0\n");
7142 hbmp = (HBITMAP)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_BITMAP, 0);
7143 ok(hbmp == NULL, "Expect hbmp to be NULL\n");
7144 DestroyWindow(hwnd);
7145
7146 /* Set icon with BS_ICON */
7147 hwnd = CreateWindowA("Button", "test", default_style | BS_ICON, 0, 0, 100, 100, 0, 0, 0, 0);
7148 ok(hwnd != NULL, "Expect hwnd not NULL\n");
7149 SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hicon2x2);
7150 hicon = (HICON)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_ICON, 0);
7151 ok(hicon != NULL, "Expect hicon not NULL\n");
7152 ZeroMemory(&icon_info, sizeof(icon_info));
7153 ok(GetIconInfo(hicon, &icon_info), "Expect GetIconInfo() success\n");
7154 ZeroMemory(&bm, sizeof(bm));
7155 ok(GetObjectW(icon_info.hbmColor, sizeof(bm), &bm), "Expect GetObjectW() success\n");
7156 ok(bm.bmWidth == 2 && bm.bmHeight == 2, "Expect bitmap size: %d,%d, got: %d,%d\n", 2, 2,
7157 bm.bmWidth, bm.bmHeight);
7158 DeleteObject(icon_info.hbmColor);
7159 DeleteObject(icon_info.hbmMask);
7160 DestroyWindow(hwnd);
7161
7162 /* Set icon without BS_ICON */
7163 hwnd = CreateWindowA("Button", "test", default_style, 0, 0, 100, 100, 0, 0, 0, 0);
7164 ok(hwnd != NULL, "Expect hwnd not NULL\n");
7165 ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hicon2x2);
7166 ok(ret == 0, "Expect ret to be 0\n");
7167 hicon = (HICON)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_ICON, 0);
7168 ok(hicon == NULL, "Expect hicon to be NULL\n");
7169 DestroyWindow(hwnd);
7170
7171 /* Set icon with BS_BITMAP */
7172 hwnd = CreateWindowA("Button", "test", default_style | BS_BITMAP, 0, 0, 100, 100, 0, 0, 0, 0);
7173 ok(hwnd != NULL, "Expect hwnd to be not NULL\n");
7174 ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)hicon2x2);
7175 ok(ret == 0, "Expect ret to be 0\n");
7176 hicon = (HICON)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_ICON, 0);
7177 ok(hicon == NULL, "Expect hicon to be NULL\n");
7178 DestroyWindow(hwnd);
7179
7180 /* Set bitmap with BS_ICON */
7181 hwnd = CreateWindowA("Button", "test", default_style | BS_ICON, 0, 0, 100, 100, 0, 0, 0, 0);
7182 ok(hwnd != NULL, "Expect hwnd to be not NULL\n");
7183 ret = SendMessageA(hwnd, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp1x1);
7184 ok(ret == 0, "Expect ret to be 0\n");
7185 hbmp = (HBITMAP)SendMessageA(hwnd, BM_GETIMAGE, (WPARAM)IMAGE_BITMAP, 0);
7186 ok(hbmp == NULL, "Expect hbmp to be NULL\n");
7187 DestroyWindow(hwnd);
7188
7189 DestroyIcon(hicon2x2);
7190 DeleteObject(hmask2x2);
7191 DeleteObject(hbmp2x2);
7192 DeleteObject(hbmp1x1);
7193 ReleaseDC(0, hdc);
7194 }
7195
7196 #define ID_RADIO1 501
7197 #define ID_RADIO2 502
7198 #define ID_RADIO3 503
7199 #define ID_TEXT 504
7200
7201 static const struct message auto_radio_button_BM_CLICK[] =
7202 {
7203 { BM_CLICK, sent|wparam|lparam, 0, 0 },
7204 { WM_LBUTTONDOWN, sent|wparam|lparam|defwinproc, 0, 0 },
7205 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
7206 { BM_SETSTATE, sent|wparam|lparam|defwinproc, BST_CHECKED, ID_RADIO2 },
7207 { WM_CTLCOLORSTATIC, sent|parent },
7208 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7209 { WM_LBUTTONUP, sent|wparam|lparam|defwinproc, 0, 0 },
7210 { BM_SETSTATE, sent|wparam|lparam|defwinproc, BST_UNCHECKED, ID_RADIO2 },
7211 { WM_CTLCOLORSTATIC, sent|parent },
7212 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7213 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_RADIO2, 0 },
7214 { BM_SETCHECK, sent|wparam|lparam|defwinproc, BST_CHECKED, ID_RADIO2 },
7215 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_RADIO1, 0 },
7216 { BM_SETCHECK, sent|wparam|lparam|defwinproc, 0, ID_RADIO1 },
7217 { WM_CTLCOLORSTATIC, sent|parent },
7218 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7219 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_RADIO3, 0 },
7220 { BM_SETCHECK, sent|wparam|lparam|defwinproc, 0, ID_RADIO3 },
7221 { WM_CTLCOLORSTATIC, sent|parent },
7222 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7223 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_TEXT, 0 },
7224 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
7225 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
7226 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_RADIO2, BN_CLICKED) },
7227 { WM_NCHITTEST, sent|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
7228 { WM_SETCURSOR, sent|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
7229 { WM_MOUSEMOVE, sent|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
7230 { 0 }
7231 };
7232
7233 static const struct message auto_radio_button_VK_UP_child[] =
7234 {
7235 { WM_KEYDOWN, sent|wparam|lparam, VK_UP, 0 },
7236 { WM_KEYUP, sent|wparam|lparam, VK_UP, 0 },
7237 { 0 }
7238 };
7239
7240 static const struct message auto_radio_button_VK_UP_parent[] =
7241 {
7242 { WM_KEYDOWN, sent|wparam|lparam|parent, VK_UP, 0 },
7243 { WM_KEYUP, sent|wparam|lparam|parent, VK_UP, 0 },
7244 { 0 }
7245 };
7246
7247 static const struct message auto_radio_button_VK_UP_dialog[] =
7248 {
7249 { WM_GETDLGCODE, sent|parent, 0, 0 },
7250
7251 /* optional trailer seen on some windows setups */
7252 { WM_CHANGEUISTATE, sent|optional },
7253 { WM_UPDATEUISTATE, sent|optional },
7254 { WM_UPDATEUISTATE, sent|optional },
7255 { WM_UPDATEUISTATE, sent|optional },
7256 { WM_UPDATEUISTATE, sent|optional },
7257 { WM_UPDATEUISTATE, sent|optional },
7258 { WM_UPDATEUISTATE, sent|optional },
7259 { WM_UPDATEUISTATE, sent|optional },
7260 { WM_UPDATEUISTATE, sent|optional },
7261 { WM_UPDATEUISTATE, sent|optional },
7262 { WM_UPDATEUISTATE, sent|optional },
7263 { WM_UPDATEUISTATE, sent|optional },
7264 { WM_UPDATEUISTATE, sent|optional },
7265 { WM_UPDATEUISTATE, sent|optional },
7266 { WM_UPDATEUISTATE, sent|optional },
7267 { WM_UPDATEUISTATE, sent|optional },
7268 { WM_UPDATEUISTATE, sent|optional },
7269 { WM_UPDATEUISTATE, sent|optional },
7270 { WM_UPDATEUISTATE, sent|optional },
7271 { WM_CTLCOLORSTATIC, sent|parent|optional },
7272 { WM_CTLCOLORSTATIC, sent|parent|optional },
7273 { WM_CTLCOLORSTATIC, sent|parent|optional },
7274 { WM_UPDATEUISTATE, sent|optional },
7275 { WM_CTLCOLORSTATIC, sent|parent|optional },
7276 { WM_CTLCOLORSTATIC, sent|parent|optional },
7277 { WM_UPDATEUISTATE, sent|optional },
7278 { WM_CTLCOLORBTN, sent|parent|optional },
7279 { WM_CTLCOLORBTN, sent|parent|optional },
7280 { WM_UPDATEUISTATE, sent|optional },
7281 { WM_CTLCOLORSTATIC, sent|parent|optional },
7282 { WM_CTLCOLORSTATIC, sent|parent|optional },
7283 { 0 }
7284 };
7285
7286 static const struct message auto_radio_button_VK_DOWN_dialog[] =
7287 {
7288 { WM_GETDLGCODE, sent|parent, 0, 0 },
7289 { WM_GETDLGCODE, sent|wparam|lparam, ID_RADIO1, MAKELPARAM(WM_KEYDOWN, VK_DOWN) },
7290 { WM_GETDLGCODE, sent|wparam|lparam, ID_RADIO1, 0 },
7291 { HCBT_SETFOCUS, hook },
7292 { WM_KILLFOCUS, sent, 0, 0 },
7293 { WM_CTLCOLORSTATIC, sent|parent },
7294 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_RADIO3, BN_KILLFOCUS) },
7295 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
7296 { WM_SETFOCUS, sent, 0, 0 },
7297 { WM_CTLCOLORSTATIC, sent|parent },
7298 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_RADIO1, BN_SETFOCUS) },
7299 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_RADIO1, BN_CLICKED) },
7300 { WM_GETDLGCODE, sent|wparam|lparam, ID_RADIO1, 0 },
7301 { WM_GETDLGCODE, sent|parent, 0, 0 },
7302 { DM_GETDEFID, sent|parent, 0, 0 },
7303 { BM_GETCHECK, sent|wparam|lparam, 0, ID_RADIO1 },
7304 { BM_CLICK, sent|wparam|lparam, 1, 0 },
7305 { WM_LBUTTONDOWN, sent|wparam|lparam|defwinproc, 0, 0 },
7306 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
7307 { BM_SETSTATE, sent|wparam|lparam|defwinproc, BST_CHECKED, ID_RADIO1 },
7308 { WM_CTLCOLORSTATIC, sent|parent },
7309 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7310 { WM_LBUTTONUP, sent|wparam|lparam|defwinproc, 0, 0 },
7311 { BM_SETSTATE, sent|wparam|lparam|defwinproc, BST_UNCHECKED, ID_RADIO1 },
7312 { WM_CTLCOLORSTATIC, sent|parent },
7313 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7314 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_RADIO1, 0 },
7315 { BM_SETCHECK, sent|wparam|lparam|defwinproc, BST_CHECKED, ID_RADIO1 },
7316 { WM_CTLCOLORSTATIC, sent|parent },
7317 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7318 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_RADIO3, 0 },
7319 { BM_SETCHECK, sent|wparam|lparam|defwinproc, BST_UNCHECKED, ID_RADIO3 },
7320 { WM_CTLCOLORSTATIC, sent|parent },
7321 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7322 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_TEXT, 0 },
7323 { WM_GETDLGCODE, sent|wparam|lparam|defwinproc, ID_RADIO2, 0 },
7324 { BM_SETCHECK, sent|wparam|lparam|defwinproc, BST_UNCHECKED, ID_RADIO2 },
7325 { WM_CTLCOLORSTATIC, sent|parent },
7326 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
7327 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
7328 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
7329 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_RADIO1, BN_CLICKED) },
7330 { WM_NCHITTEST, sent|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
7331 { WM_SETCURSOR, sent|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
7332 { WM_MOUSEMOVE, sent|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
7333 { WM_PAINT, sent },
7334 { WM_CTLCOLORSTATIC, sent|parent },
7335 { 0 }
7336 };
7337
7338 static const struct message auto_radio_button_VK_DOWN_radio3[] =
7339 {
7340 { BM_GETCHECK, sent|wparam|lparam, 0, ID_RADIO1 },
7341 { BM_GETCHECK, sent|wparam|lparam, 0, ID_RADIO2 },
7342 { BM_GETCHECK, sent|wparam|lparam, 0, ID_RADIO3 },
7343 { WM_GETDLGCODE, sent|parent, 0, 0 },
7344 { WM_GETDLGCODE, sent|wparam|lparam, ID_RADIO1, MAKELPARAM(WM_KEYDOWN, VK_DOWN) },
7345 { WM_GETDLGCODE, sent|wparam|lparam, ID_RADIO1, 0 },
7346 { WM_GETDLGCODE, sent|wparam|lparam, ID_RADIO1, 0 },
7347 { WM_GETDLGCODE, sent|wparam|lparam|parent, 0, 0 },
7348 { WM_USER, sent|parent, 0, 0 },
7349 { BM_GETCHECK, sent|wparam|lparam, 0, ID_RADIO1 },
7350 { 0 }
7351 };
7352
7353 static const struct message auto_radio_button_VK_UP_radio1[] =
7354 {
7355 { WM_GETDLGCODE, sent|parent, 0, 0 },
7356 { 0 }
7357 };
7358
7359 static INT_PTR WINAPI radio_test_dlg_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
7360 {
7361 ParentMsgCheckProcA(hwnd, msg, wp, lp);
7362 return 1;
7363 }
7364
7365 static void test_autoradio_BM_CLICK(void)
7366 {
7367 HWND parent, radio1, radio2, radio3;
7368 RECT rc;
7369 MSG msg;
7370 DWORD ret;
7371
7372 subclass_button();
7373
7374 parent = CreateDialogParamA(0, "AUTORADIO_TEST_DIALOG_1", 0, radio_test_dlg_proc, 0);
7375 ok(parent != 0, "failed to create parent window\n");
7376
7377 radio1 = GetDlgItem(parent, ID_RADIO1);
7378 radio2 = GetDlgItem(parent, ID_RADIO2);
7379 radio3 = GetDlgItem(parent, ID_RADIO3);
7380
7381 /* this avoids focus messages in the generated sequence */
7382 SetFocus(radio2);
7383
7384 flush_events();
7385 flush_sequence();
7386
7387 ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
7388 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7389 ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
7390 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7391 ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
7392 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7393
7394 SendMessageA(radio1, BM_SETCHECK, BST_CHECKED, 0);
7395
7396 ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
7397 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7398 ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
7399 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7400 ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
7401 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7402
7403 SendMessageA(radio2, BM_SETCHECK, BST_CHECKED, 0);
7404
7405 ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
7406 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7407 ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
7408 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7409 ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
7410 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7411
7412 SendMessageA(radio3, BM_SETCHECK, BST_CHECKED, 0);
7413
7414 ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
7415 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7416 ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
7417 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7418 ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
7419 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7420
7421 GetWindowRect(radio2, &rc);
7422 SetCursorPos(rc.left+1, rc.top+1);
7423
7424 flush_events();
7425 flush_sequence();
7426
7427 log_all_parent_messages++;
7428
7429 SendMessageA(radio2, BM_CLICK, 0, 0);
7430 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7431 ok_sequence(auto_radio_button_BM_CLICK, "BM_CLICK on auto-radio button", FALSE);
7432
7433 log_all_parent_messages--;
7434
7435 ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
7436 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7437 ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
7438 ok(ret == BST_CHECKED, "got %08lx\n", ret);
7439 ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
7440 ok(ret == BST_UNCHECKED, "got %08lx\n", ret);
7441
7442 DestroyWindow(parent);
7443 }
7444
7445 #define test_radio(r1, s1, r2, s2, r3, s3) test_radio_dbg(r1, s1, r2, s2, r3, s3, __LINE__)
7446 static void test_radio_dbg(HWND radio1, int state1, HWND radio2, int state2, HWND radio3, int state3, int line)
7447 {
7448 DWORD ret;
7449
7450 ret = SendMessageA(radio1, BM_GETCHECK, 0, 0);
7451 ok_(__FILE__,line)(ret == state1 ? BST_CHECKED : BST_UNCHECKED, "got %08lx\n", ret);
7452 ret = SendMessageA(radio2, BM_GETCHECK, 0, 0);
7453 ok_(__FILE__,line)(ret == state2 ? BST_CHECKED : BST_UNCHECKED, "got %08lx\n", ret);
7454 ret = SendMessageA(radio3, BM_GETCHECK, 0, 0);
7455 ok_(__FILE__,line)(ret == state3 ? BST_CHECKED : BST_UNCHECKED, "got %08lx\n", ret);
7456 }
7457
7458 static void set_radio(HWND radio1, int state1, HWND radio2, int state2, HWND radio3, int state3)
7459 {
7460 SendMessageA(radio1, BM_SETCHECK, state1 ? BST_CHECKED : BST_UNCHECKED, 0);
7461 SendMessageA(radio2, BM_SETCHECK, state2 ? BST_CHECKED : BST_UNCHECKED, 0);
7462 SendMessageA(radio3, BM_SETCHECK, state3 ? BST_CHECKED : BST_UNCHECKED, 0);
7463 }
7464
7465 static void test_autoradio_kbd_move(void)
7466 {
7467 HWND parent, radio1, radio2, radio3, hwnd;
7468 RECT rc;
7469 MSG msg;
7470 DWORD ret;
7471
7472 subclass_button();
7473
7474 parent = CreateDialogParamA(0, "AUTORADIO_TEST_DIALOG_2", 0, radio_test_dlg_proc, 0);
7475 ok(parent != 0, "failed to create parent window\n");
7476
7477 radio1 = GetDlgItem(parent, ID_RADIO1);
7478 radio2 = GetDlgItem(parent, ID_RADIO2);
7479 radio3 = GetDlgItem(parent, ID_RADIO3);
7480
7481 flush_events();
7482 flush_sequence();
7483
7484 test_radio(radio1, 0, radio2, 0, radio3, 0);
7485 set_radio(radio1, 1, radio2, 1, radio3, 1);
7486 test_radio(radio1, 1, radio2, 1, radio3, 1);
7487
7488 SetFocus(radio3);
7489
7490 flush_events();
7491 flush_sequence();
7492
7493 log_all_parent_messages++;
7494
7495 SendMessageA(radio3, WM_KEYDOWN, VK_UP, 0);
7496 SendMessageA(radio3, WM_KEYUP, VK_UP, 0);
7497 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7498 ok_sequence(auto_radio_button_VK_UP_child, "press/release VK_UP on auto-radio button", FALSE);
7499
7500 test_radio(radio1, 1, radio2, 1, radio3, 1);
7501
7502 flush_events();
7503 flush_sequence();
7504
7505 DefDlgProcA(parent, WM_KEYDOWN, VK_UP, 0);
7506 DefDlgProcA(parent, WM_KEYUP, VK_UP, 0);
7507 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7508 ok_sequence(auto_radio_button_VK_UP_parent, "press/release VK_UP on dialog", FALSE);
7509
7510 test_radio(radio1, 1, radio2, 1, radio3, 1);
7511
7512 SetFocus(radio3);
7513 GetWindowRect(radio3, &rc);
7514
7515 flush_events();
7516 flush_sequence();
7517
7518 msg.hwnd = parent;
7519 msg.message = WM_KEYDOWN;
7520 msg.wParam = VK_UP;
7521 msg.lParam = 0;
7522 msg.pt.x = rc.left + 1;
7523 msg.pt.y = rc.top + 1;
7524 ret = IsDialogMessageA(parent, &msg);
7525 ok(ret, "IsDialogMessage should return TRUE\n");
7526 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7527 if (0) /* actual message sequence is different on every run in some Windows setups */
7528 ok_sequence(auto_radio_button_VK_UP_dialog, "IsDialogMessage(VK_UP) #1", FALSE);
7529 /* what really matters is that nothing has changed */
7530 test_radio(radio1, 1, radio2, 1, radio3, 1);
7531
7532 set_radio(radio1, 0, radio2, 1, radio3, 1);
7533 test_radio(radio1, 0, radio2, 1, radio3, 1);
7534
7535 flush_events();
7536 flush_sequence();
7537
7538 ret = IsDialogMessageA(parent, &msg);
7539 ok(ret, "IsDialogMessage should return TRUE\n");
7540 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7541 if (0) /* actual message sequence is different on every run in some Windows setups */
7542 ok_sequence(auto_radio_button_VK_UP_dialog, "IsDialogMessage(VK_UP) #2", FALSE);
7543 /* what really matters is that nothing has changed */
7544 test_radio(radio1, 0, radio2, 1, radio3, 1);
7545
7546 /* switch from radio3 ro radio1 */
7547 SetFocus(radio3);
7548 GetWindowRect(radio3, &rc);
7549
7550 flush_events();
7551 flush_sequence();
7552
7553 msg.hwnd = parent;
7554 msg.message = WM_KEYDOWN;
7555 msg.wParam = VK_DOWN;
7556 msg.lParam = 0;
7557 msg.pt.x = rc.left + 1;
7558 msg.pt.y = rc.top + 1;
7559 ret = IsDialogMessageA(parent, &msg);
7560 ok(ret, "IsDialogMessage should return TRUE\n");
7561 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7562 ok_sequence(auto_radio_button_VK_DOWN_dialog, "IsDialogMessage(VK_DOWN)", TRUE);
7563
7564 test_radio(radio1, 1, radio2, 0, radio3, 0);
7565
7566 hwnd = GetFocus();
7567 ok(hwnd == radio1, "focus should be on radio1, not on %p\n", hwnd);
7568 GetWindowRect(radio1, &rc);
7569
7570 msg.hwnd = parent;
7571 msg.message = WM_KEYDOWN;
7572 msg.wParam = VK_DOWN;
7573 msg.lParam = 0;
7574 msg.pt.x = rc.left + 1;
7575 msg.pt.y = rc.top + 1;
7576 ret = IsDialogMessageA(parent, &msg);
7577 ok(ret, "IsDialogMessage should return TRUE\n");
7578 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7579 ok_sequence(auto_radio_button_VK_DOWN_radio3, "down to radio3", TRUE);
7580
7581 test_radio(radio1, 1, radio2, 0, radio3, 0);
7582
7583 hwnd = GetFocus();
7584 ok(hwnd == radio1, "focus should be on radio1, not on %p\n", hwnd);
7585
7586 flush_events();
7587 flush_sequence();
7588
7589 msg.hwnd = parent;
7590 msg.message = WM_KEYDOWN;
7591 msg.wParam = VK_UP;
7592 msg.lParam = 0;
7593 msg.pt.x = rc.left + 1;
7594 msg.pt.y = rc.top + 1;
7595 ret = IsDialogMessageA(parent, &msg);
7596 ok(ret, "IsDialogMessage should return TRUE\n");
7597 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7598 ok_sequence(auto_radio_button_VK_UP_radio1, "up to radio1", TRUE);
7599
7600 test_radio(radio1, 1, radio2, 0, radio3, 0);
7601
7602 hwnd = GetFocus();
7603 ok(hwnd == radio1, "focus should be on radio1, not on %p\n", hwnd);
7604
7605 flush_events();
7606 flush_sequence();
7607
7608 msg.hwnd = parent;
7609 msg.message = WM_KEYDOWN;
7610 msg.wParam = VK_UP;
7611 msg.lParam = 0;
7612 msg.pt.x = rc.left + 1;
7613 msg.pt.y = rc.top + 1;
7614 ret = IsDialogMessageA(parent, &msg);
7615 ok(ret, "IsDialogMessage should return TRUE\n");
7616 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7617 if (0) /* actual message sequence is different on every run in some Windows setups */
7618 ok_sequence(auto_radio_button_VK_UP_dialog, "IsDialogMessage(VK_UP) #3", FALSE);
7619 /* what really matters is that nothing has changed */
7620 test_radio(radio1, 1, radio2, 0, radio3, 0);
7621
7622 log_all_parent_messages--;
7623
7624 DestroyWindow(parent);
7625 }
7626
7627 /****************** static message test *************************/
7628 static const struct message WmSetFontStaticSeq2[] =
7629 {
7630 { WM_SETFONT, sent },
7631 { WM_PAINT, sent|defwinproc|optional },
7632 { WM_ERASEBKGND, sent|defwinproc|optional },
7633 { WM_CTLCOLORSTATIC, sent|defwinproc|optional },
7634 { 0 }
7635 };
7636
7637 static WNDPROC old_static_proc;
7638
7639 static LRESULT CALLBACK static_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7640 {
7641 static LONG defwndproc_counter = 0;
7642 LRESULT ret;
7643 struct recvd_message msg;
7644
7645 if (ignore_message( message )) return 0;
7646
7647 msg.hwnd = hwnd;
7648 msg.message = message;
7649 msg.flags = sent|wparam|lparam;
7650 if (defwndproc_counter) msg.flags |= defwinproc;
7651 msg.wParam = wParam;
7652 msg.lParam = lParam;
7653 msg.descr = "static";
7654 add_message(&msg);
7655
7656 defwndproc_counter++;
7657 ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
7658 defwndproc_counter--;
7659
7660 return ret;
7661 }
7662
7663 static void subclass_static(void)
7664 {
7665 WNDCLASSA cls;
7666
7667 if (!GetClassInfoA(0, "static", &cls)) assert(0);
7668
7669 old_static_proc = cls.lpfnWndProc;
7670
7671 cls.hInstance = GetModuleHandleA(NULL);
7672 cls.lpfnWndProc = static_hook_proc;
7673 cls.lpszClassName = "my_static_class";
7674 UnregisterClassA(cls.lpszClassName, cls.hInstance);
7675 if (!RegisterClassA(&cls)) assert(0);
7676 }
7677
7678 static void test_static_messages(void)
7679 {
7680 /* FIXME: make as comprehensive as the button message test */
7681 static const struct
7682 {
7683 DWORD style;
7684 DWORD dlg_code;
7685 const struct message *setfont;
7686 } static_ctrl[] = {
7687 { SS_LEFT, DLGC_STATIC,
7688 WmSetFontStaticSeq2 }
7689 };
7690 unsigned int i;
7691 HWND hwnd;
7692 DWORD dlg_code;
7693
7694 subclass_static();
7695
7696 for (i = 0; i < ARRAY_SIZE(static_ctrl); i++)
7697 {
7698 hwnd = CreateWindowExA(0, "my_static_class", "test", static_ctrl[i].style | WS_POPUP,
7699 0, 0, 50, 14, 0, 0, 0, NULL);
7700 ok(hwnd != 0, "Failed to create static window\n");
7701
7702 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
7703 ok(dlg_code == static_ctrl[i].dlg_code, "%u: wrong dlg_code %08lx\n", i, dlg_code);
7704
7705 ShowWindow(hwnd, SW_SHOW);
7706 UpdateWindow(hwnd);
7707 SetFocus(0);
7708 flush_sequence();
7709
7710 if (winetest_debug > 1) trace("static style %08lx\n", static_ctrl[i].style);
7711 SendMessageA(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
7712 ok_sequence(static_ctrl[i].setfont, "WM_SETFONT on a static", FALSE);
7713
7714 DestroyWindow(hwnd);
7715 }
7716 }
7717
7718 /****************** ComboBox message test *************************/
7719 #define ID_COMBOBOX 0x000f
7720
7721 static const struct message SetCurSelComboSeq[] =
7722 {
7723 { CB_SETCURSEL, sent|wparam|lparam, 0, 0 },
7724 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
7725 { LB_SETTOPINDEX, sent|wparam|lparam, 0, 0 },
7726 { LB_GETCURSEL, sent|wparam|lparam, 0, 0 },
7727 { LB_GETTEXTLEN, sent|wparam|lparam, 0, 0 },
7728 { LB_GETTEXTLEN, sent|wparam|lparam|optional, 0, 0 }, /* TODO: it's sent on all Windows versions */
7729 { LB_GETTEXT, sent|wparam, 0 },
7730 { WM_CTLCOLOREDIT, sent|parent },
7731 { LB_GETITEMDATA, sent|wparam|lparam, 0, 0 },
7732 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_COMBOBOX, 0x100010f3 },
7733 { 0 }
7734 };
7735
7736 static const struct message SetCurSelComboSeq2[] =
7737 {
7738 { CB_SETCURSEL, sent|wparam|lparam, 0, 0 },
7739 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
7740 { LB_SETTOPINDEX, sent|wparam|lparam, 0, 0 },
7741 { LB_GETCURSEL, sent|wparam|lparam, 0, 0 },
7742 { LB_GETTEXTLEN, sent|wparam|lparam, 0, 0 },
7743 { LB_GETTEXTLEN, sent|wparam|lparam|optional, 0, 0 }, /* TODO: it's sent on all Windows versions */
7744 { LB_GETTEXT, sent|wparam, 0 },
7745 { 0 }
7746 };
7747
7748 static const struct message SetCurSelComboSeq_edit[] =
7749 {
7750 { CB_SETCURSEL, sent|wparam|lparam, 0, 0 },
7751 { WM_SETTEXT, sent|wparam, 0 },
7752 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
7753 { 0 }
7754 };
7755
7756 static const struct message WmKeyDownComboSeq[] =
7757 {
7758 { WM_KEYDOWN, sent|wparam|lparam, VK_DOWN, 0 },
7759 { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(1000, LBN_SELCHANGE) },
7760 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDOK) },
7761 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELCHANGE) },
7762 { WM_CTLCOLOREDIT, sent|parent },
7763 { WM_KEYUP, sent|wparam|lparam, VK_DOWN, 0 },
7764 { 0 }
7765 };
7766
7767 static const struct message WmSetPosComboSeq[] =
7768 {
7769 { WM_WINDOWPOSCHANGING, sent },
7770 { WM_NCCALCSIZE, sent|wparam, TRUE },
7771 { WM_CHILDACTIVATE, sent },
7772 { WM_WINDOWPOSCHANGED, sent },
7773 { WM_MOVE, sent|defwinproc },
7774 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
7775 { WM_WINDOWPOSCHANGING, sent|defwinproc },
7776 { WM_NCCALCSIZE, sent|defwinproc|wparam, TRUE },
7777 { WM_WINDOWPOSCHANGED, sent|defwinproc },
7778 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
7779 { 0 }
7780 };
7781
7782 static const struct message WMSetFocusComboBoxSeq[] =
7783 {
7784 { WM_SETFOCUS, sent },
7785 { WM_KILLFOCUS, sent|parent },
7786 { WM_SETFOCUS, sent },
7787 { WM_COMMAND, sent|defwinproc|wparam, MAKEWPARAM(1001, EN_SETFOCUS) },
7788 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, INT_MAX },
7789 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
7790 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
7791 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SETFOCUS) },
7792 { 0 }
7793 };
7794
7795 static const struct message SetFocusButtonSeq[] =
7796 {
7797 { WM_KILLFOCUS, sent },
7798 { CB_GETCOMBOBOXINFO, sent|optional },/* Windows 2000 */
7799 { 0x0167, sent|optional },/* Undocumented message. Sent on all versions except Windows 2000 */
7800 { WM_LBUTTONUP, sent|defwinproc },
7801 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDCANCEL) },
7802 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, 0 },
7803 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
7804 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
7805 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_KILLFOCUS) },
7806 { WM_CTLCOLORBTN, sent|parent },
7807 { 0 }
7808 };
7809
7810 static const struct message SetFocusComboBoxSeq[] =
7811 {
7812 { WM_CTLCOLORBTN, sent|parent },
7813 { WM_SETFOCUS, sent },
7814 { WM_KILLFOCUS, sent|defwinproc },
7815 { WM_SETFOCUS, sent },
7816 { WM_COMMAND, sent|defwinproc|wparam, MAKEWPARAM(1001, EN_SETFOCUS) },
7817 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, INT_MAX },
7818 { WM_CTLCOLOREDIT, sent|defwinproc|optional },/* Not sent on W2000, XP or Server 2003 */
7819 { WM_CTLCOLOREDIT, sent|parent|optional },/* Not sent on W2000, XP or Server 2003 */
7820 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SETFOCUS) },
7821 { 0 }
7822 };
7823
7824 static const struct message SetFocusButtonSeq2[] =
7825 {
7826 { WM_KILLFOCUS, sent },
7827 { CB_GETCOMBOBOXINFO, sent|optional },/* Windows 2000 */
7828 { 0x0167, sent|optional },/* Undocumented message. Sent on all versions except Windows 2000 */
7829 { WM_LBUTTONUP, sent|defwinproc },
7830 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDCANCEL) },
7831 { EM_SETSEL, sent|defwinproc|wparam|lparam, 0, 0 },
7832 { WM_CTLCOLOREDIT, sent|defwinproc },
7833 { WM_CTLCOLOREDIT, sent|parent },
7834 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_COMBOBOX, CBN_KILLFOCUS) },
7835 { WM_CTLCOLORBTN, sent|parent },
7836 { 0 }
7837 };
7838
7839 static WNDPROC old_combobox_proc, edit_window_proc, lbox_window_proc;
7840
7841 static LRESULT CALLBACK combobox_edit_subclass_proc(HWND hwnd, UINT message,
7842 WPARAM wParam, LPARAM lParam)
7843 {
7844 static LONG defwndproc_counter = 0;
7845 LRESULT ret;
7846 struct recvd_message msg;
7847
7848 /* do not log painting messages */
7849 if (message != WM_PAINT &&
7850 message != WM_NCPAINT &&
7851 message != WM_SYNCPAINT &&
7852 message != WM_ERASEBKGND &&
7853 message != WM_NCHITTEST &&
7854 message != WM_GETTEXT &&
7855 !ignore_message( message ))
7856 {
7857 msg.hwnd = hwnd;
7858 msg.message = message;
7859 msg.flags = sent|wparam|lparam;
7860 if (defwndproc_counter) msg.flags |= defwinproc;
7861 msg.wParam = wParam;
7862 msg.lParam = lParam;
7863 msg.descr = "combo edit";
7864 add_message(&msg);
7865 }
7866
7867 defwndproc_counter++;
7868 ret = CallWindowProcA(edit_window_proc, hwnd, message, wParam, lParam);
7869 defwndproc_counter--;
7870
7871 return ret;
7872 }
7873
7874 static LRESULT CALLBACK combobox_lbox_subclass_proc(HWND hwnd, UINT message,
7875 WPARAM wParam, LPARAM lParam)
7876 {
7877 static LONG defwndproc_counter = 0;
7878 LRESULT ret;
7879 struct recvd_message msg;
7880
7881 /* do not log painting messages */
7882 if (message != WM_PAINT &&
7883 message != WM_NCPAINT &&
7884 message != WM_SYNCPAINT &&
7885 message != WM_ERASEBKGND &&
7886 message != WM_NCHITTEST &&
7887 !ignore_message( message ))
7888 {
7889 msg.hwnd = hwnd;
7890 msg.message = message;
7891 msg.flags = sent|wparam|lparam;
7892 if (defwndproc_counter) msg.flags |= defwinproc;
7893 msg.wParam = wParam;
7894 msg.lParam = lParam;
7895 msg.descr = "combo lbox";
7896 add_message(&msg);
7897 }
7898
7899 defwndproc_counter++;
7900 ret = CallWindowProcA(lbox_window_proc, hwnd, message, wParam, lParam);
7901 defwndproc_counter--;
7902
7903 return ret;
7904 }
7905
7906 static LRESULT CALLBACK combobox_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7907 {
7908 static LONG defwndproc_counter = 0;
7909 LRESULT ret;
7910 struct recvd_message msg;
7911
7912 /* do not log painting messages */
7913 if (message != WM_PAINT &&
7914 message != WM_NCPAINT &&
7915 message != WM_SYNCPAINT &&
7916 message != WM_ERASEBKGND &&
7917 message != WM_NCHITTEST &&
7918 message != WM_GETTEXT &&
7919 !ignore_message( message ))
7920 {
7921 msg.hwnd = hwnd;
7922 msg.message = message;
7923 msg.flags = sent|wparam|lparam;
7924 if (defwndproc_counter) msg.flags |= defwinproc;
7925 msg.wParam = wParam;
7926 msg.lParam = lParam;
7927 msg.descr = "combo";
7928 add_message(&msg);
7929 }
7930
7931 defwndproc_counter++;
7932 ret = CallWindowProcA(old_combobox_proc, hwnd, message, wParam, lParam);
7933 defwndproc_counter--;
7934
7935 return ret;
7936 }
7937
7938 static void subclass_combobox(void)
7939 {
7940 WNDCLASSA cls;
7941
7942 if (!GetClassInfoA(0, "ComboBox", &cls)) assert(0);
7943
7944 old_combobox_proc = cls.lpfnWndProc;
7945
7946 cls.hInstance = GetModuleHandleA(NULL);
7947 cls.lpfnWndProc = combobox_hook_proc;
7948 cls.lpszClassName = "my_combobox_class";
7949 UnregisterClassA(cls.lpszClassName, cls.hInstance);
7950 if (!RegisterClassA(&cls)) assert(0);
7951 }
7952
7953 static void test_combobox_messages(void)
7954 {
7955 HWND parent, combo, button, edit, lbox;
7956 LRESULT ret;
7957 COMBOBOXINFO cbInfo;
7958 BOOL res;
7959
7960 subclass_combobox();
7961
7962 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7963 100, 100, 200, 200, 0, 0, 0, NULL);
7964 ok(parent != 0, "Failed to create parent window\n");
7965 flush_sequence();
7966
7967 combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | CBS_HASSTRINGS,
7968 0, 0, 100, 150, parent, (HMENU)ID_COMBOBOX, 0, NULL);
7969 ok(combo != 0, "Failed to create combobox window\n");
7970
7971 UpdateWindow(combo);
7972
7973 ret = SendMessageA(combo, WM_GETDLGCODE, 0, 0);
7974 ok(ret == (DLGC_WANTCHARS | DLGC_WANTARROWS), "wrong dlg_code %08Ix\n", ret);
7975
7976 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
7977 ok(ret == 0, "expected 0, got %Id\n", ret);
7978 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 1");
7979 ok(ret == 1, "expected 1, got %Id\n", ret);
7980 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 2");
7981 ok(ret == 2, "expected 2, got %Id\n", ret);
7982
7983 SendMessageA(combo, CB_SETCURSEL, 0, 0);
7984 SetFocus(combo);
7985 flush_sequence();
7986
7987 log_all_parent_messages++;
7988 SendMessageA(combo, WM_KEYDOWN, VK_DOWN, 0);
7989 SendMessageA(combo, WM_KEYUP, VK_DOWN, 0);
7990 log_all_parent_messages--;
7991 ok_sequence(WmKeyDownComboSeq, "WM_KEYDOWN/VK_DOWN on a ComboBox", FALSE);
7992
7993 flush_sequence();
7994 SetWindowPos(combo, 0, 10, 10, 120, 130, SWP_NOZORDER);
7995 ok_sequence(WmSetPosComboSeq, "repositioning messages on a ComboBox", FALSE);
7996
7997 DestroyWindow(combo);
7998 DestroyWindow(parent);
7999
8000 /* Start again. Test combobox text selection when getting and losing focus */
8001 parent = CreateWindowExA(0, "TestParentClass", "Parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
8002 10, 10, 300, 300, NULL, NULL, NULL, NULL);
8003 ok(parent != 0, "Failed to create parent window\n");
8004
8005 combo = CreateWindowExA(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWN,
8006 5, 5, 100, 100, parent, (HMENU)ID_COMBOBOX, NULL, NULL);
8007 ok(combo != 0, "Failed to create combobox window\n");
8008
8009 cbInfo.cbSize = sizeof(COMBOBOXINFO);
8010 SetLastError(0xdeadbeef);
8011 res = GetComboBoxInfo(combo, &cbInfo);
8012 ok(res, "Failed to get COMBOBOXINFO structure; LastError: %lu\n", GetLastError());
8013 edit = cbInfo.hwndItem;
8014
8015 edit_window_proc = (WNDPROC)SetWindowLongPtrA(edit, GWLP_WNDPROC,
8016 (ULONG_PTR)combobox_edit_subclass_proc);
8017
8018 button = CreateWindowExA(0, "Button", "OK", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
8019 5, 50, 100, 20, parent, NULL,
8020 (HINSTANCE)GetWindowLongPtrA(parent, GWLP_HINSTANCE), NULL);
8021 ok(button != 0, "Failed to create button window\n");
8022
8023 flush_sequence();
8024 log_all_parent_messages++;
8025 SendMessageA(combo, WM_SETFOCUS, 0, (LPARAM)edit);
8026 log_all_parent_messages--;
8027 ok_sequence(WMSetFocusComboBoxSeq, "WM_SETFOCUS on a ComboBox", TRUE);
8028
8029 flush_sequence();
8030 log_all_parent_messages++;
8031 SetFocus(button);
8032 log_all_parent_messages--;
8033 ok_sequence(SetFocusButtonSeq, "SetFocus on a Button", TRUE);
8034
8035 SendMessageA(combo, WM_SETTEXT, 0, (LPARAM)"Wine Test");
8036
8037 flush_sequence();
8038 log_all_parent_messages++;
8039 SetFocus(combo);
8040 log_all_parent_messages--;
8041 ok_sequence(SetFocusComboBoxSeq, "SetFocus on a ComboBox", TRUE);
8042
8043 flush_sequence();
8044 log_all_parent_messages++;
8045 SetFocus(button);
8046 log_all_parent_messages--;
8047 ok_sequence(SetFocusButtonSeq2, "SetFocus on a Button (2)", TRUE);
8048
8049 SetFocus(combo);
8050 SendMessageA(combo, WM_SETREDRAW, FALSE, 0);
8051 flush_sequence();
8052 log_all_parent_messages++;
8053 SendMessageA(combo, CB_SETCURSEL, 0, 0);
8054 log_all_parent_messages--;
8055 ok_sequence(SetCurSelComboSeq_edit, "CB_SETCURSEL on a ComboBox with edit control", FALSE);
8056
8057 DestroyWindow(button);
8058 DestroyWindow(combo);
8059
8060 combo = CreateWindowExA(0, "my_combobox_class", "test",
8061 WS_CHILD | WS_VISIBLE | CBS_OWNERDRAWFIXED | CBS_DROPDOWNLIST,
8062 5, 5, 100, 100, parent, (HMENU)ID_COMBOBOX, NULL, NULL);
8063 ok(combo != 0, "Failed to create combobox window\n");
8064
8065 ret = SendMessageA(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
8066 ok(ret == 0, "expected 0, got %Id\n", ret);
8067
8068 cbInfo.cbSize = sizeof(COMBOBOXINFO);
8069 SetLastError(0xdeadbeef);
8070 res = GetComboBoxInfo(combo, &cbInfo);
8071 ok(res, "Failed to get COMBOBOXINFO structure; LastError: %lu\n", GetLastError());
8072 lbox = cbInfo.hwndList;
8073 lbox_window_proc = (WNDPROC)SetWindowLongPtrA(lbox, GWLP_WNDPROC,
8074 (ULONG_PTR)combobox_lbox_subclass_proc);
8075 flush_sequence();
8076
8077 log_all_parent_messages++;
8078 SendMessageA(combo, CB_SETCURSEL, 0, 0);
8079 log_all_parent_messages--;
8080 ok_sequence(SetCurSelComboSeq, "CB_SETCURSEL on a ComboBox", FALSE);
8081
8082 ShowWindow(combo, SW_HIDE);
8083 flush_sequence();
8084 log_all_parent_messages++;
8085 SendMessageA(combo, CB_SETCURSEL, 0, 0);
8086 log_all_parent_messages--;
8087 ok_sequence(SetCurSelComboSeq2, "CB_SETCURSEL on a ComboBox", FALSE);
8088
8089 DestroyWindow(combo);
8090 DestroyWindow(parent);
8091 }
8092
8093 /****************** WM_IME_KEYDOWN message test *******************/
8094
8095 static const struct message WmImeKeydownMsgSeq_0[] =
8096 {
8097 { WM_IME_KEYDOWN, wparam, VK_RETURN },
8098 { WM_CHAR, wparam, 'A' },
8099 { 0 }
8100 };
8101
8102 static const struct message WmImeKeydownMsgSeq_1[] =
8103 {
8104 { WM_KEYDOWN, optional|wparam, VK_RETURN },
8105 { WM_CHAR, optional|wparam, VK_RETURN },
8106 { 0 }
8107 };
8108
8109 static LRESULT WINAPI wmime_keydown_procA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8110 {
8111 struct recvd_message msg;
8112
8113 msg.hwnd = hwnd;
8114 msg.message = message;
8115 msg.flags = wparam|lparam;
8116 msg.wParam = wParam;
8117 msg.lParam = lParam;
8118 msg.descr = "wmime_keydown";
8119 add_message(&msg);
8120
8121 return DefWindowProcA(hwnd, message, wParam, lParam);
8122 }
8123
8124 static void register_wmime_keydown_class(void)
8125 {
8126 WNDCLASSA cls;
8127
8128 ZeroMemory(&cls, sizeof(WNDCLASSA));
8129 cls.lpfnWndProc = wmime_keydown_procA;
8130 cls.hInstance = GetModuleHandleA(0);
8131 cls.lpszClassName = "wmime_keydown_class";
8132 if (!RegisterClassA(&cls)) assert(0);
8133 }
8134
8135 static void test_wmime_keydown_message(void)
8136 {
8137 HWND hwnd;
8138 MSG msg;
8139
8140 if (winetest_debug > 1) trace("Message sequences by WM_IME_KEYDOWN\n");
8141
8142 register_wmime_keydown_class();
8143 hwnd = CreateWindowExA(0, "wmime_keydown_class", NULL, WS_OVERLAPPEDWINDOW,
8144 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
8145 NULL, NULL, 0);
8146 flush_events();
8147 flush_sequence();
8148
8149 SendMessageA(hwnd, WM_IME_KEYDOWN, VK_RETURN, 0x1c0001);
8150 SendMessageA(hwnd, WM_CHAR, 'A', 1);
8151 ok_sequence(WmImeKeydownMsgSeq_0, "WM_IME_KEYDOWN 0", FALSE);
8152
8153 while ( PeekMessageA(&msg, 0, 0, 0, PM_REMOVE) )
8154 {
8155 TranslateMessage(&msg);
8156 DispatchMessageA(&msg);
8157 }
8158 ok_sequence(WmImeKeydownMsgSeq_1, "WM_IME_KEYDOWN 1", FALSE);
8159
8160 DestroyWindow(hwnd);
8161 }
8162
8163 /************* painting message test ********************/
8164
8165 void dump_region(HRGN hrgn)
8166 {
8167 DWORD i, size;
8168 RGNDATA *data = NULL;
8169 RECT *rect;
8170
8171 if (!hrgn)
8172 {
8173 printf( "null region\n" );
8174 return;
8175 }
8176 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
8177 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
8178 GetRegionData( hrgn, size, data );
8179 printf("%ld rects:", data->rdh.nCount );
8180 for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
8181 printf( " %s", wine_dbgstr_rect( rect ));
8182 printf("\n");
8183 HeapFree( GetProcessHeap(), 0, data );
8184 }
8185
8186 #define check_update_rgn( hwnd, hrgn ) check_update_rgn_( __LINE__, hwnd, hrgn )
8187 static void check_update_rgn_( int line, HWND hwnd, HRGN hrgn )
8188 {
8189 INT ret;
8190 RECT r1, r2;
8191 HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
8192 HRGN update = CreateRectRgn( 0, 0, 0, 0 );
8193
8194 ret = GetUpdateRgn( hwnd, update, FALSE );
8195 ok( ret != ERROR, "GetUpdateRgn failed\n" );
8196 if (ret == NULLREGION)
8197 {
8198 ok_(__FILE__,line)( !hrgn, "Update region shouldn't be empty\n" );
8199 }
8200 else
8201 {
8202 if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
8203 {
8204 ok_(__FILE__,line)( 0, "Regions are different\n" );
8205 if (winetest_debug > 0)
8206 {
8207 printf( "Update region: " );
8208 dump_region( update );
8209 printf( "Wanted region: " );
8210 dump_region( hrgn );
8211 }
8212 }
8213 }
8214 GetRgnBox( update, &r1 );
8215 GetUpdateRect( hwnd, &r2, FALSE );
8216 ok_(__FILE__,line)( EqualRect( &r1, &r2 ), "Rectangles are different: %s / %s\n",
8217 wine_dbgstr_rect( &r1 ), wine_dbgstr_rect( &r2 ));
8218
8219 DeleteObject( tmp );
8220 DeleteObject( update );
8221 }
8222
8223 static const struct message WmInvalidateRgn[] = {
8224 { WM_NCPAINT, sent },
8225 { WM_GETTEXT, sent|defwinproc|optional },
8226 { 0 }
8227 };
8228
8229 static const struct message WmGetUpdateRect[] = {
8230 { WM_NCPAINT, sent },
8231 { WM_GETTEXT, sent|defwinproc|optional },
8232 { WM_PAINT, sent },
8233 { 0 }
8234 };
8235
8236 static const struct message WmInvalidateFull[] = {
8237 { WM_NCPAINT, sent|wparam, 1 },
8238 { WM_GETTEXT, sent|defwinproc|optional },
8239 { 0 }
8240 };
8241
8242 static const struct message WmInvalidateErase[] = {
8243 { WM_NCPAINT, sent|wparam, 1 },
8244 { WM_GETTEXT, sent|defwinproc|optional },
8245 { WM_ERASEBKGND, sent },
8246 { 0 }
8247 };
8248
8249 static const struct message WmInvalidatePaint[] = {
8250 { WM_PAINT, sent },
8251 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
8252 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
8253 { 0 }
8254 };
8255
8256 static const struct message WmInvalidateErasePaint[] = {
8257 { WM_PAINT, sent },
8258 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
8259 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
8260 { WM_ERASEBKGND, sent|beginpaint|optional },
8261 { 0 }
8262 };
8263
8264 static const struct message WmInvalidateErasePaint2[] = {
8265 { WM_PAINT, sent },
8266 { WM_NCPAINT, sent|beginpaint },
8267 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
8268 { WM_ERASEBKGND, sent|beginpaint|optional },
8269 { 0 }
8270 };
8271
8272 static const struct message WmErase[] = {
8273 { WM_ERASEBKGND, sent },
8274 { 0 }
8275 };
8276
8277 static const struct message WmPaint[] = {
8278 { WM_PAINT, sent },
8279 { 0 }
8280 };
8281
8282 static const struct message WmParentOnlyPaint[] = {
8283 { WM_PAINT, sent|parent },
8284 { 0 }
8285 };
8286
8287 static const struct message WmInvalidateParent[] = {
8288 { WM_NCPAINT, sent|parent },
8289 { WM_GETTEXT, sent|defwinproc|parent|optional },
8290 { WM_ERASEBKGND, sent|parent },
8291 { 0 }
8292 };
8293
8294 static const struct message WmInvalidateParentChild[] = {
8295 { WM_NCPAINT, sent|parent },
8296 { WM_GETTEXT, sent|defwinproc|parent|optional },
8297 { WM_ERASEBKGND, sent|parent },
8298 { WM_NCPAINT, sent },
8299 { WM_GETTEXT, sent|defwinproc|optional },
8300 { WM_ERASEBKGND, sent },
8301 { 0 }
8302 };
8303
8304 static const struct message WmInvalidateParentChild2[] = {
8305 { WM_ERASEBKGND, sent|parent },
8306 { WM_NCPAINT, sent },
8307 { WM_GETTEXT, sent|defwinproc|optional },
8308 { WM_ERASEBKGND, sent },
8309 { 0 }
8310 };
8311
8312 static const struct message WmParentPaint[] = {
8313 { WM_PAINT, sent|parent },
8314 { WM_PAINT, sent },
8315 { 0 }
8316 };
8317
8318 static const struct message WmParentPaintNc[] = {
8319 { WM_PAINT, sent|parent },
8320 { WM_PAINT, sent },
8321 { WM_NCPAINT, sent|beginpaint },
8322 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
8323 { WM_ERASEBKGND, sent|beginpaint|optional },
8324 { WM_GETMINMAXINFO, sent|optional },
8325 { 0 }
8326 };
8327
8328 static const struct message WmChildPaintNc[] = {
8329 { WM_PAINT, sent },
8330 { WM_NCPAINT, sent|beginpaint },
8331 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
8332 { WM_ERASEBKGND, sent|beginpaint|optional },
8333 { 0 }
8334 };
8335
8336 static const struct message WmParentErasePaint[] = {
8337 { WM_PAINT, sent|parent },
8338 { WM_NCPAINT, sent|parent|beginpaint },
8339 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
8340 { WM_ERASEBKGND, sent|parent|beginpaint|optional },
8341 { WM_PAINT, sent },
8342 { WM_NCPAINT, sent|beginpaint },
8343 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
8344 { WM_ERASEBKGND, sent|beginpaint|optional },
8345 { 0 }
8346 };
8347
8348 static const struct message WmParentOnlyNcPaint[] = {
8349 { WM_PAINT, sent|parent },
8350 { WM_NCPAINT, sent|parent|beginpaint },
8351 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
8352 { 0 }
8353 };
8354
8355 static const struct message WmSetParentStyle[] = {
8356 { WM_STYLECHANGING, sent|parent },
8357 { WM_STYLECHANGED, sent|parent },
8358 { 0 }
8359 };
8360
8361 static void test_paint_messages(void)
8362 {
8363 BOOL ret;
8364 RECT rect, rect2;
8365 POINT pt;
8366 MSG msg;
8367 HWND hparent, hchild;
8368 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
8369 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
8370 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
8371 100, 100, 200, 200, 0, 0, 0, NULL);
8372 ok (hwnd != 0, "Failed to create overlapped window\n");
8373
8374 ShowWindow( hwnd, SW_SHOW );
8375 UpdateWindow( hwnd );
8376 flush_events();
8377 flush_sequence();
8378
8379 check_update_rgn( hwnd, 0 );
8380 SetRectRgn( hrgn, 10, 10, 20, 20 );
8381 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
8382 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8383 check_update_rgn( hwnd, hrgn );
8384 SetRectRgn( hrgn2, 20, 20, 30, 30 );
8385 ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
8386 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8387 CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
8388 check_update_rgn( hwnd, hrgn );
8389 /* validate everything */
8390 ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8391 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8392 check_update_rgn( hwnd, 0 );
8393
8394 /* test empty region */
8395 SetRectRgn( hrgn, 10, 10, 10, 15 );
8396 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
8397 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8398 check_update_rgn( hwnd, 0 );
8399 /* test empty rect */
8400 SetRect( &rect, 10, 10, 10, 15 );
8401 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8402 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8403 check_update_rgn( hwnd, 0 );
8404
8405 /* test a zeroed rectangle */
8406 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8407 SetRect( &rect, 0, 0, 0, 0 );
8408 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8409 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8410 check_update_rgn( hwnd, 0 );
8411
8412 /* a well ordered rectangle */
8413 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8414 SetRect( &rect, 10, 5, 17, 21 );
8415 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8416 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8417 SetRectRgn( hrgn, 10, 5, 17, 21 );
8418 check_update_rgn( hwnd, hrgn );
8419
8420 /* empty rectangle, top and bottom are swapped but left and right have
8421 the same value */
8422 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8423 SetRect( &rect, 5, 30, 5, 10 );
8424 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8425 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8426 check_update_rgn( hwnd, 0 );
8427
8428 /* empty rectangle, left and right are swapped but top and bottom have
8429 the same value */
8430 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8431 SetRect( &rect, 17, 10, 5, 10 );
8432 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8433 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8434 check_update_rgn( hwnd, 0 );
8435
8436 /* Left and right are swapped */
8437 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8438 SetRect( &rect, 21, 12, 7, 30 );
8439 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8440 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8441 SetRectRgn( hrgn, 7, 12, 21, 30 );
8442 check_update_rgn( hwnd, hrgn );
8443
8444 /* Top and bottom are swapped */
8445 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8446 SetRect( &rect, 7, 30, 21, 12 );
8447 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8448 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8449 SetRectRgn( hrgn, 7, 12, 21, 30 );
8450 check_update_rgn( hwnd, hrgn );
8451
8452 /* both reference points are swapped */
8453 RedrawWindow( hwnd, NULL, 0, RDW_VALIDATE|RDW_NOFRAME|RDW_NOERASE );
8454 SetRect( &rect, 21, 30, 7, 12 );
8455 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
8456 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
8457 SetRectRgn( hrgn, 7, 12, 21, 30 );
8458 check_update_rgn( hwnd, hrgn );
8459
8460 /* flush pending messages */
8461 flush_events();
8462 flush_sequence();
8463
8464 GetClientRect( hwnd, &rect );
8465 SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
8466 /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
8467 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
8468 */
8469 SetRectEmpty( &rect );
8470 ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) failed\n");
8471 check_update_rgn( hwnd, hrgn );
8472 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8473 flush_events();
8474 ok_sequence( WmPaint, "Paint", FALSE );
8475 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8476 check_update_rgn( hwnd, 0 );
8477
8478 SetRectEmpty( &rect );
8479 ok(RedrawWindow(0, &rect, 0, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8480 "RedrawWindow failed\n");
8481 check_update_rgn( hwnd, 0 );
8482
8483 SetRectEmpty( &rect );
8484 ok(RedrawWindow(0, &rect, 0, RDW_ALLCHILDREN | RDW_VALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8485 "RedrawWindow failed\n");
8486 check_update_rgn( hwnd, 0 );
8487
8488 GetWindowRect( hwnd, &rect );
8489 ok(RedrawWindow(0, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8490 "RedrawWindow failed\n");
8491 check_update_rgn( hwnd, 0 );
8492
8493 flush_events();
8494 ok(RedrawWindow(0, &rect, 0, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8495 "RedrawWindow failed\n");
8496 check_update_rgn( hwnd, hrgn );
8497 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8498 flush_events();
8499 ok_sequence( WmPaint, "Paint", FALSE );
8500 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8501 check_update_rgn( hwnd, 0 );
8502
8503 ok(RedrawWindow(GetDesktopWindow(), &rect, 0,
8504 RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8505 "RedrawWindow failed\n");
8506 ret = GetUpdateRgn( hwnd, hrgn2, FALSE );
8507 ok( ret == NULLREGION || broken(ret == SIMPLEREGION), /* <= win7 */
8508 "region should be null (%d)\n", ret );
8509 if (ret == SIMPLEREGION) ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8510 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8511 flush_events();
8512
8513 ok(RedrawWindow(GetDesktopWindow(), NULL, 0,
8514 RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8515 "RedrawWindow failed\n");
8516 ret = GetUpdateRgn( hwnd, hrgn2, FALSE );
8517 ok( ret == NULLREGION || broken(ret == SIMPLEREGION), /* <= win7 */
8518 "region should be null (%d)\n", ret );
8519 if (ret == SIMPLEREGION) ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8520 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8521 flush_events();
8522
8523 SetRectRgn( hrgn2, rect.left, rect.top, rect.right, rect.bottom );
8524 ok(RedrawWindow(0, NULL, hrgn2, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW ),
8525 "RedrawWindow failed\n");
8526 check_update_rgn( hwnd, hrgn );
8527 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8528 flush_events();
8529 ok_sequence( WmPaint, "Paint", FALSE );
8530 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8531 check_update_rgn( hwnd, 0 );
8532
8533 ok(RedrawWindow(0, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW ),
8534 "RedrawWindow failed\n");
8535 check_update_rgn( hwnd, 0 );
8536
8537 ok(RedrawWindow(0, NULL, 0, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW ),
8538 "RedrawWindow failed\n");
8539 check_update_rgn( hwnd, hrgn );
8540 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8541 flush_events();
8542 ok_sequence( WmPaint, "Paint", FALSE );
8543 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8544 check_update_rgn( hwnd, 0 );
8545
8546 /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
8547 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
8548 */
8549 SetRectEmpty( &rect );
8550 if (ValidateRect(0, &rect) && /* not supported on Win9x */
8551 GetUpdateRect(hwnd, NULL, FALSE)) /* or >= Win 8 */
8552 {
8553 check_update_rgn( hwnd, hrgn );
8554 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8555 flush_events();
8556 ok_sequence( WmPaint, "Paint", FALSE );
8557 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
8558 check_update_rgn( hwnd, 0 );
8559 }
8560
8561 SetLastError(0xdeadbeef);
8562 ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
8563 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || GetLastError() == 0xdeadbeef,
8564 "wrong error code %ld\n", GetLastError());
8565 check_update_rgn( hwnd, 0 );
8566 flush_events();
8567 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8568
8569 SetLastError(0xdeadbeef);
8570 ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
8571 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
8572 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
8573 "wrong error code %ld\n", GetLastError());
8574 check_update_rgn( hwnd, 0 );
8575 flush_events();
8576 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8577
8578 SetLastError(0xdeadbeef);
8579 ok(!UpdateWindow(NULL), "UpdateWindow(NULL) should fail\n");
8580 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE ||
8581 broken( GetLastError() == 0xdeadbeef ) /* win9x */,
8582 "wrong error code %ld\n", GetLastError());
8583 check_update_rgn( hwnd, 0 );
8584 flush_events();
8585 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8586
8587 /* now with frame */
8588 SetRectRgn( hrgn, -5, -5, 20, 20 );
8589
8590 /* flush pending messages */
8591 flush_events();
8592 flush_sequence();
8593 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
8594 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
8595
8596 SetRectRgn( hrgn, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
8597 check_update_rgn( hwnd, hrgn );
8598
8599 flush_sequence();
8600 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
8601 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
8602
8603 flush_sequence();
8604 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
8605 ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
8606
8607 GetClientRect( hwnd, &rect );
8608 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
8609 check_update_rgn( hwnd, hrgn );
8610
8611 flush_sequence();
8612 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
8613 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
8614
8615 flush_sequence();
8616 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
8617 ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
8618 check_update_rgn( hwnd, 0 );
8619
8620 flush_sequence();
8621 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
8622 ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
8623 check_update_rgn( hwnd, 0 );
8624
8625 flush_sequence();
8626 SetRectRgn( hrgn, 0, 0, 100, 100 );
8627 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
8628 SetRectRgn( hrgn, 0, 0, 50, 100 );
8629 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
8630 SetRectRgn( hrgn, 50, 0, 100, 100 );
8631 check_update_rgn( hwnd, hrgn );
8632 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
8633 ok_sequence( WmEmptySeq, "EmptySeq", FALSE ); /* must not generate messages, everything is valid */
8634 check_update_rgn( hwnd, 0 );
8635
8636 flush_sequence();
8637 SetRectRgn( hrgn, 0, 0, 100, 100 );
8638 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
8639 SetRectRgn( hrgn, 0, 0, 100, 50 );
8640 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
8641 ok_sequence( WmErase, "Erase", FALSE );
8642 SetRectRgn( hrgn, 0, 50, 100, 100 );
8643 check_update_rgn( hwnd, hrgn );
8644
8645 flush_sequence();
8646 SetRectRgn( hrgn, 0, 0, 100, 100 );
8647 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
8648 SetRectRgn( hrgn, 0, 0, 50, 50 );
8649 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
8650 ok_sequence( WmPaint, "Paint", FALSE );
8651
8652 flush_sequence();
8653 SetRectRgn( hrgn, -4, -4, -2, -2 );
8654 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
8655 SetRectRgn( hrgn, -200, -200, -198, -198 );
8656 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
8657 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
8658
8659 flush_sequence();
8660 SetRectRgn( hrgn, -4, -4, -2, -2 );
8661 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
8662 SetRectRgn( hrgn, -4, -4, -3, -3 );
8663 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
8664 SetRectRgn( hrgn, 0, 0, 1, 1 );
8665 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
8666 ok_sequence( WmPaint, "Paint", FALSE );
8667
8668 flush_sequence();
8669 SetRectRgn( hrgn, -4, -4, -1, -1 );
8670 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
8671 RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
8672 /* make sure no WM_PAINT was generated */
8673 flush_events();
8674 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
8675
8676 flush_sequence();
8677 SetRectRgn( hrgn, -4, -4, -1, -1 );
8678 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
8679 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
8680 {
8681 if (msg.hwnd == hwnd && msg.message == WM_PAINT)
8682 {
8683 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
8684 INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
8685 ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
8686 ret = GetUpdateRect( hwnd, &rect, FALSE );
8687 ok( ret, "Invalid GetUpdateRect result %d\n", ret );
8688 /* this will send WM_NCPAINT and validate the non client area */
8689 ret = GetUpdateRect( hwnd, &rect, TRUE );
8690 ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
8691 }
8692 DispatchMessageA( &msg );
8693 }
8694 ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
8695
8696 DestroyWindow( hwnd );
8697
8698 /* now test with a child window */
8699
8700 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
8701 100, 100, 200, 200, 0, 0, 0, NULL);
8702 ok (hparent != 0, "Failed to create parent window\n");
8703
8704 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
8705 10, 10, 100, 100, hparent, 0, 0, NULL);
8706 ok (hchild != 0, "Failed to create child window\n");
8707
8708 ShowWindow( hparent, SW_SHOW );
8709 UpdateWindow( hparent );
8710 UpdateWindow( hchild );
8711 flush_events();
8712 flush_sequence();
8713 log_all_parent_messages++;
8714
8715 SetRect( &rect, 0, 0, 50, 50 );
8716 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8717 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
8718 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
8719
8720 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8721 pt.x = pt.y = 0;
8722 MapWindowPoints( hchild, hparent, &pt, 1 );
8723 SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
8724 check_update_rgn( hchild, hrgn );
8725 SetRectRgn( hrgn, 0, 0, 50, 50 );
8726 check_update_rgn( hparent, hrgn );
8727 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
8728 ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
8729 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
8730 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
8731
8732 flush_events();
8733 ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
8734
8735 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
8736 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
8737 ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
8738 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
8739 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
8740
8741 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
8742 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
8743 ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
8744
8745 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
8746 flush_sequence();
8747 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
8748 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
8749 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
8750
8751 /* flush all paint messages */
8752 flush_events();
8753 flush_sequence();
8754
8755 /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
8756 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
8757 SetRectRgn( hrgn, 0, 0, 50, 50 );
8758 check_update_rgn( hparent, hrgn );
8759 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
8760 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
8761 SetRectRgn( hrgn, 0, 0, 50, 50 );
8762 check_update_rgn( hparent, hrgn );
8763
8764 /* flush all paint messages */
8765 flush_events();
8766 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
8767 flush_sequence();
8768
8769 /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
8770 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8771 SetRectRgn( hrgn, 0, 0, 50, 50 );
8772 check_update_rgn( hparent, hrgn );
8773 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
8774 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
8775 SetRectRgn( hrgn2, 10, 10, 50, 50 );
8776 CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
8777 check_update_rgn( hparent, hrgn );
8778 /* flush all paint messages */
8779 flush_events();
8780 flush_sequence();
8781
8782 /* same as above but parent gets completely validated */
8783 SetRect( &rect, 20, 20, 30, 30 );
8784 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8785 SetRectRgn( hrgn, 20, 20, 30, 30 );
8786 check_update_rgn( hparent, hrgn );
8787 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
8788 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
8789 check_update_rgn( hparent, 0 ); /* no update region */
8790 flush_events();
8791 ok_sequence( WmEmptySeq, "WmEmpty", FALSE ); /* and no paint messages */
8792
8793 /* make sure RDW_VALIDATE on child doesn't have the same effect */
8794 flush_sequence();
8795 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8796 SetRectRgn( hrgn, 20, 20, 30, 30 );
8797 check_update_rgn( hparent, hrgn );
8798 RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
8799 SetRectRgn( hrgn, 20, 20, 30, 30 );
8800 check_update_rgn( hparent, hrgn );
8801
8802 /* same as above but normal WM_PAINT doesn't validate parent */
8803 flush_sequence();
8804 SetRect( &rect, 20, 20, 30, 30 );
8805 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8806 SetRectRgn( hrgn, 20, 20, 30, 30 );
8807 check_update_rgn( hparent, hrgn );
8808 /* no WM_PAINT in child while parent still pending */
8809 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8810 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
8811 while (PeekMessageA( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8812 ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
8813
8814 flush_sequence();
8815 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8816 /* no WM_PAINT in child while parent still pending */
8817 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8818 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
8819 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
8820 /* now that parent is valid child should get WM_PAINT */
8821 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8822 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
8823 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8824 ok_sequence( WmEmptySeq, "No other message", FALSE );
8825
8826 /* same thing with WS_CLIPCHILDREN in parent */
8827 flush_sequence();
8828 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
8829 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
8830 /* changing style invalidates non client area, but we need to invalidate something else to see it */
8831 RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
8832 ok_sequence( WmEmptySeq, "No message", FALSE );
8833 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
8834 ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
8835
8836 flush_sequence();
8837 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
8838 SetRectRgn( hrgn, 20, 20, 30, 30 );
8839 check_update_rgn( hparent, hrgn );
8840 /* no WM_PAINT in child while parent still pending */
8841 while (PeekMessageA( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8842 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
8843 /* WM_PAINT in parent first */
8844 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
8845 ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
8846
8847 /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
8848 flush_sequence();
8849 SetRect( &rect, 0, 0, 30, 30 );
8850 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
8851 SetRectRgn( hrgn, 0, 0, 30, 30 );
8852 check_update_rgn( hparent, hrgn );
8853 flush_events();
8854 ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
8855
8856 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
8857 flush_sequence();
8858 SetRect( &rect, -10, 0, 30, 30 );
8859 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
8860 SetRect( &rect, 0, 0, 20, 20 );
8861 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
8862 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
8863 ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
8864
8865 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
8866 flush_sequence();
8867 SetRect( &rect, -10, 0, 30, 30 );
8868 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
8869 SetRect( &rect, 0, 0, 100, 100 );
8870 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
8871 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
8872 ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
8873 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
8874 ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
8875
8876 /* WS_CLIPCHILDREN doesn't exclude children from update region */
8877 flush_sequence();
8878 RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
8879 GetClientRect( hparent, &rect );
8880 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
8881 check_update_rgn( hparent, hrgn );
8882 flush_events();
8883
8884 RedrawWindow( hparent, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
8885 GetClientRect( hparent, &rect );
8886 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
8887 check_update_rgn( hparent, hrgn );
8888 flush_events();
8889
8890 /* test RDW_INTERNALPAINT behavior */
8891
8892 flush_sequence();
8893 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
8894 flush_events();
8895 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
8896
8897 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
8898 flush_events();
8899 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
8900
8901 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
8902 flush_events();
8903 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
8904
8905 assert( GetWindowLongA(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
8906 UpdateWindow( hparent );
8907 flush_events();
8908 flush_sequence();
8909 if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
8910 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8911 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
8912 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
8913 flush_events();
8914 ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
8915
8916 UpdateWindow( hparent );
8917 flush_events();
8918 flush_sequence();
8919 if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
8920 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8921 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
8922 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
8923 flush_events();
8924 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
8925
8926 SetWindowLongA( hparent, GWL_STYLE, GetWindowLongA(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
8927 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
8928 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
8929 flush_events();
8930 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
8931
8932 assert( !(GetWindowLongA(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
8933 UpdateWindow( hparent );
8934 flush_events();
8935 flush_sequence();
8936 if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
8937 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8938 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
8939 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
8940 flush_events();
8941 ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
8942
8943 UpdateWindow( hparent );
8944 flush_events();
8945 flush_sequence();
8946 if (winetest_debug > 1) trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
8947 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
8948 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
8949 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
8950 flush_events();
8951 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
8952
8953 ok(GetWindowLongA( hparent, GWL_STYLE ) & WS_VISIBLE, "parent should be visible\n");
8954 ok(GetWindowLongA( hchild, GWL_STYLE ) & WS_VISIBLE, "child should be visible\n");
8955
8956 UpdateWindow( hparent );
8957 flush_events();
8958 flush_sequence();
8959 if (winetest_debug > 1) trace("testing SetWindowPos(-10000, -10000) on child\n");
8960 SetWindowPos( hchild, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
8961 check_update_rgn( hchild, 0 );
8962 flush_events();
8963
8964 #if 0 /* this one doesn't pass under Wine yet */
8965 UpdateWindow( hparent );
8966 flush_events();
8967 flush_sequence();
8968 if (winetest_debug > 1) trace("testing ShowWindow(SW_MINIMIZE) on child\n");
8969 ShowWindow( hchild, SW_MINIMIZE );
8970 check_update_rgn( hchild, 0 );
8971 flush_events();
8972 #endif
8973
8974 UpdateWindow( hparent );
8975 flush_events();
8976 flush_sequence();
8977 if (winetest_debug > 1) trace("testing SetWindowPos(-10000, -10000) on parent\n");
8978 SetWindowPos( hparent, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
8979 check_update_rgn( hparent, 0 );
8980 flush_events();
8981
8982 log_all_parent_messages--;
8983 DestroyWindow( hparent );
8984 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
8985
8986 /* tests for moving windows off-screen (needs simple WS_POPUP windows) */
8987
8988 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_POPUP | WS_VISIBLE,
8989 100, 100, 200, 200, 0, 0, 0, NULL);
8990 ok (hparent != 0, "Failed to create parent window\n");
8991
8992 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
8993 10, 10, 100, 100, hparent, 0, 0, NULL);
8994 ok (hchild != 0, "Failed to create child window\n");
8995
8996 ShowWindow( hparent, SW_SHOW );
8997 UpdateWindow( hparent );
8998 UpdateWindow( hchild );
8999 flush_events();
9000 flush_sequence();
9001
9002 /* moving child outside of parent boundaries changes update region */
9003 SetRect( &rect, 0, 0, 40, 40 );
9004 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
9005 SetRectRgn( hrgn, 0, 0, 40, 40 );
9006 check_update_rgn( hchild, hrgn );
9007 MoveWindow( hchild, -10, 10, 100, 100, FALSE );
9008 SetRectRgn( hrgn, 10, 0, 40, 40 );
9009 check_update_rgn( hchild, hrgn );
9010 MoveWindow( hchild, -10, -10, 100, 100, FALSE );
9011 SetRectRgn( hrgn, 10, 10, 40, 40 );
9012 check_update_rgn( hchild, hrgn );
9013
9014 /* moving parent off-screen does too */
9015 SetRect( &rect, 0, 0, 100, 100 );
9016 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
9017 SetRectRgn( hrgn, 0, 0, 100, 100 );
9018 check_update_rgn( hparent, hrgn );
9019 SetRectRgn( hrgn, 10, 10, 40, 40 );
9020 check_update_rgn( hchild, hrgn );
9021 MoveWindow( hparent, -20, -20, 200, 200, FALSE );
9022 GetUpdateRect( hparent, &rect2, FALSE );
9023 if (!EqualRect( &rect2, &rect )) /* Win 8 and later don't crop update to screen */
9024 {
9025 rect.left += 20;
9026 rect.top += 20;
9027 }
9028 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
9029 check_update_rgn( hparent, hrgn );
9030 SetRectRgn( hrgn, rect.left + 10, rect.top + 10, 40, 40 );
9031 check_update_rgn( hchild, hrgn );
9032
9033 /* invalidated region is cropped by the parent rects */
9034 SetRect( &rect, 0, 0, 50, 50 );
9035 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
9036 SetRectRgn( hrgn, rect2.left + 10, rect2.top + 10, 50, 50 );
9037 check_update_rgn( hchild, hrgn );
9038
9039 DestroyWindow( hparent );
9040 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
9041 flush_sequence();
9042
9043 DeleteObject( hrgn );
9044 DeleteObject( hrgn2 );
9045 }
9046
9047 static void visualize_region_differences( HWND hwnd, HWND hother, HRGN hrgn_expect, HRGN hrgn_actual )
9048 {
9049 HBRUSH b_expectonly, b_actualonly, b_intersect;
9050 HRGN hrgn_intersect;
9051 HWND hstatic, hshow, hhide;
9052 HDC hdc, hdctmp;
9053 HBITMAP hbitmap;
9054 MSG msg;
9055 RECT rect;
9056 DWORD start_time, elapsed, timeout = 60 * 1000;
9057 BOOL toggle = TRUE, stop = FALSE;
9058
9059 start_time = GetTickCount();
9060
9061 b_expectonly = CreateSolidBrush( RGB( 64, 64, 255 ));
9062 b_actualonly = CreateSolidBrush( RGB( 255, 64, 64 ));
9063 b_intersect = CreateSolidBrush( RGB( 159, 64, 159 ));
9064
9065 hrgn_intersect = CreateRectRgn( 0, 0, 0, 0 );
9066 CombineRgn( hrgn_intersect, hrgn_expect, hrgn_actual, RGN_AND );
9067
9068 GetClientRect( hwnd, &rect );
9069 hdc = GetDC( hwnd );
9070 hbitmap = CreateCompatibleBitmap( hdc, rect.right, rect.bottom );
9071 hdctmp = CreateCompatibleDC( hdc );
9072 ReleaseDC( hwnd, hdc );
9073
9074 SelectObject( hdctmp, hbitmap );
9075 FillRgn( hdctmp, hrgn_expect, b_expectonly );
9076 FillRgn( hdctmp, hrgn_actual, b_actualonly );
9077 FillRgn( hdctmp, hrgn_intersect, b_intersect );
9078
9079 DeleteObject( hdctmp );
9080 DeleteObject( hrgn_intersect );
9081 DeleteObject( b_intersect );
9082 DeleteObject( b_actualonly );
9083 DeleteObject( b_expectonly );
9084
9085 hstatic = CreateWindowExA( 0, WC_STATICA, "", WS_CHILD | SS_BITMAP,
9086 0, 0, rect.right, rect.bottom, hwnd, 0, 0, NULL );
9087 SendMessageA( hstatic, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbitmap );
9088
9089 hshow = hstatic;
9090 hhide = hother;
9091
9092 for (;;)
9093 {
9094 if (stop) toggle = hshow == hother;
9095 if (toggle)
9096 {
9097 HWND htmp;
9098 HDWP hdwp;
9099
9100 hdwp = BeginDeferWindowPos( !!hhide + !!hshow );
9101 if (hhide)
9102 {
9103 DeferWindowPos( hdwp, hhide, NULL, 0, 0, 0, 0,
9104 SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER );
9105 }
9106 if (hshow)
9107 {
9108 DeferWindowPos( hdwp, hshow, HWND_TOP, 0, 0, 0, 0,
9109 SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
9110 }
9111 EndDeferWindowPos( hdwp );
9112
9113 htmp = hshow;
9114 hshow = hhide;
9115 hhide = htmp;
9116 toggle = FALSE;
9117 }
9118 if (stop) break;
9119 if ((elapsed = GetTickCount() - start_time) >= timeout)
9120 {
9121 stop = TRUE;
9122 continue;
9123 }
9124 MsgWaitForMultipleObjects( 0, NULL, FALSE, timeout - elapsed, QS_ALLINPUT );
9125 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
9126 {
9127 TranslateMessage( &msg );
9128 DispatchMessageA( &msg );
9129 if (msg.message == WM_MOUSEMOVE)
9130 {
9131 start_time = GetTickCount();
9132 }
9133 else if (msg.message == WM_LBUTTONUP || (msg.message == WM_CHAR && msg.wParam == VK_SPACE))
9134 {
9135 toggle = !toggle;
9136 }
9137 else if (msg.message == WM_RBUTTONUP || (msg.message == WM_CHAR && msg.wParam == VK_RETURN))
9138 {
9139 stop = TRUE;
9140 }
9141 }
9142 }
9143
9144 DestroyWindow( hstatic );
9145 DeleteObject( hbitmap );
9146 }
9147
9148 #define subtest_swp_paint_regions(w,p,c) subtest_swp_paint_regions_(__LINE__,w,p,c)
9149
9150 static void subtest_swp_paint_regions_( int line, int wrap_toplevel, LPCSTR parent_class, LPCSTR child_class )
9151 {
9152 static const struct exposure_test {
9153 int ex_style, style;
9154 BOOL shuffle_zorder;
9155 } exposure_tests[] = {
9156 { 0, WS_CLIPCHILDREN, FALSE },
9157 { 0, 0, FALSE },
9158 { WS_EX_COMPOSITED, WS_CLIPCHILDREN, TRUE },
9159 { WS_EX_COMPOSITED, 0, FALSE },
9160 { WS_EX_COMPOSITED, 0, TRUE },
9161 };
9162 size_t i;
9163 HWND htoplevel = NULL, hparent, hchild, hauxchild;
9164 const RECT rect_old = { 10, 10, 100, 100 };
9165 HRGN hrgn_old_vis = CreateRectRgn( 0, 0, 0, 0 );
9166 HRGN hrgn_new_vis = CreateRectRgn( 0, 0, 0, 0 );
9167 HRGN hrgn_expect = CreateRectRgn( 0, 0, 0, 0 );
9168 HRGN hrgn_actual = CreateRectRgn( 0, 0, 0, 0 );
9169 HRGN hrgn_old_vis_child = CreateRectRgn( 0, 0, 0, 0 );
9170 HRGN hrgn_new_vis_child = CreateRectRgn( 0, 0, 0, 0 );
9171 HRGN hrgn_expect_child = CreateRectRgn( 0, 0, 0, 0 );
9172 HRGN hrgn_actual_child = CreateRectRgn( 0, 0, 0, 0 );
9173 int base_style;
9174 BOOL is_composition_possible, has_parentdc_anomaly;
9175 WNDCLASSA parent_wc;
9176
9177 if (wrap_toplevel)
9178 {
9179 htoplevel = CreateWindowExA( 0, "SimpleWindowClass", "Test toplevel", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
9180 100, 100, 400, 400, 0, 0, 0, NULL );
9181 ok( htoplevel != 0, "Failed to create top-level window: %lu\n", GetLastError() );
9182 base_style = WS_CHILD | WS_VISIBLE;
9183 }
9184 else
9185 {
9186 base_style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;
9187 }
9188
9189 ok( GetClassInfoA( GetModuleHandleA( NULL ), parent_class, &parent_wc ),
9190 "GetClassInfoA failed\n" );
9191
9192 is_composition_possible = (base_style & (WS_POPUP|WS_CHILD)) != WS_CHILD ||
9193 (parent_wc.style & CS_PARENTDC) == 0;
9194
9195 has_parentdc_anomaly = (base_style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
9196 (parent_wc.style & CS_PARENTDC) != 0;
9197
9198 hparent = CreateWindowExA( 0, parent_class, "Test parent", base_style,
9199 80, 80, 200, 200, htoplevel, 0, 0, NULL );
9200 ok( hparent != 0, "Creating parent window (%s) returned error %lu\n",
9201 debugstr_a( parent_class ), GetLastError() );
9202
9203 hchild = CreateWindowExA( 0, child_class, "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
9204 rect_old.left, rect_old.top,
9205 rect_old.right - rect_old.left, rect_old.bottom - rect_old.top,
9206 hparent, 0, 0, NULL );
9207 ok( hchild != 0, "Creating child window (%s) returned error %lu\n",
9208 debugstr_a( child_class ), GetLastError() );
9209
9210 hauxchild = CreateWindowExA( 0, child_class, "Auxiliary child for z order test", WS_CHILD | WS_VISIBLE,
9211 110, 0, 0, 0, hparent, 0, 0, NULL );
9212 ok( hauxchild != 0, "Creating child window (%s) returned error %lu\n",
9213 debugstr_a( child_class ), GetLastError() );
9214
9215 for (i = 0; i < ARRAY_SIZE(exposure_tests); i++)
9216 {
9217 const struct exposure_test *extest = &exposure_tests[i];
9218 BOOL has_ws_ex_composited = (extest->ex_style & WS_EX_COMPOSITED) != 0;
9219 BOOL is_composited = is_composition_possible && has_ws_ex_composited;
9220 BOOL is_zorder_redraw = is_composited && extest->shuffle_zorder;
9221 int delta;
9222
9223 winetest_push_context( "%d: SetWindowPos redraw #%Id (ex_style = %#x, style = %#x, shuffle_zorder = %d)",
9224 line, i, extest->ex_style, extest->style, extest->shuffle_zorder );
9225
9226 SetWindowLongA( hparent, GWL_EXSTYLE, extest->ex_style );
9227 SetWindowLongA( hparent, GWL_STYLE, base_style | extest->style );
9228 RedrawWindow( hparent, NULL, NULL, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
9229
9230 for (delta = -20; delta <= 0; delta += 20)
9231 {
9232 RECT rect_old_vis, rect_new, rect_new_vis;
9233 RECT rect_parent_clip, rect_child_clip;
9234 RECT rect_old_vis_child, rect_new_vis_child;
9235 BOOL rgn_ok;
9236
9237 winetest_push_context( "delta = %+d", delta );
9238
9239 SetWindowPos( hchild, HWND_TOP,
9240 rect_old.left,
9241 rect_old.top,
9242 rect_old.right - rect_old.left,
9243 rect_old.bottom - rect_old.top,
9244 SWP_NOACTIVATE );
9245
9246 rect_new = rect_old;
9247 OffsetRect( &rect_new, delta, delta );
9248
9249 rect_old_vis_child = rect_old;
9250 MapWindowPoints( hparent, hchild, (POINT *)&rect_old_vis_child, 2 );
9251
9252 SetRectRgn( hrgn_actual, 0, 0, 0, 0 );
9253 SetRectRgn( hrgn_actual_child, 0, 0, 0, 0 );
9254
9255 UpdateWindow( hparent );
9256 flush_events();
9257
9258 if (extest->shuffle_zorder)
9259 {
9260 /* bring sibling to top/bottom first so we can trigger z-order change */
9261 SetWindowPos( hauxchild, HWND_TOP, 0, 0, 0, 0,
9262 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
9263 }
9264
9265 SetWindowPos( hchild, HWND_TOP,
9266 rect_new.left,
9267 rect_new.top,
9268 rect_new.right - rect_new.left,
9269 rect_new.bottom - rect_new.top,
9270 SWP_NOACTIVATE |
9271 (extest->shuffle_zorder ? 0 : SWP_NOZORDER) );
9272
9273 ok( GetUpdateRgn( hparent, hrgn_actual, FALSE ) != ERROR,
9274 "GetUpdateRgn on parentshall succeed\n" );
9275 ok( GetUpdateRgn( hchild, hrgn_actual_child, FALSE ) != ERROR,
9276 "GetUpdateRgn on child shall succeed\n" );
9277
9278 /* Compute parent window expose region */
9279 GetClientRect( hparent, &rect_parent_clip );
9280 IntersectRect( &rect_old_vis, &rect_old, &rect_parent_clip );
9281 SetRectRgn( hrgn_old_vis, rect_old_vis.left, rect_old_vis.top, rect_old_vis.right, rect_old_vis.bottom );
9282 IntersectRect( &rect_new_vis, &rect_new, &rect_parent_clip );
9283 SetRectRgn( hrgn_new_vis, rect_new_vis.left, rect_new_vis.top, rect_new_vis.right, rect_new_vis.bottom );
9284
9285 if (!EqualRect( &rect_old, &rect_new ) || is_zorder_redraw)
9286 {
9287 CombineRgn( hrgn_expect, hrgn_old_vis, hrgn_new_vis, is_composited ? RGN_OR : RGN_DIFF );
9288 }
9289 else
9290 {
9291 SetRectRgn( hrgn_expect, 0, 0, 0, 0 );
9292 }
9293
9294 rgn_ok = EqualRgn( hrgn_expect, hrgn_actual );
9295 if (!rgn_ok && broken( has_parentdc_anomaly && is_composited /* Win7 */ ))
9296 {
9297 if (winetest_debug > 1)
9298 {
9299 trace( "Forcing non-composited update region (broken)\n" );
9300 }
9301 rgn_ok = 1;
9302 }
9303 else
9304 {
9305 ok( !!rgn_ok, "Parent update region shall match expected region\n" );
9306 }
9307
9308 if (!rgn_ok && winetest_debug > 1)
9309 {
9310 trace( "Expected parent update region: " );
9311 dump_region( hrgn_expect );
9312 trace( "Actual parent update region: " );
9313 dump_region( hrgn_actual );
9314 trace( "Old child window visible area: %s\n", wine_dbgstr_rect( &rect_old_vis ) );
9315 trace( "New child window visible area: %s\n", wine_dbgstr_rect( &rect_new_vis ) );
9316 }
9317
9318 if (winetest_interactive)
9319 {
9320 if (!rgn_ok)
9321 {
9322 visualize_region_differences( hparent, hchild, hrgn_expect, hrgn_actual );
9323 }
9324
9325 /* Let the position change be visible to the user */
9326 flush_events();
9327 }
9328
9329 rect_new_vis_child = rect_new;
9330 MapWindowPoints( hparent, hchild, (POINT *)&rect_new_vis_child, 2 );
9331
9332 /* Compute child window expose region */
9333 GetClientRect( hchild, &rect_child_clip );
9334 if (is_composited)
9335 {
9336 RECT rect_outer_clip;
9337 GetClientRect( hparent, &rect_outer_clip );
9338 MapWindowPoints( hparent, hchild, (POINT *)&rect_outer_clip, 2 );
9339 IntersectRect( &rect_child_clip, &rect_child_clip, &rect_outer_clip );
9340 }
9341 IntersectRect( &rect_old_vis_child, &rect_old_vis_child, &rect_child_clip );
9342 SetRectRgn( hrgn_old_vis_child, rect_old_vis_child.left, rect_old_vis_child.top, rect_old_vis_child.right, rect_old_vis_child.bottom );
9343 IntersectRect( &rect_new_vis_child, &rect_new_vis_child, &rect_child_clip );
9344 SetRectRgn( hrgn_new_vis_child, rect_new_vis_child.left, rect_new_vis_child.top, rect_new_vis_child.right, rect_new_vis_child.bottom );
9345
9346 if (!EqualRect( &rect_old, &rect_new ) || is_zorder_redraw)
9347 {
9348 CombineRgn( hrgn_expect_child, hrgn_new_vis_child, hrgn_old_vis_child, is_composited ? RGN_OR : RGN_DIFF );
9349 }
9350 else
9351 {
9352 SetRectRgn( hrgn_expect_child, 0, 0, 0, 0 );
9353 }
9354
9355 rgn_ok = EqualRgn( hrgn_expect_child, hrgn_actual_child );
9356 if (!rgn_ok && broken( has_parentdc_anomaly && is_composited /* Win7 */ ))
9357 {
9358 if (winetest_debug > 1)
9359 {
9360 trace( "Forcing non-composited update region (broken)\n" );
9361 }
9362 rgn_ok = 1;
9363 }
9364 else
9365 {
9366 ok( !!rgn_ok, "Child update region shall match expected region\n" );
9367 }
9368
9369 if (!rgn_ok && winetest_debug > 1)
9370 {
9371 trace( "Expected child update region: " );
9372 dump_region( hrgn_expect_child );
9373 trace( "Actual child update region: " );
9374 dump_region( hrgn_actual_child );
9375 trace( "Old child window client visible area: %s\n", wine_dbgstr_rect( &rect_old_vis_child ) );
9376 trace( "New child window client visible area: %s\n", wine_dbgstr_rect( &rect_new_vis_child ) );
9377 }
9378
9379 if (winetest_interactive)
9380 {
9381 if (!rgn_ok)
9382 {
9383 visualize_region_differences( hchild, NULL, hrgn_expect_child, hrgn_actual_child );
9384 }
9385
9386 /* Let the position change be visible to the user */
9387 flush_events();
9388 }
9389
9390 winetest_pop_context();
9391 }
9392
9393 winetest_pop_context();
9394 }
9395
9396 DestroyWindow( hauxchild );
9397 DestroyWindow( hchild );
9398 DestroyWindow( hparent );
9399 if (htoplevel) DestroyWindow( htoplevel );
9400
9401 DeleteObject( hrgn_actual_child );
9402 DeleteObject( hrgn_expect_child );
9403 DeleteObject( hrgn_new_vis_child );
9404 DeleteObject( hrgn_old_vis_child );
9405 DeleteObject( hrgn_actual );
9406 DeleteObject( hrgn_expect );
9407 DeleteObject( hrgn_new_vis );
9408 DeleteObject( hrgn_old_vis );
9409 }
9410
9411 static void test_swp_paint_regions(void)
9412 {
9413 subtest_swp_paint_regions( 1, "SimpleWindowClass", "SimpleWindowClass" );
9414 subtest_swp_paint_regions( 0, "SimpleWindowClass", "SimpleWindowClass" );
9415 subtest_swp_paint_regions( 0, "SimpleWindowClass", "SimpleWindowClassWithParentDC" );
9416 subtest_swp_paint_regions( 0, "SimpleWindowClassWithParentDC", "SimpleWindowClass" );
9417 }
9418
9419 struct wnd_event
9420 {
9421 HWND hwnd;
9422 HANDLE grand_child;
9423 HANDLE start_event;
9424 HANDLE stop_event;
9425 };
9426
9427 static DWORD WINAPI thread_proc(void *param)
9428 {
9429 MSG msg;
9430 struct wnd_event *wnd_event = param;
9431
9432 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
9433 100, 100, 200, 200, 0, 0, 0, NULL);
9434 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
9435
9436 SetEvent(wnd_event->start_event);
9437
9438 while (GetMessageA(&msg, 0, 0, 0))
9439 {
9440 TranslateMessage(&msg);
9441 DispatchMessageA(&msg);
9442 }
9443
9444 ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
9445
9446 return 0;
9447 }
9448
9449 static DWORD CALLBACK create_grand_child_thread( void *param )
9450 {
9451 struct wnd_event *wnd_event = param;
9452 HWND hchild;
9453 MSG msg;
9454
9455 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
9456 WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
9457 ok (hchild != 0, "Failed to create child window\n");
9458 flush_events();
9459 flush_sequence();
9460 SetEvent( wnd_event->start_event );
9461
9462 for (;;)
9463 {
9464 MsgWaitForMultipleObjects(0, NULL, FALSE, 1000, QS_ALLINPUT);
9465 if (!IsWindow( hchild )) break; /* will be destroyed when parent thread exits */
9466 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
9467 }
9468 return 0;
9469 }
9470
9471 static DWORD CALLBACK create_child_thread( void *param )
9472 {
9473 struct wnd_event *wnd_event = param;
9474 struct wnd_event child_event;
9475 DWORD ret, tid;
9476 MSG msg;
9477
9478 child_event.hwnd = CreateWindowExA(0, "TestWindowClass", "Test child",
9479 WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, wnd_event->hwnd, 0, 0, NULL);
9480 ok (child_event.hwnd != 0, "Failed to create child window\n");
9481 SetFocus( child_event.hwnd );
9482 flush_events();
9483 flush_sequence();
9484 child_event.start_event = wnd_event->start_event;
9485 wnd_event->grand_child = CreateThread(NULL, 0, create_grand_child_thread, &child_event, 0, &tid);
9486 for (;;)
9487 {
9488 DWORD ret = MsgWaitForMultipleObjects(1, &child_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
9489 if (ret != 1) break;
9490 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
9491 }
9492 ret = WaitForSingleObject( wnd_event->stop_event, 5000 );
9493 ok( !ret, "WaitForSingleObject failed %lx\n", ret );
9494 return 0;
9495 }
9496
9497 static const char manifest_dep[] =
9498 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
9499 "<assemblyIdentity version=\"1.2.3.4\" name=\"testdep1\" type=\"win32\" processorArchitecture=\"" ARCH "\"/>"
9500 " <file name=\"testdep.dll\" />"
9501 "</assembly>";
9502
9503 static const char manifest_main[] =
9504 "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">"
9505 "<assemblyIdentity version=\"1.2.3.4\" name=\"Wine.Test\" type=\"win32\" />"
9506 "<dependency>"
9507 " <dependentAssembly>"
9508 " <assemblyIdentity type=\"win32\" name=\"testdep1\" version=\"1.2.3.4\" processorArchitecture=\"" ARCH "\" />"
9509 " </dependentAssembly>"
9510 "</dependency>"
9511 "</assembly>";
9512
9513 static void create_manifest_file(const char *filename, const char *manifest)
9514 {
9515 WCHAR path[MAX_PATH];
9516 HANDLE file;
9517 DWORD size;
9518
9519 MultiByteToWideChar( CP_ACP, 0, filename, -1, path, MAX_PATH );
9520 file = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
9521 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed: %lu\n", GetLastError());
9522 WriteFile(file, manifest, strlen(manifest), &size, NULL);
9523 CloseHandle(file);
9524 }
9525
9526 static HANDLE test_create(const char *file)
9527 {
9528 WCHAR path[MAX_PATH];
9529 ACTCTXW actctx;
9530 HANDLE handle;
9531
9532 MultiByteToWideChar(CP_ACP, 0, file, -1, path, MAX_PATH);
9533 memset(&actctx, 0, sizeof(ACTCTXW));
9534 actctx.cbSize = sizeof(ACTCTXW);
9535 actctx.lpSource = path;
9536
9537 handle = CreateActCtxW(&actctx);
9538 ok(handle != INVALID_HANDLE_VALUE, "failed to create context, error %lu\n", GetLastError());
9539
9540 ok(actctx.cbSize == sizeof(actctx), "cbSize=%ld\n", actctx.cbSize);
9541 ok(actctx.dwFlags == 0, "dwFlags=%ld\n", actctx.dwFlags);
9542 ok(actctx.lpSource == path, "lpSource=%p\n", actctx.lpSource);
9543 ok(actctx.wProcessorArchitecture == 0, "wProcessorArchitecture=%d\n", actctx.wProcessorArchitecture);
9544 ok(actctx.wLangId == 0, "wLangId=%d\n", actctx.wLangId);
9545 ok(actctx.lpAssemblyDirectory == NULL, "lpAssemblyDirectory=%p\n", actctx.lpAssemblyDirectory);
9546 ok(actctx.lpResourceName == NULL, "lpResourceName=%p\n", actctx.lpResourceName);
9547 ok(actctx.lpApplicationName == NULL, "lpApplicationName=%p\n", actctx.lpApplicationName);
9548 ok(actctx.hModule == NULL, "hModule=%p\n", actctx.hModule);
9549
9550 return handle;
9551 }
9552
9553 static void test_interthread_messages(void)
9554 {
9555 HANDLE hThread, context, handle, event;
9556 ULONG_PTR cookie;
9557 DWORD tid;
9558 WNDPROC proc;
9559 MSG msg;
9560 char buf[256];
9561 int len, expected_len;
9562 struct wnd_event wnd_event;
9563 BOOL ret;
9564
9565 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
9566 if (!wnd_event.start_event)
9567 {
9568 win_skip("skipping interthread message test under win9x\n");
9569 return;
9570 }
9571
9572 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
9573 ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
9574
9575 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9576
9577 CloseHandle(wnd_event.start_event);
9578
9579 SetLastError(0xdeadbeef);
9580 ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeeded\n");
9581 ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == 0xdeadbeef,
9582 "wrong error code %ld\n", GetLastError());
9583
9584 proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
9585 ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %ld\n", GetLastError());
9586
9587 expected_len = lstrlenA("window caption text");
9588 memset(buf, 0, sizeof(buf));
9589 SetLastError(0xdeadbeef);
9590 len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
9591 ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %ld, len %d, expected len %d\n", GetLastError(), len, expected_len);
9592 ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
9593
9594 msg.hwnd = wnd_event.hwnd;
9595 msg.message = WM_GETTEXT;
9596 msg.wParam = sizeof(buf);
9597 msg.lParam = (LPARAM)buf;
9598 memset(buf, 0, sizeof(buf));
9599 SetLastError(0xdeadbeef);
9600 len = DispatchMessageA(&msg);
9601 ok((!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY) || broken(len), /* nt4 */
9602 "DispatchMessageA(WM_GETTEXT) succeeded on another thread window: ret %d, error %ld\n", len, GetLastError());
9603
9604 /* the following test causes an exception in user.exe under win9x */
9605 msg.hwnd = wnd_event.hwnd;
9606 msg.message = WM_TIMER;
9607 msg.wParam = 0;
9608 msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
9609 SetLastError(0xdeadbeef);
9610 len = DispatchMessageA(&msg);
9611 ok(!len && GetLastError() == 0xdeadbeef,
9612 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %ld\n", len, GetLastError());
9613
9614 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
9615 ok( ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
9616
9617 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9618 CloseHandle(hThread);
9619
9620 ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
9621
9622 wnd_event.hwnd = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
9623 100, 100, 200, 200, 0, 0, 0, NULL);
9624 ok (wnd_event.hwnd != 0, "Failed to create parent window\n");
9625 flush_events();
9626 flush_sequence();
9627 log_all_parent_messages++;
9628 wnd_event.start_event = CreateEventA( NULL, TRUE, FALSE, NULL );
9629 wnd_event.stop_event = CreateEventA( NULL, TRUE, FALSE, NULL );
9630 hThread = CreateThread( NULL, 0, create_child_thread, &wnd_event, 0, &tid );
9631 for (;;)
9632 {
9633 ret = MsgWaitForMultipleObjects(1, &wnd_event.start_event, FALSE, 1000, QS_SENDMESSAGE);
9634 if (ret != 1) break;
9635 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
9636 }
9637 ok( !ret, "MsgWaitForMultipleObjects failed %x\n", ret );
9638 /* now wait for the thread without processing messages; this shouldn't deadlock */
9639 SetEvent( wnd_event.stop_event );
9640 ret = WaitForSingleObject( hThread, 5000 );
9641 ok( !ret, "WaitForSingleObject failed %x\n", ret );
9642 CloseHandle( hThread );
9643
9644 ret = WaitForSingleObject( wnd_event.grand_child, 5000 );
9645 ok( !ret, "WaitForSingleObject failed %x\n", ret );
9646 CloseHandle( wnd_event.grand_child );
9647
9648 CloseHandle( wnd_event.start_event );
9649 CloseHandle( wnd_event.stop_event );
9650 flush_events();
9651 ok_sequence(WmExitThreadSeq, "destroy child on thread exit", FALSE);
9652 log_all_parent_messages--;
9653 DestroyWindow( wnd_event.hwnd );
9654
9655 /* Activation context tests */
9656 create_manifest_file("testdep1.manifest", manifest_dep);
9657 create_manifest_file("main.manifest", manifest_main);
9658
9659 context = test_create("main.manifest");
9660 DeleteFileA("testdep1.manifest");
9661 DeleteFileA("main.manifest");
9662
9663 handle = (void*)0xdeadbeef;
9664 ret = GetCurrentActCtx(&handle);
9665 ok(ret, "GetCurrentActCtx failed: %lu\n", GetLastError());
9666 ok(handle == 0, "active context %p\n", handle);
9667
9668 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
9669 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
9670 ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
9671 ok(WaitForSingleObject(wnd_event.start_event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9672 CloseHandle(wnd_event.start_event);
9673
9674 /* context is activated after thread creation, so it doesn't inherit it by default */
9675 ret = ActivateActCtx(context, &cookie);
9676 ok(ret, "activation failed: %lu\n", GetLastError());
9677
9678 handle = 0;
9679 ret = GetCurrentActCtx(&handle);
9680 ok(ret, "GetCurrentActCtx failed: %lu\n", GetLastError());
9681 ok(handle != 0, "active context %p\n", handle);
9682 ReleaseActCtx(handle);
9683
9684 /* destination window will test for active context */
9685 ret = SendMessageA(wnd_event.hwnd, WM_USER+10, 0, 0);
9686 ok(ret, "thread window returned %d\n", ret);
9687
9688 event = CreateEventW(NULL, 0, 0, NULL);
9689 ret = PostMessageA(wnd_event.hwnd, WM_USER+10, 0, (LPARAM)event);
9690 ok(ret, "thread window returned %d\n", ret);
9691 ok(WaitForSingleObject(event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9692 CloseHandle(event);
9693
9694 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
9695 ok(ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
9696
9697 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
9698 CloseHandle(hThread);
9699
9700 ret = DeactivateActCtx(0, cookie);
9701 ok(ret, "DeactivateActCtx failed: %lu\n", GetLastError());
9702 ReleaseActCtx(context);
9703 }
9704
9705
9706 static const struct message WmVkN[] = {
9707 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
9708 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
9709 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
9710 { WM_CHAR, wparam|lparam, 'n', 1 },
9711 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
9712 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
9713 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
9714 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
9715 { 0 }
9716 };
9717 static const struct message WmShiftVkN[] = {
9718 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
9719 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
9720 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
9721 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
9722 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
9723 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
9724 { WM_CHAR, wparam|lparam, 'N', 1 },
9725 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
9726 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
9727 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
9728 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
9729 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
9730 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
9731 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
9732 { 0 }
9733 };
9734 static const struct message WmCtrlVkN[] = {
9735 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
9736 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
9737 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
9738 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
9739 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
9740 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
9741 { WM_CHAR, wparam|lparam, 0x000e, 1 },
9742 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
9743 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
9744 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
9745 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
9746 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
9747 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
9748 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
9749 { 0 }
9750 };
9751 static const struct message WmCtrlVkN_2[] = {
9752 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
9753 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
9754 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
9755 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
9756 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
9757 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
9758 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
9759 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
9760 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
9761 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
9762 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
9763 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
9764 { 0 }
9765 };
9766 static const struct message WmAltVkN[] = {
9767 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
9768 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
9769 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
9770 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
9771 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
9772 { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
9773 { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
9774 { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
9775 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
9776 { HCBT_SYSCOMMAND, hook },
9777 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
9778 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
9779 { 0x00AE, sent|defwinproc|optional }, /* XP */
9780 { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
9781 { WM_INITMENU, sent|defwinproc },
9782 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9783 { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
9784 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
9785 { WM_CAPTURECHANGED, sent|defwinproc },
9786 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
9787 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9788 { WM_EXITMENULOOP, sent|defwinproc },
9789 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
9790 { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
9791 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
9792 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
9793 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
9794 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
9795 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
9796 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
9797 { 0 }
9798 };
9799 static const struct message WmAltVkN_2[] = {
9800 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
9801 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
9802 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
9803 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
9804 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
9805 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
9806 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
9807 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
9808 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
9809 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
9810 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
9811 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
9812 { 0 }
9813 };
9814 static const struct message WmCtrlAltVkN[] = {
9815 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
9816 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
9817 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
9818 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
9819 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
9820 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
9821 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
9822 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
9823 { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
9824 { WM_CHAR, optional },
9825 { WM_CHAR, sent|optional },
9826 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
9827 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
9828 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
9829 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
9830 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
9831 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
9832 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
9833 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
9834 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
9835 { 0 }
9836 };
9837 static const struct message WmCtrlShiftVkN[] = {
9838 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
9839 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
9840 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
9841 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
9842 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
9843 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
9844 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
9845 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
9846 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
9847 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
9848 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
9849 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
9850 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
9851 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
9852 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
9853 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
9854 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
9855 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
9856 { 0 }
9857 };
9858 static const struct message WmCtrlAltShiftVkN[] = {
9859 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
9860 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
9861 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
9862 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
9863 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
9864 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
9865 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0x20000001 }, /* XP */
9866 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
9867 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
9868 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
9869 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
9870 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
9871 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
9872 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
9873 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
9874 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xe0000001 }, /* XP */
9875 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
9876 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
9877 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
9878 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
9879 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
9880 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
9881 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
9882 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
9883 { 0 }
9884 };
9885 static const struct message WmAltPressRelease[] = {
9886 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
9887 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
9888 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
9889 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
9890 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
9891 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
9892 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
9893 { HCBT_SYSCOMMAND, hook },
9894 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
9895 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
9896 { WM_INITMENU, sent|defwinproc },
9897 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9898 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
9899 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 1 },
9900
9901 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x30000001 }, /* XP */
9902
9903 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9904 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0, },
9905 { WM_CAPTURECHANGED, sent|defwinproc },
9906 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
9907 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9908 { WM_EXITMENULOOP, sent|defwinproc },
9909 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
9910 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
9911 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
9912 { 0 }
9913 };
9914 static const struct message WmShiftMouseButton[] = {
9915 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
9916 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
9917 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
9918 { WM_MOUSEMOVE, wparam|optional, 0, 0 },
9919 { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
9920 { WM_LBUTTONDOWN, wparam, MK_LBUTTON|MK_SHIFT, 0 },
9921 { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON|MK_SHIFT, 0 },
9922 { WM_LBUTTONUP, wparam|optional, MK_SHIFT, 0 }, /* < w1064v1809 */
9923 { WM_LBUTTONUP, sent|wparam|optional, MK_SHIFT, 0 }, /* < w1064v1809 */
9924 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
9925 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
9926 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
9927 { WM_LBUTTONUP, optional, 0, 0 }, /* >= w1064v1809 */
9928 { WM_LBUTTONUP, sent|optional, 0, 0 }, /* >= w1064v1809 */
9929 { 0 }
9930 };
9931 static const struct message WmF1Seq[] = {
9932 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 1 }, /* XP */
9933 { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
9934 { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
9935 { WM_KEYF1, wparam|lparam, 0, 0 },
9936 { WM_KEYF1, sent|wparam|lparam, 0, 0 },
9937 { WM_HELP, sent|defwinproc },
9938 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 0xc0000001 }, /* XP */
9939 { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
9940 { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
9941 { 0 }
9942 };
9943 static const struct message WmVkAppsSeq[] = {
9944 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 1 }, /* XP */
9945 { WM_KEYDOWN, wparam|lparam, VK_APPS, 1 },
9946 { WM_KEYDOWN, sent|wparam|lparam, VK_APPS, 0x00000001 },
9947 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 0xc0000001 }, /* XP */
9948 { WM_KEYUP, wparam|lparam, VK_APPS, 0xc0000001 },
9949 { WM_KEYUP, sent|wparam|lparam, VK_APPS, 0xc0000001 },
9950 { WM_CONTEXTMENU, lparam, /*hwnd*/0, -1 },
9951 { WM_CONTEXTMENU, sent|lparam, /*hwnd*/0, -1 },
9952 { 0 }
9953 };
9954 static const struct message WmVkF10Seq[] = {
9955 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
9956 { WM_SYSKEYDOWN, wparam|lparam, VK_F10, 1 },
9957 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_F10, 0x00000001 },
9958 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
9959 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
9960 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
9961 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_KEYMENU },
9962 { HCBT_SYSCOMMAND, hook },
9963 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
9964 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
9965 { WM_INITMENU, sent|defwinproc },
9966 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9967 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
9968 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 1 },
9969
9970 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0x10000001 }, /* XP */
9971
9972 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
9973 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9974 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0, },
9975 { WM_CAPTURECHANGED, sent|defwinproc },
9976 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
9977 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
9978 { WM_EXITMENULOOP, sent|defwinproc },
9979 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
9980 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
9981 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
9982 { 0 }
9983 };
9984 static const struct message WmShiftF10Seq[] = {
9985 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
9986 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
9987 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x00000001 },
9988 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 1 }, /* XP */
9989 { WM_SYSKEYDOWN, wparam|lparam, VK_F10, 1 },
9990 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_F10, 0x00000001 },
9991 { WM_CONTEXTMENU, sent|defwinproc|lparam, /*hwnd*/0, -1 },
9992 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F10, 0xc0000001 }, /* XP */
9993 { WM_SYSKEYUP, wparam|lparam, VK_F10, 0xc0000001 },
9994 { WM_SYSKEYUP, sent|wparam|lparam, VK_F10, 0xc0000001 },
9995 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_KEYMENU },
9996 { HCBT_SYSCOMMAND, hook },
9997 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
9998 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
9999 { WM_INITMENU, sent|defwinproc },
10000 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
10001 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE), 0, MAKEWPARAM(0,MF_RIGHTJUSTIFY) },
10002 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 1 },
10003 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xd0000001 }, /* XP */
10004 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0x10000001 }, /* XP */
10005 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
10006 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
10007 { WM_CAPTURECHANGED, sent|defwinproc|wparam|lparam, 0, 0 },
10008 { WM_MENUSELECT, sent|defwinproc|wparam|lparam, 0xffff0000, 0 },
10009 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_SYSMENU, 0 },
10010 { WM_EXITMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
10011 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0xc0000001 }, /* XP */
10012 { WM_KEYUP, wparam|lparam, VK_ESCAPE, 0xc0000001 },
10013 { WM_KEYUP, sent|wparam|lparam, VK_ESCAPE, 0xc0000001 },
10014 { 0 }
10015 };
10016
10017 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
10018 {
10019 MSG msg;
10020
10021 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
10022 {
10023 struct recvd_message log_msg;
10024
10025 /* ignore some unwanted messages */
10026 if (msg.message == WM_MOUSEMOVE ||
10027 msg.message == WM_TIMER ||
10028 ignore_message( msg.message ))
10029 continue;
10030
10031 log_msg.hwnd = msg.hwnd;
10032 log_msg.message = msg.message;
10033 log_msg.flags = wparam|lparam;
10034 log_msg.wParam = msg.wParam;
10035 log_msg.lParam = msg.lParam;
10036 log_msg.descr = "accel";
10037 add_message(&log_msg);
10038
10039 if (!hAccel || !TranslateAcceleratorA(hwnd, hAccel, &msg))
10040 {
10041 TranslateMessage(&msg);
10042 DispatchMessageA(&msg);
10043 }
10044 }
10045 }
10046
10047 static void test_accelerators(void)
10048 {
10049 RECT rc;
10050 POINT pt;
10051 SHORT state;
10052 HACCEL hAccel;
10053 HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10054 100, 100, 200, 200, 0, 0, 0, NULL);
10055 BOOL us_kbd = (GetKeyboardLayout(0) == (HKL)(ULONG_PTR)0x04090409);
10056 BOOL ret;
10057
10058 assert(hwnd != 0);
10059 UpdateWindow(hwnd);
10060 flush_events();
10061 flush_sequence();
10062
10063 SetFocus(hwnd);
10064 ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
10065
10066 state = GetKeyState(VK_SHIFT);
10067 ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
10068 state = GetKeyState(VK_CAPITAL);
10069 ok(state == 0, "wrong CapsLock state %04x\n", state);
10070
10071 hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
10072 assert(hAccel != 0);
10073
10074 flush_events();
10075 pump_msg_loop(hwnd, 0);
10076 flush_sequence();
10077
10078 if (!us_kbd)
10079 {
10080 skip("skipping ascii VK events on non-us keyboard\n");
10081 goto done;
10082 }
10083
10084 if (winetest_debug > 1) trace("testing VK_N press/release\n");
10085 flush_sequence();
10086 keybd_event('N', 0, 0, 0);
10087 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10088 pump_msg_loop(hwnd, hAccel);
10089 if (!sequence_cnt) /* we didn't get any message */
10090 {
10091 skip( "queuing key events not supported\n" );
10092 goto done;
10093 }
10094 ok_sequence(WmVkN, "VK_N press/release", FALSE);
10095
10096 if (winetest_debug > 1) trace("testing Shift+VK_N press/release\n");
10097 flush_sequence();
10098 keybd_event(VK_SHIFT, 0, 0, 0);
10099 keybd_event('N', 0, 0, 0);
10100 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10101 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
10102 pump_msg_loop(hwnd, hAccel);
10103 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
10104
10105 if (winetest_debug > 1) trace("testing Ctrl+VK_N press/release\n");
10106 flush_sequence();
10107 keybd_event(VK_CONTROL, 0, 0, 0);
10108 keybd_event('N', 0, 0, 0);
10109 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10110 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
10111 pump_msg_loop(hwnd, hAccel);
10112 ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
10113
10114 if (winetest_debug > 1) trace("testing Alt+VK_N press/release\n");
10115 flush_sequence();
10116 keybd_event(VK_MENU, 0, 0, 0);
10117 keybd_event('N', 0, 0, 0);
10118 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10119 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10120 pump_msg_loop(hwnd, hAccel);
10121 ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
10122
10123 if (winetest_debug > 1) trace("testing Ctrl+Alt+VK_N press/release 1\n");
10124 flush_sequence();
10125 keybd_event(VK_CONTROL, 0, 0, 0);
10126 keybd_event(VK_MENU, 0, 0, 0);
10127 keybd_event('N', 0, 0, 0);
10128 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10129 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10130 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
10131 pump_msg_loop(hwnd, hAccel);
10132 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
10133
10134 ret = DestroyAcceleratorTable(hAccel);
10135 ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
10136
10137 hAccel = LoadAcceleratorsA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(2));
10138 assert(hAccel != 0);
10139
10140 if (winetest_debug > 1) trace("testing VK_N press/release\n");
10141 flush_sequence();
10142 keybd_event('N', 0, 0, 0);
10143 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10144 pump_msg_loop(hwnd, hAccel);
10145 ok_sequence(WmVkN, "VK_N press/release", FALSE);
10146
10147 if (winetest_debug > 1) trace("testing Shift+VK_N press/release\n");
10148 flush_sequence();
10149 keybd_event(VK_SHIFT, 0, 0, 0);
10150 keybd_event('N', 0, 0, 0);
10151 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10152 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
10153 pump_msg_loop(hwnd, hAccel);
10154 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
10155
10156 if (winetest_debug > 1) trace("testing Ctrl+VK_N press/release 2\n");
10157 flush_sequence();
10158 keybd_event(VK_CONTROL, 0, 0, 0);
10159 keybd_event('N', 0, 0, 0);
10160 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10161 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
10162 pump_msg_loop(hwnd, hAccel);
10163 ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
10164
10165 if (winetest_debug > 1) trace("testing Alt+VK_N press/release 2\n");
10166 flush_sequence();
10167 keybd_event(VK_MENU, 0, 0, 0);
10168 keybd_event('N', 0, 0, 0);
10169 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10170 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10171 pump_msg_loop(hwnd, hAccel);
10172 ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
10173
10174 if (winetest_debug > 1) trace("testing Ctrl+Alt+VK_N press/release 2\n");
10175 flush_sequence();
10176 keybd_event(VK_CONTROL, 0, 0, 0);
10177 keybd_event(VK_MENU, 0, 0, 0);
10178 keybd_event('N', 0, 0, 0);
10179 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10180 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10181 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
10182 pump_msg_loop(hwnd, hAccel);
10183 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
10184
10185 if (winetest_debug > 1) trace("testing Ctrl+Shift+VK_N press/release\n");
10186 flush_sequence();
10187 keybd_event(VK_CONTROL, 0, 0, 0);
10188 keybd_event(VK_SHIFT, 0, 0, 0);
10189 keybd_event('N', 0, 0, 0);
10190 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10191 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
10192 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
10193 pump_msg_loop(hwnd, hAccel);
10194 ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
10195
10196 if (winetest_debug > 1) trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
10197 flush_sequence();
10198 keybd_event(VK_CONTROL, 0, 0, 0);
10199 keybd_event(VK_MENU, 0, 0, 0);
10200 keybd_event(VK_SHIFT, 0, 0, 0);
10201 keybd_event('N', 0, 0, 0);
10202 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
10203 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
10204 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10205 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
10206 pump_msg_loop(hwnd, hAccel);
10207 ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
10208
10209 ret = DestroyAcceleratorTable(hAccel);
10210 ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
10211 hAccel = 0;
10212
10213 if (winetest_debug > 1) trace("testing Alt press/release\n");
10214 flush_sequence();
10215 keybd_event(VK_MENU, 0, 0, 0);
10216 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10217 keybd_event(VK_MENU, 0, 0, 0);
10218 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
10219 pump_msg_loop(hwnd, 0);
10220 /* this test doesn't pass in Wine for managed windows */
10221 ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
10222
10223 if (winetest_debug > 1) trace("testing VK_F1 press/release\n");
10224 keybd_event(VK_F1, 0, 0, 0);
10225 keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
10226 pump_msg_loop(hwnd, 0);
10227 ok_sequence(WmF1Seq, "F1 press/release", FALSE);
10228
10229 if (winetest_debug > 1) trace("testing VK_APPS press/release\n");
10230 keybd_event(VK_APPS, 0, 0, 0);
10231 keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
10232 pump_msg_loop(hwnd, 0);
10233 ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
10234
10235 if (winetest_debug > 1) trace("testing VK_F10 press/release\n");
10236 keybd_event(VK_F10, 0, 0, 0);
10237 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
10238 keybd_event(VK_F10, 0, 0, 0);
10239 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
10240 pump_msg_loop(hwnd, 0);
10241 ok_sequence(WmVkF10Seq, "VK_F10 press/release", TRUE);
10242
10243 if (winetest_debug > 1) trace("testing SHIFT+F10 press/release\n");
10244 keybd_event(VK_SHIFT, 0, 0, 0);
10245 keybd_event(VK_F10, 0, 0, 0);
10246 keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
10247 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
10248 keybd_event(VK_ESCAPE, 0, 0, 0);
10249 keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
10250 pump_msg_loop(hwnd, 0);
10251 ok_sequence(WmShiftF10Seq, "SHIFT+F10 press/release", TRUE);
10252
10253 if (winetest_debug > 1) trace("testing Shift+MouseButton press/release\n");
10254 /* first, move mouse pointer inside of the window client area */
10255 GetClientRect(hwnd, &rc);
10256 MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
10257 rc.left += (rc.right - rc.left)/2;
10258 rc.top += (rc.bottom - rc.top)/2;
10259 SetCursorPos(rc.left, rc.top);
10260 SetActiveWindow(hwnd);
10261
10262 flush_events();
10263 flush_sequence();
10264 GetCursorPos(&pt);
10265 if (pt.x == rc.left && pt.y == rc.top)
10266 {
10267 int i;
10268 keybd_event(VK_SHIFT, 0, 0, 0);
10269 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
10270 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
10271 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
10272 pump_msg_loop(hwnd, 0);
10273 for (i = 0; i < sequence_cnt; i++) if (sequence[i].message == WM_LBUTTONDOWN) break;
10274 if (i < sequence_cnt)
10275 ok_sequence(WmShiftMouseButton, "Shift+MouseButton press/release", FALSE);
10276 else
10277 skip( "Shift+MouseButton event didn't get to the window\n" );
10278 }
10279
10280 done:
10281 if (hAccel) DestroyAcceleratorTable(hAccel);
10282 DestroyWindow(hwnd);
10283 }
10284
10285 /************* window procedures ********************/
10286
10287 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message,
10288 WPARAM wParam, LPARAM lParam)
10289 {
10290 static LONG defwndproc_counter = 0;
10291 static LONG beginpaint_counter = 0;
10292 LRESULT ret;
10293 struct recvd_message msg;
10294
10295 if (ignore_message( message )) return 0;
10296
10297 switch (message)
10298 {
10299 case WM_ENABLE:
10300 {
10301 LONG style = GetWindowLongA(hwnd, GWL_STYLE);
10302 ok((BOOL)wParam == !(style & WS_DISABLED),
10303 "wrong WS_DISABLED state: %Id != %d\n", wParam, !(style & WS_DISABLED));
10304 break;
10305 }
10306
10307 case WM_CAPTURECHANGED:
10308 if (test_DestroyWindow_flag)
10309 {
10310 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
10311 if (style & WS_CHILD)
10312 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
10313 else if (style & WS_POPUP)
10314 lParam = WND_POPUP_ID;
10315 else
10316 lParam = WND_PARENT_ID;
10317 }
10318 break;
10319
10320 case WM_NCDESTROY:
10321 {
10322 HWND capture;
10323
10324 ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
10325 capture = GetCapture();
10326 if (capture)
10327 {
10328 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
10329 if (winetest_debug > 1) trace("current capture %p, releasing...\n", capture);
10330 ReleaseCapture();
10331 }
10332 }
10333 /* fall through */
10334 case WM_DESTROY:
10335 ok(GetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
10336 if (test_DestroyWindow_flag)
10337 {
10338 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
10339 if (style & WS_CHILD)
10340 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
10341 else if (style & WS_POPUP)
10342 lParam = WND_POPUP_ID;
10343 else
10344 lParam = WND_PARENT_ID;
10345 }
10346 break;
10347
10348 /* test_accelerators() depends on this */
10349 case WM_NCHITTEST:
10350 return HTCLIENT;
10351
10352 case WM_USER+10:
10353 {
10354 ACTIVATION_CONTEXT_BASIC_INFORMATION basicinfo;
10355 HANDLE handle, event = (HANDLE)lParam;
10356 BOOL ret;
10357
10358 handle = (void*)0xdeadbeef;
10359 ret = GetCurrentActCtx(&handle);
10360 ok(ret, "failed to get current context, %lu\n", GetLastError());
10361 ok(handle == 0, "got active context %p\n", handle);
10362
10363 memset(&basicinfo, 0xff, sizeof(basicinfo));
10364 ret = QueryActCtxW(QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX, handle, 0, ActivationContextBasicInformation,
10365 &basicinfo, sizeof(basicinfo), NULL);
10366 ok(ret, "got %d, error %ld\n", ret, GetLastError());
10367 ok(basicinfo.hActCtx == NULL, "got %p\n", basicinfo.hActCtx);
10368 ok(basicinfo.dwFlags == 0, "got %lx\n", basicinfo.dwFlags);
10369
10370 if (event) SetEvent(event);
10371 return 1;
10372 }
10373
10374 /* ignore */
10375 case WM_MOUSEMOVE:
10376 case WM_MOUSEACTIVATE:
10377 case WM_NCMOUSEMOVE:
10378 case WM_SETCURSOR:
10379 case WM_IME_SELECT:
10380 return 0;
10381 }
10382
10383 msg.hwnd = hwnd;
10384 msg.message = message;
10385 msg.flags = sent|wparam|lparam;
10386 if (defwndproc_counter) msg.flags |= defwinproc;
10387 if (beginpaint_counter) msg.flags |= beginpaint;
10388 msg.wParam = wParam;
10389 msg.lParam = lParam;
10390 msg.descr = "MsgCheckProc";
10391 add_message(&msg);
10392
10393 if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
10394 {
10395 HWND parent = GetParent(hwnd);
10396 RECT rc;
10397 MINMAXINFO *minmax = (MINMAXINFO *)lParam;
10398
10399 GetClientRect(parent, &rc);
10400 if (winetest_debug > 1)
10401 {
10402 trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
10403 trace("Reserved=%ld,%ld MaxSize=%ld,%ld MaxPos=%ld,%ld MinTrack=%ld,%ld MaxTrack=%ld,%ld\n",
10404 minmax->ptReserved.x, minmax->ptReserved.y,
10405 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
10406 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
10407 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
10408 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
10409 }
10410 ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %ld != %ld\n",
10411 minmax->ptMaxSize.x, rc.right);
10412 ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %ld != %ld\n",
10413 minmax->ptMaxSize.y, rc.bottom);
10414 }
10415
10416 if (message == WM_PAINT)
10417 {
10418 PAINTSTRUCT ps;
10419 beginpaint_counter++;
10420 BeginPaint( hwnd, &ps );
10421 beginpaint_counter--;
10422 EndPaint( hwnd, &ps );
10423 return 0;
10424 }
10425
10426 if (!test_context_menu && message == WM_CONTEXTMENU)
10427 {
10428 /* don't create context menu */
10429 return 0;
10430 }
10431
10432 defwndproc_counter++;
10433 ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
10434 : DefWindowProcA(hwnd, message, wParam, lParam);
10435 defwndproc_counter--;
10436
10437 return ret;
10438 }
10439
10440 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10441 {
10442 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
10443 }
10444
10445 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10446 {
10447 return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
10448 }
10449
10450 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10451 {
10452 static LONG defwndproc_counter = 0;
10453 LRESULT ret;
10454 struct recvd_message msg;
10455
10456 if (ignore_message( message )) return 0;
10457
10458 switch (message)
10459 {
10460 case WM_QUERYENDSESSION:
10461 case WM_ENDSESSION:
10462 lParam &= ~0x01; /* Vista adds a 0x01 flag */
10463 break;
10464 }
10465
10466 msg.hwnd = hwnd;
10467 msg.message = message;
10468 msg.flags = sent|wparam|lparam;
10469 if (defwndproc_counter) msg.flags |= defwinproc;
10470 msg.wParam = wParam;
10471 msg.lParam = lParam;
10472 msg.descr = "popup";
10473 add_message(&msg);
10474
10475 if (message == WM_CREATE)
10476 {
10477 DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
10478 SetWindowLongA(hwnd, GWL_STYLE, style);
10479 }
10480
10481 defwndproc_counter++;
10482 ret = DefWindowProcA(hwnd, message, wParam, lParam);
10483 defwndproc_counter--;
10484
10485 return ret;
10486 }
10487
10488 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10489 {
10490 static LONG defwndproc_counter = 0;
10491 static LONG beginpaint_counter = 0;
10492 LRESULT ret;
10493 struct recvd_message msg;
10494
10495 if (ignore_message( message )) return 0;
10496
10497 if (log_all_parent_messages ||
10498 message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
10499 message == WM_SETFOCUS || message == WM_KILLFOCUS ||
10500 message == WM_ENABLE || message == WM_ENTERIDLE ||
10501 message == WM_DRAWITEM || message == WM_MEASUREITEM || message == WM_COMPAREITEM ||
10502 message == WM_COMMAND || message == WM_IME_SETCONTEXT)
10503 {
10504 switch (message)
10505 {
10506 /* ignore */
10507 case WM_NCHITTEST:
10508 return HTCLIENT;
10509 case WM_SETCURSOR:
10510 case WM_MOUSEMOVE:
10511 case WM_NCMOUSEMOVE:
10512 return 0;
10513 }
10514
10515 msg.hwnd = hwnd;
10516 msg.message = message;
10517 msg.flags = sent|parent|wparam|lparam;
10518 if (defwndproc_counter) msg.flags |= defwinproc;
10519 if (beginpaint_counter) msg.flags |= beginpaint;
10520 msg.wParam = wParam;
10521 msg.lParam = lParam;
10522 msg.descr = "parent";
10523 add_message(&msg);
10524 }
10525
10526 if (message == WM_PAINT)
10527 {
10528 PAINTSTRUCT ps;
10529 beginpaint_counter++;
10530 BeginPaint( hwnd, &ps );
10531 beginpaint_counter--;
10532 EndPaint( hwnd, &ps );
10533 return 0;
10534 }
10535
10536 defwndproc_counter++;
10537 ret = DefWindowProcA(hwnd, message, wParam, lParam);
10538 defwndproc_counter--;
10539
10540 return message == WM_COMPAREITEM ? -1 : ret;
10541 }
10542
10543 static LRESULT CALLBACK StopQuitMsgCheckProcA(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
10544 {
10545 if (message == WM_CREATE)
10546 PostMessageA(hwnd, WM_CLOSE, 0, 0);
10547 else if (message == WM_CLOSE)
10548 {
10549 /* Only the first WM_QUIT will survive the window destruction */
10550 PostMessageA(hwnd, WM_USER, 0x1234, 0x5678);
10551 PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
10552 PostMessageA(hwnd, WM_QUIT, 0x4321, 0x8765);
10553 }
10554
10555 return DefWindowProcA(hwnd, message, wp, lp);
10556 }
10557
10558 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10559 {
10560 static LONG defwndproc_counter = 0;
10561 LRESULT ret;
10562 struct recvd_message msg;
10563
10564 if (ignore_message( message )) return 0;
10565
10566 if (test_def_id)
10567 {
10568 DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
10569 ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
10570 if (after_end_dialog)
10571 ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %Ix\n", ret );
10572 else
10573 ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %Ix\n", ret);
10574 }
10575
10576 msg.hwnd = hwnd;
10577 msg.message = message;
10578 msg.flags = sent|wparam|lparam;
10579 if (defwndproc_counter) msg.flags |= defwinproc;
10580 msg.wParam = wParam;
10581 msg.lParam = lParam;
10582 msg.descr = "dialog";
10583 add_message(&msg);
10584
10585 defwndproc_counter++;
10586 ret = DefDlgProcA(hwnd, message, wParam, lParam);
10587 defwndproc_counter--;
10588
10589 return ret;
10590 }
10591
10592 static LRESULT WINAPI ShowWindowProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10593 {
10594 static LONG defwndproc_counter = 0;
10595 LRESULT ret;
10596 struct recvd_message msg;
10597
10598 /* log only specific messages we are interested in */
10599 switch (message)
10600 {
10601 #if 0 /* probably log these as well */
10602 case WM_ACTIVATE:
10603 case WM_SETFOCUS:
10604 case WM_KILLFOCUS:
10605 #endif
10606 case WM_SHOWWINDOW:
10607 case WM_SIZE:
10608 case WM_MOVE:
10609 case WM_GETMINMAXINFO:
10610 case WM_WINDOWPOSCHANGING:
10611 case WM_WINDOWPOSCHANGED:
10612 break;
10613
10614 default: /* ignore */
10615 /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
10616 return DefWindowProcA(hwnd, message, wParam, lParam);
10617 }
10618
10619 msg.hwnd = hwnd;
10620 msg.message = message;
10621 msg.flags = sent|wparam|lparam;
10622 if (defwndproc_counter) msg.flags |= defwinproc;
10623 msg.wParam = wParam;
10624 msg.lParam = lParam;
10625 msg.descr = "show";
10626 add_message(&msg);
10627
10628 defwndproc_counter++;
10629 ret = DefWindowProcA(hwnd, message, wParam, lParam);
10630 defwndproc_counter--;
10631
10632 return ret;
10633 }
10634
10635 static LRESULT WINAPI PaintLoopProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
10636 {
10637 switch (msg)
10638 {
10639 case WM_CREATE: return 0;
10640 case WM_PAINT:
10641 {
10642 MSG msg2;
10643 static int i = 0;
10644
10645 if (i < 256)
10646 {
10647 i++;
10648 if (PeekMessageA(&msg2, 0, 0, 0, 1))
10649 {
10650 TranslateMessage(&msg2);
10651 DispatchMessageA(&msg2);
10652 }
10653 i--;
10654 }
10655 else ok(broken(1), "infinite loop\n");
10656 if ( i == 0)
10657 paint_loop_done = TRUE;
10658 return DefWindowProcA(hWnd,msg,wParam,lParam);
10659 }
10660 }
10661 return DefWindowProcA(hWnd,msg,wParam,lParam);
10662 }
10663
10664 static LRESULT WINAPI HotkeyMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
10665 {
10666 static LONG defwndproc_counter = 0;
10667 LRESULT ret;
10668 struct recvd_message msg;
10669 DWORD queue_status;
10670
10671 if (ignore_message( message )) return 0;
10672
10673 if ((message >= WM_KEYFIRST && message <= WM_KEYLAST) ||
10674 message == WM_HOTKEY || message >= WM_APP)
10675 {
10676 msg.hwnd = hwnd;
10677 msg.message = message;
10678 msg.flags = sent|wparam|lparam;
10679 if (defwndproc_counter) msg.flags |= defwinproc;
10680 msg.wParam = wParam;
10681 msg.lParam = lParam;
10682 msg.descr = "HotkeyMsgCheckProcA";
10683 add_message(&msg);
10684 }
10685
10686 defwndproc_counter++;
10687 ret = DefWindowProcA(hwnd, message, wParam, lParam);
10688 defwndproc_counter--;
10689
10690 if (message == WM_APP)
10691 {
10692 queue_status = GetQueueStatus(QS_HOTKEY);
10693 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %lx\n", queue_status);
10694 queue_status = GetQueueStatus(QS_POSTMESSAGE);
10695 ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %lx\n", queue_status);
10696 PostMessageA(hwnd, WM_APP+1, 0, 0);
10697 }
10698 else if (message == WM_APP+1)
10699 {
10700 queue_status = GetQueueStatus(QS_HOTKEY);
10701 ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %lx\n", queue_status);
10702 }
10703
10704 return ret;
10705 }
10706
10707 static BOOL RegisterWindowClasses(void)
10708 {
10709 WNDCLASSA cls;
10710 WNDCLASSW clsW;
10711
10712 cls.style = 0;
10713 cls.lpfnWndProc = MsgCheckProcA;
10714 cls.cbClsExtra = 0;
10715 cls.cbWndExtra = 0;
10716 cls.hInstance = GetModuleHandleA(0);
10717 cls.hIcon = 0;
10718 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
10719 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
10720 cls.lpszMenuName = NULL;
10721 cls.lpszClassName = "TestWindowClass";
10722 if(!RegisterClassA(&cls)) return FALSE;
10723
10724 cls.lpfnWndProc = HotkeyMsgCheckProcA;
10725 cls.lpszClassName = "HotkeyWindowClass";
10726 if(!RegisterClassA(&cls)) return FALSE;
10727
10728 cls.lpfnWndProc = ShowWindowProcA;
10729 cls.lpszClassName = "ShowWindowClass";
10730 if(!RegisterClassA(&cls)) return FALSE;
10731
10732 cls.lpfnWndProc = PopupMsgCheckProcA;
10733 cls.lpszClassName = "TestPopupClass";
10734 if(!RegisterClassA(&cls)) return FALSE;
10735
10736 cls.lpfnWndProc = ParentMsgCheckProcA;
10737 cls.lpszClassName = "TestParentClass";
10738 if(!RegisterClassA(&cls)) return FALSE;
10739
10740 cls.lpfnWndProc = StopQuitMsgCheckProcA;
10741 cls.lpszClassName = "StopQuitClass";
10742 if(!RegisterClassA(&cls)) return FALSE;
10743
10744 cls.lpfnWndProc = DefWindowProcA;
10745 cls.lpszClassName = "SimpleWindowClass";
10746 if(!RegisterClassA(&cls)) return FALSE;
10747
10748 cls.lpfnWndProc = PaintLoopProcA;
10749 cls.lpszClassName = "PaintLoopWindowClass";
10750 if(!RegisterClassA(&cls)) return FALSE;
10751
10752 cls.style = CS_NOCLOSE;
10753 cls.lpszClassName = "NoCloseWindowClass";
10754 if(!RegisterClassA(&cls)) return FALSE;
10755
10756 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
10757 cls.style = 0;
10758 cls.hInstance = GetModuleHandleA(0);
10759 cls.hbrBackground = 0;
10760 cls.lpfnWndProc = TestDlgProcA;
10761 cls.lpszClassName = "TestDialogClass";
10762 if(!RegisterClassA(&cls)) return FALSE;
10763
10764 cls.lpfnWndProc = DefWindowProcA;
10765 cls.style = CS_PARENTDC;
10766 cls.lpszClassName = "SimpleWindowClassWithParentDC";
10767 if(!RegisterClassA(&cls)) return FALSE;
10768
10769 clsW.style = 0;
10770 clsW.lpfnWndProc = MsgCheckProcW;
10771 clsW.cbClsExtra = 0;
10772 clsW.cbWndExtra = 0;
10773 clsW.hInstance = GetModuleHandleW(0);
10774 clsW.hIcon = 0;
10775 clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
10776 clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
10777 clsW.lpszMenuName = NULL;
10778 clsW.lpszClassName = testWindowClassW;
10779 RegisterClassW(&clsW); /* ignore error, this fails on Win9x */
10780
10781 return TRUE;
10782 }
10783
10784 static BOOL is_our_logged_class(HWND hwnd)
10785 {
10786 char buf[256];
10787
10788 if (GetClassNameA(hwnd, buf, sizeof(buf)))
10789 {
10790 if (!lstrcmpiA(buf, "TestWindowClass") ||
10791 !lstrcmpiA(buf, "ShowWindowClass") ||
10792 !lstrcmpiA(buf, "TestParentClass") ||
10793 !lstrcmpiA(buf, "TestPopupClass") ||
10794 !lstrcmpiA(buf, "SimpleWindowClass") ||
10795 !lstrcmpiA(buf, "TestDialogClass") ||
10796 !lstrcmpiA(buf, "MDI_frame_class") ||
10797 !lstrcmpiA(buf, "MDI_client_class") ||
10798 !lstrcmpiA(buf, "MDI_child_class") ||
10799 !lstrcmpiA(buf, "my_button_class") ||
10800 !lstrcmpiA(buf, "my_edit_class") ||
10801 !lstrcmpiA(buf, "static") ||
10802 !lstrcmpiA(buf, "ListBox") ||
10803 !lstrcmpiA(buf, "ComboBox") ||
10804 !lstrcmpiA(buf, "MyDialogClass") ||
10805 !lstrcmpiA(buf, "#32770") ||
10806 !lstrcmpiA(buf, "#32768"))
10807 return TRUE;
10808 }
10809 return FALSE;
10810 }
10811
10812 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
10813 {
10814 HWND hwnd;
10815
10816 ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
10817
10818 if (nCode == HCBT_CLICKSKIPPED)
10819 {
10820 /* ignore this event, XP sends it a lot when switching focus between windows */
10821 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
10822 }
10823
10824 if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
10825 {
10826 struct recvd_message msg;
10827
10828 msg.hwnd = 0;
10829 msg.message = nCode;
10830 msg.flags = hook|wparam|lparam;
10831 msg.wParam = wParam;
10832 msg.lParam = lParam;
10833 msg.descr = "CBT";
10834 add_message(&msg);
10835
10836 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
10837 }
10838
10839 if (nCode == HCBT_DESTROYWND)
10840 {
10841 if (test_DestroyWindow_flag)
10842 {
10843 DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
10844 if (style & WS_CHILD)
10845 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
10846 else if (style & WS_POPUP)
10847 lParam = WND_POPUP_ID;
10848 else
10849 lParam = WND_PARENT_ID;
10850 }
10851 }
10852
10853 /* Log also SetFocus(0) calls */
10854 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
10855
10856 if (is_our_logged_class(hwnd))
10857 {
10858 struct recvd_message msg;
10859
10860 msg.hwnd = hwnd;
10861 msg.message = nCode;
10862 msg.flags = hook|wparam|lparam;
10863 msg.wParam = wParam;
10864 msg.lParam = lParam;
10865 msg.descr = "CBT";
10866 add_message(&msg);
10867 }
10868 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
10869 }
10870
10871 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
10872 DWORD event,
10873 HWND hwnd,
10874 LONG object_id,
10875 LONG child_id,
10876 DWORD thread_id,
10877 DWORD event_time)
10878 {
10879 ok(thread_id == winevent_hook_thread_id, "we didn't ask for events from other threads\n");
10880
10881 /* ignore mouse cursor events */
10882 if (object_id == OBJID_CURSOR) return;
10883
10884 if (!hwnd || is_our_logged_class(hwnd))
10885 {
10886 struct recvd_message msg;
10887
10888 msg.hwnd = hwnd;
10889 msg.message = event;
10890 msg.flags = winevent_hook|wparam|lparam;
10891 msg.wParam = object_id;
10892 msg.lParam = child_id;
10893 msg.descr = "WEH";
10894 add_message(&msg);
10895 }
10896 }
10897
10898 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
10899 static const WCHAR wszAnsi[] = {'U',0};
10900
10901 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
10902 {
10903 switch (uMsg)
10904 {
10905 case CB_FINDSTRINGEXACT:
10906 if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
10907 return 1;
10908 if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
10909 return 0;
10910 return -1;
10911 }
10912 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
10913 }
10914
10915 static const struct message WmGetTextLengthAfromW[] = {
10916 { WM_GETTEXTLENGTH, sent },
10917 { WM_GETTEXT, sent|optional },
10918 { 0 }
10919 };
10920
10921 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
10922
10923 /* dummy window proc for WM_GETTEXTLENGTH test */
10924 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
10925 {
10926 switch(msg)
10927 {
10928 case WM_GETTEXTLENGTH:
10929 return lstrlenW(dummy_window_text) + 37; /* some random length */
10930 case WM_GETTEXT:
10931 lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
10932 return lstrlenW( (LPWSTR)lp );
10933 default:
10934 return DefWindowProcW( hwnd, msg, wp, lp );
10935 }
10936 }
10937
10938 static void test_message_conversion(void)
10939 {
10940 static const WCHAR wszMsgConversionClass[] =
10941 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
10942 WNDCLASSW cls;
10943 LRESULT lRes;
10944 HWND hwnd;
10945 WNDPROC wndproc, newproc;
10946 BOOL ret;
10947
10948 cls.style = 0;
10949 cls.lpfnWndProc = MsgConversionProcW;
10950 cls.cbClsExtra = 0;
10951 cls.cbWndExtra = 0;
10952 cls.hInstance = GetModuleHandleW(NULL);
10953 cls.hIcon = NULL;
10954 cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
10955 cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
10956 cls.lpszMenuName = NULL;
10957 cls.lpszClassName = wszMsgConversionClass;
10958 /* this call will fail on Win9x, but that doesn't matter as this test is
10959 * meaningless on those platforms */
10960 if(!RegisterClassW(&cls)) return;
10961
10962 hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
10963 100, 100, 200, 200, 0, 0, 0, NULL);
10964 ok(hwnd != NULL, "Window creation failed\n");
10965
10966 /* {W, A} -> A */
10967
10968 wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
10969 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10970 ok(lRes == 0, "String should have been converted\n");
10971 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10972 ok(lRes == 1, "String shouldn't have been converted\n");
10973
10974 /* {W, A} -> W */
10975
10976 wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
10977 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10978 ok(lRes == 1, "String shouldn't have been converted\n");
10979 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10980 ok(lRes == 1, "String shouldn't have been converted\n");
10981
10982 /* Synchronous messages */
10983
10984 lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10985 ok(lRes == 0, "String should have been converted\n");
10986 lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10987 ok(lRes == 1, "String shouldn't have been converted\n");
10988
10989 /* Asynchronous messages */
10990
10991 SetLastError(0);
10992 lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10993 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
10994 "PostMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
10995 SetLastError(0);
10996 lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
10997 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
10998 "PostMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
10999 SetLastError(0);
11000 lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
11001 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
11002 "PosThreadtMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
11003 SetLastError(0);
11004 lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
11005 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
11006 "PosThreadtMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
11007 SetLastError(0);
11008 lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
11009 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
11010 "SendNotifyMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
11011 SetLastError(0);
11012 lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
11013 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
11014 "SendNotifyMessage on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
11015 SetLastError(0);
11016 lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
11017 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
11018 "SendMessageCallback on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
11019 SetLastError(0);
11020 lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
11021 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
11022 "SendMessageCallback on sync only message returned %Id, last error %ld\n", lRes, GetLastError());
11023
11024 /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
11025
11026 hwnd = CreateWindowW (testWindowClassW, wszUnicode,
11027 WS_OVERLAPPEDWINDOW,
11028 100, 100, 200, 200, 0, 0, 0, NULL);
11029 assert(hwnd);
11030 flush_sequence();
11031 lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
11032 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
11033 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
11034 "got bad length %Id\n", lRes );
11035
11036 flush_sequence();
11037 lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
11038 hwnd, WM_GETTEXTLENGTH, 0, 0);
11039 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
11040 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
11041 "got bad length %Id\n", lRes );
11042
11043 wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
11044 newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
11045 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
11046 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
11047 NULL, 0, NULL, NULL ) ||
11048 broken(lRes == lstrlenW(dummy_window_text) + 37),
11049 "got bad length %Id\n", lRes );
11050
11051 SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc ); /* restore old wnd proc */
11052 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
11053 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
11054 NULL, 0, NULL, NULL ) ||
11055 broken(lRes == lstrlenW(dummy_window_text) + 37),
11056 "got bad length %Id\n", lRes );
11057
11058 ret = DestroyWindow(hwnd);
11059 ok( ret, "DestroyWindow() error %ld\n", GetLastError());
11060 }
11061
11062 struct timer_info
11063 {
11064 HWND hWnd;
11065 HANDLE handles[2];
11066 DWORD id;
11067 };
11068
11069 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
11070 {
11071 }
11072
11073 #define TIMER_ID 0x19
11074 #define TIMER_COUNT_EXPECTED 100
11075 #define TIMER_COUNT_TOLERANCE 10
11076
11077 static int count = 0;
11078 static void CALLBACK callback_count(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
11079 {
11080 count++;
11081 }
11082
11083 static DWORD exception;
11084 static void CALLBACK callback_exception(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
11085 {
11086 count++;
11087 RaiseException(exception, 0, 0, NULL);
11088 }
11089
11090 static DWORD WINAPI timer_thread_proc(LPVOID x)
11091 {
11092 struct timer_info *info = x;
11093 DWORD r;
11094
11095 r = KillTimer(info->hWnd, 0x19);
11096 ok(r,"KillTimer failed in thread\n");
11097 r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
11098 ok(r,"SetTimer failed in thread\n");
11099 ok(r==TIMER_ID,"SetTimer id different\n");
11100 r = SetEvent(info->handles[0]);
11101 ok(r,"SetEvent failed in thread\n");
11102 return 0;
11103 }
11104
11105 static void test_timers(void)
11106 {
11107 struct timer_info info;
11108 DWORD start;
11109 DWORD id;
11110 MSG msg;
11111
11112 info.hWnd = CreateWindowA("TestWindowClass", NULL,
11113 WS_OVERLAPPEDWINDOW ,
11114 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
11115 NULL, NULL, 0);
11116
11117 info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
11118 ok(info.id, "SetTimer failed\n");
11119 ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
11120 info.handles[0] = CreateEventW(NULL,0,0,NULL);
11121 info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
11122
11123 WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
11124
11125 WaitForSingleObject(info.handles[1], INFINITE);
11126
11127 CloseHandle(info.handles[0]);
11128 CloseHandle(info.handles[1]);
11129
11130 ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
11131
11132 /* Check the minimum allowed timeout for a timer. MSDN indicates that it should be 10.0 ms,
11133 * which occurs sometimes, but most testing on the VMs indicates a minimum timeout closer to
11134 * 15.6 ms. Since there is some measurement error between test runs we are allowing for
11135 * ±9 counts (~4 ms) around the expected value.
11136 */
11137 count = 0;
11138 id = SetTimer(info.hWnd, TIMER_ID, 0, callback_count);
11139 ok(id != 0, "did not get id from SetTimer.\n");
11140 ok(id==TIMER_ID, "SetTimer timer ID different\n");
11141 start = GetTickCount();
11142 while (GetTickCount()-start < 1001 && GetMessageA(&msg, info.hWnd, 0, 0))
11143 DispatchMessageA(&msg);
11144 ok(abs(count-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE /* xp */
11145 || broken(abs(count-64) <= TIMER_COUNT_TOLERANCE) /* most common */
11146 || broken(abs(count-43) <= TIMER_COUNT_TOLERANCE) /* w2k3, win8 */,
11147 "did not get expected count for minimum timeout (%d != ~%d).\n",
11148 count, TIMER_COUNT_EXPECTED);
11149 ok(KillTimer(info.hWnd, id), "KillTimer failed\n");
11150 /* Perform the same check on SetSystemTimer (only available on w2k3 and older) */
11151 if (pSetSystemTimer)
11152 {
11153 int syscount = 0;
11154
11155 count = 0;
11156 id = pSetSystemTimer(info.hWnd, TIMER_ID, 0, callback_count);
11157 ok(id != 0, "did not get id from SetSystemTimer.\n");
11158 ok(id==TIMER_ID, "SetTimer timer ID different\n");
11159 start = GetTickCount();
11160 while (GetTickCount()-start < 1001 && GetMessageA(&msg, info.hWnd, 0, 0))
11161 {
11162 if (msg.message == WM_SYSTIMER)
11163 syscount++;
11164 DispatchMessageA(&msg);
11165 }
11166 ok(abs(syscount-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE
11167 || broken(abs(syscount-64) < TIMER_COUNT_TOLERANCE) /* most common */
11168 || broken(syscount > 4000 && syscount < 12000) /* win2k3sp0 */,
11169 "did not get expected count for minimum timeout (%d != ~%d).\n",
11170 syscount, TIMER_COUNT_EXPECTED);
11171 ok(count == 0, "did not get expected count for callback timeout (%d != 0).\n", count);
11172 ok(pKillSystemTimer(info.hWnd, id), "KillSystemTimer failed\n");
11173 }
11174
11175 ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
11176 }
11177
11178 static void test_timers_no_wnd(void)
11179 {
11180 static UINT_PTR ids[0xffff];
11181 UINT_PTR id, id2;
11182 DWORD start;
11183 MSG msg;
11184 int i;
11185
11186 count = 0;
11187 id = SetTimer(NULL, 0, 100, callback_count);
11188 ok(id != 0, "did not get id from SetTimer.\n");
11189 id2 = SetTimer(NULL, id, 200, callback_count);
11190 ok(id2 == id, "did not get same id from SetTimer when replacing (%Ii expected %Ii).\n", id2, id);
11191 Sleep(150);
11192 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
11193 ok(count == 0, "did not get zero count as expected (%i).\n", count);
11194 Sleep(150);
11195 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
11196 ok(count == 1, "did not get one count as expected (%i).\n", count);
11197 KillTimer(NULL, id);
11198 Sleep(250);
11199 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
11200 ok(count == 1, "killing replaced timer did not work (%i).\n", count);
11201
11202 /* Check the minimum allowed timeout for a timer. MSDN indicates that it should be 10.0 ms,
11203 * which occurs sometimes, but most testing on the VMs indicates a minimum timeout closer to
11204 * 15.6 ms. Since there is some measurement error between test runs we are allowing for
11205 * ±9 counts (~4 ms) around the expected value.
11206 */
11207 count = 0;
11208 id = SetTimer(NULL, 0, 0, callback_count);
11209 ok(id != 0, "did not get id from SetTimer.\n");
11210 start = GetTickCount();
11211 while (GetTickCount()-start < 1001 && GetMessageA(&msg, NULL, 0, 0))
11212 DispatchMessageA(&msg);
11213 ok(abs(count-TIMER_COUNT_EXPECTED) < TIMER_COUNT_TOLERANCE /* xp */
11214 || broken(abs(count-64) <= TIMER_COUNT_TOLERANCE) /* most common */
11215 || broken(abs(count-43) <= TIMER_COUNT_TOLERANCE) /* w1064v1809 */,
11216 "did not get expected count for minimum timeout (%d != ~%d).\n",
11217 count, TIMER_COUNT_EXPECTED);
11218 KillTimer(NULL, id);
11219 /* Note: SetSystemTimer doesn't support a NULL window, see test_timers */
11220
11221 if (pSetCoalescableTimer)
11222 {
11223 count = 0;
11224 id = pSetCoalescableTimer(NULL, 0, 0, callback_count, 0);
11225 ok(id != 0, "SetCoalescableTimer failed with %lu.\n", GetLastError());
11226 start = GetTickCount();
11227 while (GetTickCount()-start < 100 && GetMessageA(&msg, NULL, 0, 0))
11228 DispatchMessageA(&msg);
11229 ok(count > 1, "expected count > 1, got %d.\n", count);
11230 KillTimer(NULL, id);
11231 }
11232 else
11233 win_skip("SetCoalescableTimer not available.\n");
11234
11235 /* Check what happens when we're running out of timers */
11236 for (i = 0; i < ARRAY_SIZE(ids); i++)
11237 {
11238 SetLastError(0xdeadbeef);
11239 ids[i] = SetTimer(NULL, 0, USER_TIMER_MAXIMUM, tfunc);
11240 if (!ids[i]) break;
11241 }
11242 ok(i != ARRAY_SIZE(ids), "all timers were created successfully\n");
11243 ok(GetLastError()==ERROR_NO_MORE_USER_HANDLES || broken(GetLastError()==0xdeadbeef),
11244 "GetLastError() = %ld\n", GetLastError());
11245 while (i > 0) KillTimer(NULL, ids[--i]);
11246 }
11247
11248 static void test_timers_exception(DWORD code)
11249 {
11250 UINT_PTR id;
11251 MSG msg;
11252
11253 exception = code;
11254 id = SetTimer(NULL, 0, 1000, callback_exception);
11255 ok(id != 0, "did not get id from SetTimer.\n");
11256
11257 memset(&msg, 0, sizeof(msg));
11258 msg.message = WM_TIMER;
11259 msg.wParam = id;
11260 msg.lParam = (LPARAM)callback_exception;
11261
11262 count = 0;
11263 DispatchMessageA(&msg);
11264 ok(count == 1, "did not get one count as expected (%i).\n", count);
11265
11266 KillTimer(NULL, id);
11267 }
11268
11269 static void test_timers_exceptions(void)
11270 {
11271 test_timers_exception(EXCEPTION_ACCESS_VIOLATION);
11272 test_timers_exception(EXCEPTION_DATATYPE_MISALIGNMENT);
11273 test_timers_exception(EXCEPTION_BREAKPOINT);
11274 test_timers_exception(EXCEPTION_SINGLE_STEP);
11275 test_timers_exception(EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
11276 test_timers_exception(EXCEPTION_FLT_DENORMAL_OPERAND);
11277 test_timers_exception(EXCEPTION_FLT_DIVIDE_BY_ZERO);
11278 test_timers_exception(EXCEPTION_FLT_INEXACT_RESULT);
11279 test_timers_exception(EXCEPTION_ILLEGAL_INSTRUCTION);
11280 test_timers_exception(0xE000BEEF); /* customer exception */
11281 }
11282
11283 /* Various win events with arbitrary parameters */
11284 static const struct message WmWinEventsSeq[] = {
11285 { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
11286 { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
11287 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
11288 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
11289 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
11290 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
11291 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
11292 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
11293 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
11294 /* our win event hook ignores OBJID_CURSOR events */
11295 /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
11296 { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
11297 { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
11298 { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
11299 { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
11300 { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
11301 { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
11302 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
11303 { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
11304 { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
11305 { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
11306 { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
11307 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
11308 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
11309 { 0 }
11310 };
11311 static const struct message WmWinEventCaretSeq[] = {
11312 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
11313 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
11314 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
11315 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
11316 { 0 }
11317 };
11318 static const struct message WmWinEventCaretSeq_2[] = {
11319 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
11320 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
11321 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
11322 { 0 }
11323 };
11324 static const struct message WmWinEventAlertSeq[] = {
11325 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
11326 { 0 }
11327 };
11328 static const struct message WmWinEventAlertSeq_2[] = {
11329 /* create window in the thread proc */
11330 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
11331 /* our test event */
11332 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
11333 { 0 }
11334 };
11335 static const struct message WmGlobalHookSeq_1[] = {
11336 /* create window in the thread proc */
11337 { HCBT_CREATEWND, hook|lparam, 0, 2 },
11338 /* our test events */
11339 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
11340 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
11341 { 0 }
11342 };
11343 static const struct message WmGlobalHookSeq_2[] = {
11344 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
11345 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
11346 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
11347 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
11348 { 0 }
11349 };
11350
11351 static const struct message WmMouseLLHookSeq[] = {
11352 { WM_MOUSEMOVE, hook },
11353 { WM_LBUTTONUP, hook },
11354 { WM_MOUSEMOVE, hook },
11355 { 0 }
11356 };
11357
11358 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
11359 DWORD event,
11360 HWND hwnd,
11361 LONG object_id,
11362 LONG child_id,
11363 DWORD thread_id,
11364 DWORD event_time)
11365 {
11366 char buf[256];
11367
11368 if (GetClassNameA(hwnd, buf, sizeof(buf)))
11369 {
11370 if (!lstrcmpiA(buf, "TestWindowClass") ||
11371 !lstrcmpiA(buf, "static"))
11372 {
11373 struct recvd_message msg;
11374
11375 msg.hwnd = hwnd;
11376 msg.message = event;
11377 msg.flags = winevent_hook|wparam|lparam;
11378 msg.wParam = object_id;
11379 msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
11380 msg.descr = "WEH_2";
11381 add_message(&msg);
11382 }
11383 }
11384 }
11385
11386 static HHOOK hCBT_global_hook;
11387 static DWORD cbt_global_hook_thread_id;
11388
11389 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
11390 {
11391 HWND hwnd;
11392 char buf[256];
11393
11394 if (nCode == HCBT_SYSCOMMAND)
11395 {
11396 struct recvd_message msg;
11397
11398 msg.hwnd = 0;
11399 msg.message = nCode;
11400 msg.flags = hook|wparam|lparam;
11401 msg.wParam = wParam;
11402 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
11403 msg.descr = "CBT_2";
11404 add_message(&msg);
11405
11406 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
11407 }
11408 /* WH_MOUSE_LL hook */
11409 if (nCode == HC_ACTION)
11410 {
11411 MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
11412
11413 /* we can't test for real mouse events */
11414 if (mhll->flags & LLMHF_INJECTED)
11415 {
11416 struct recvd_message msg;
11417
11418 memset (&msg, 0, sizeof (msg));
11419 msg.message = wParam;
11420 msg.flags = hook;
11421 msg.descr = "CBT_2";
11422 add_message(&msg);
11423 }
11424 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
11425 }
11426
11427 /* Log also SetFocus(0) calls */
11428 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
11429
11430 if (GetClassNameA(hwnd, buf, sizeof(buf)))
11431 {
11432 if (!lstrcmpiA(buf, "TestWindowClass") ||
11433 !lstrcmpiA(buf, "static"))
11434 {
11435 struct recvd_message msg;
11436
11437 msg.hwnd = hwnd;
11438 msg.message = nCode;
11439 msg.flags = hook|wparam|lparam;
11440 msg.wParam = wParam;
11441 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
11442 msg.descr = "CBT_2";
11443 add_message(&msg);
11444 }
11445 }
11446 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
11447 }
11448
11449 static DWORD WINAPI win_event_global_thread_proc(void *param)
11450 {
11451 HWND hwnd;
11452 MSG msg;
11453 HANDLE hevent = *(HANDLE *)param;
11454
11455 assert(pNotifyWinEvent);
11456
11457 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
11458 assert(hwnd);
11459 if (winetest_debug > 1) trace("created thread window %p\n", hwnd);
11460
11461 *(HWND *)param = hwnd;
11462
11463 flush_sequence();
11464 /* this event should be received only by our new hook proc,
11465 * an old one does not expect an event from another thread.
11466 */
11467 pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
11468 SetEvent(hevent);
11469
11470 while (GetMessageA(&msg, 0, 0, 0))
11471 {
11472 TranslateMessage(&msg);
11473 DispatchMessageA(&msg);
11474 }
11475 return 0;
11476 }
11477
11478 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
11479 {
11480 HWND hwnd;
11481 MSG msg;
11482 HANDLE hevent = *(HANDLE *)param;
11483
11484 flush_sequence();
11485 /* these events should be received only by our new hook proc,
11486 * an old one does not expect an event from another thread.
11487 */
11488
11489 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
11490 assert(hwnd);
11491 if (winetest_debug > 1) trace("created thread window %p\n", hwnd);
11492
11493 *(HWND *)param = hwnd;
11494
11495 /* Windows doesn't like when a thread plays games with the focus,
11496 that leads to all kinds of misbehaviours and failures to activate
11497 a window. So, better keep next lines commented out.
11498 SetFocus(0);
11499 SetFocus(hwnd);*/
11500
11501 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
11502 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
11503
11504 SetEvent(hevent);
11505
11506 while (GetMessageA(&msg, 0, 0, 0))
11507 {
11508 TranslateMessage(&msg);
11509 DispatchMessageA(&msg);
11510 }
11511 return 0;
11512 }
11513
11514 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
11515 {
11516 HWND hwnd;
11517 MSG msg;
11518 HANDLE hevent = *(HANDLE *)param;
11519
11520 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
11521 assert(hwnd);
11522 if (winetest_debug > 1) trace("created thread window %p\n", hwnd);
11523
11524 *(HWND *)param = hwnd;
11525
11526 flush_sequence();
11527
11528 /* Windows doesn't like when a thread plays games with the focus,
11529 * that leads to all kinds of misbehaviours and failures to activate
11530 * a window. So, better don't generate a mouse click message below.
11531 */
11532 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
11533 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
11534 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
11535
11536 SetEvent(hevent);
11537 while (GetMessageA(&msg, 0, 0, 0))
11538 {
11539 TranslateMessage(&msg);
11540 DispatchMessageA(&msg);
11541 }
11542 return 0;
11543 }
11544
11545 static void test_winevents(void)
11546 {
11547 BOOL ret;
11548 MSG msg;
11549 HWND hwnd, hwnd2;
11550 UINT i;
11551 HANDLE hthread, hevent;
11552 DWORD tid;
11553 HWINEVENTHOOK hhook;
11554 const struct message *events = WmWinEventsSeq;
11555
11556 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
11557 WS_OVERLAPPEDWINDOW,
11558 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
11559 NULL, NULL, 0);
11560 assert(hwnd);
11561
11562 /****** start of global hook test *************/
11563 hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
11564 if (!hCBT_global_hook)
11565 {
11566 ok(DestroyWindow(hwnd), "failed to destroy window\n");
11567 skip( "cannot set global hook\n" );
11568 return;
11569 }
11570
11571 hevent = CreateEventA(NULL, 0, 0, NULL);
11572 assert(hevent);
11573 hwnd2 = hevent;
11574
11575 hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
11576 ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
11577
11578 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11579
11580 ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
11581
11582 flush_sequence();
11583 /* this one should be received only by old hook proc */
11584 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
11585 /* this one should be received only by old hook proc */
11586 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
11587
11588 ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
11589
11590 ret = UnhookWindowsHookEx(hCBT_global_hook);
11591 ok( ret, "UnhookWindowsHookEx error %ld\n", GetLastError());
11592
11593 PostThreadMessageA(tid, WM_QUIT, 0, 0);
11594 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11595 CloseHandle(hthread);
11596 CloseHandle(hevent);
11597 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
11598 /****** end of global hook test *************/
11599
11600 if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
11601 {
11602 ok(DestroyWindow(hwnd), "failed to destroy window\n");
11603 return;
11604 }
11605
11606 flush_sequence();
11607
11608 if (0)
11609 {
11610 /* this test doesn't pass under Win9x */
11611 /* win2k ignores events with hwnd == 0 */
11612 SetLastError(0xdeadbeef);
11613 pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
11614 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
11615 GetLastError() == 0xdeadbeef, /* Win9x */
11616 "unexpected error %ld\n", GetLastError());
11617 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
11618 }
11619
11620 for (i = 0; i < ARRAY_SIZE(WmWinEventsSeq); i++)
11621 pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
11622
11623 ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
11624
11625 /****** start of event filtering test *************/
11626 hhook = pSetWinEventHook(
11627 EVENT_OBJECT_SHOW, /* 0x8002 */
11628 EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
11629 GetModuleHandleA(0), win_event_global_hook_proc,
11630 GetCurrentProcessId(), 0,
11631 WINEVENT_INCONTEXT);
11632 ok(hhook != 0, "SetWinEventHook error %ld\n", GetLastError());
11633
11634 hevent = CreateEventA(NULL, 0, 0, NULL);
11635 assert(hevent);
11636 hwnd2 = hevent;
11637
11638 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
11639 ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
11640
11641 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11642
11643 ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
11644
11645 flush_sequence();
11646 /* this one should be received only by old hook proc */
11647 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
11648 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
11649 /* this one should be received only by old hook proc */
11650 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
11651
11652 ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
11653
11654 ret = pUnhookWinEvent(hhook);
11655 ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
11656
11657 PostThreadMessageA(tid, WM_QUIT, 0, 0);
11658 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11659 CloseHandle(hthread);
11660 CloseHandle(hevent);
11661 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
11662 /****** end of event filtering test *************/
11663
11664 /****** start of out of context event test *************/
11665 hhook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0,
11666 win_event_global_hook_proc, GetCurrentProcessId(), 0,
11667 WINEVENT_OUTOFCONTEXT);
11668 ok(hhook != 0, "SetWinEventHook error %ld\n", GetLastError());
11669
11670 hevent = CreateEventA(NULL, 0, 0, NULL);
11671 assert(hevent);
11672 hwnd2 = hevent;
11673
11674 flush_sequence();
11675
11676 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
11677 ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
11678
11679 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11680
11681 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
11682 /* process pending winevent messages */
11683 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
11684 ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
11685
11686 flush_sequence();
11687 /* this one should be received only by old hook proc */
11688 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
11689 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
11690 /* this one should be received only by old hook proc */
11691 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
11692
11693 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
11694 /* process pending winevent messages */
11695 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
11696 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
11697
11698 ret = pUnhookWinEvent(hhook);
11699 ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
11700
11701 PostThreadMessageA(tid, WM_QUIT, 0, 0);
11702 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11703 CloseHandle(hthread);
11704 CloseHandle(hevent);
11705 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
11706 /****** end of out of context event test *************/
11707
11708 /****** start of MOUSE_LL hook test *************/
11709 hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
11710 /* WH_MOUSE_LL is not supported on Win9x platforms */
11711 if (!hCBT_global_hook)
11712 {
11713 win_skip("Skipping WH_MOUSE_LL test on this platform\n");
11714 goto skip_mouse_ll_hook_test;
11715 }
11716
11717 hevent = CreateEventA(NULL, 0, 0, NULL);
11718 assert(hevent);
11719 hwnd2 = hevent;
11720
11721 hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
11722 ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
11723
11724 while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
11725 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
11726
11727 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
11728 flush_sequence();
11729
11730 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
11731 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
11732 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
11733
11734 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
11735
11736 ret = UnhookWindowsHookEx(hCBT_global_hook);
11737 ok( ret, "UnhookWindowsHookEx error %ld\n", GetLastError());
11738
11739 PostThreadMessageA(tid, WM_QUIT, 0, 0);
11740 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
11741 CloseHandle(hthread);
11742 CloseHandle(hevent);
11743 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
11744 /****** end of MOUSE_LL hook test *************/
11745 skip_mouse_ll_hook_test:
11746
11747 ok(DestroyWindow(hwnd), "failed to destroy window\n");
11748 }
11749
11750 static void test_set_hook(void)
11751 {
11752 BOOL ret;
11753 HHOOK hhook;
11754 HWINEVENTHOOK hwinevent_hook;
11755
11756 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
11757 ok(hhook != 0, "local hook does not require hModule set to 0\n");
11758 UnhookWindowsHookEx(hhook);
11759
11760 if (0)
11761 {
11762 /* this test doesn't pass under Win9x: BUG! */
11763 SetLastError(0xdeadbeef);
11764 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
11765 ok(!hhook, "global hook requires hModule != 0\n");
11766 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %ld\n", GetLastError());
11767 }
11768
11769 SetLastError(0xdeadbeef);
11770 hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
11771 ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
11772 ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
11773 GetLastError() == 0xdeadbeef, /* Win9x */
11774 "unexpected error %ld\n", GetLastError());
11775
11776 SetLastError(0xdeadbeef);
11777 ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
11778 ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
11779 GetLastError() == 0xdeadbeef, /* Win9x */
11780 "unexpected error %ld\n", GetLastError());
11781
11782 if (!pSetWinEventHook || !pUnhookWinEvent) return;
11783
11784 /* even process local incontext hooks require hmodule */
11785 SetLastError(0xdeadbeef);
11786 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
11787 GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
11788 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
11789 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
11790 GetLastError() == 0xdeadbeef, /* Win9x */
11791 "unexpected error %ld\n", GetLastError());
11792
11793 /* even thread local incontext hooks require hmodule */
11794 SetLastError(0xdeadbeef);
11795 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
11796 GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
11797 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
11798 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
11799 GetLastError() == 0xdeadbeef, /* Win9x */
11800 "unexpected error %ld\n", GetLastError());
11801
11802 if (0)
11803 {
11804 /* these 3 tests don't pass under Win9x */
11805 SetLastError(0xdeadbeef);
11806 hwinevent_hook = pSetWinEventHook(1, 0, 0, win_event_proc,
11807 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
11808 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
11809 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %ld\n", GetLastError());
11810
11811 SetLastError(0xdeadbeef);
11812 hwinevent_hook = pSetWinEventHook(-1, 1, 0, win_event_proc,
11813 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
11814 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
11815 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %ld\n", GetLastError());
11816
11817 SetLastError(0xdeadbeef);
11818 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
11819 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
11820 ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
11821 ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %ld\n", GetLastError());
11822 }
11823
11824 SetLastError(0xdeadbeef);
11825 hwinevent_hook = pSetWinEventHook(0, 0, 0, win_event_proc,
11826 GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
11827 ok(hwinevent_hook != 0, "SetWinEventHook error %ld\n", GetLastError());
11828 ok(GetLastError() == 0xdeadbeef, "unexpected error %ld\n", GetLastError());
11829 ret = pUnhookWinEvent(hwinevent_hook);
11830 ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
11831
11832 todo_wine {
11833 /* This call succeeds under win2k SP4, but fails under Wine.
11834 Does win2k test/use passed process id? */
11835 SetLastError(0xdeadbeef);
11836 hwinevent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX, 0, win_event_proc,
11837 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
11838 ok(hwinevent_hook != 0, "SetWinEventHook error %ld\n", GetLastError());
11839 ok(GetLastError() == 0xdeadbeef, "unexpected error %ld\n", GetLastError());
11840 ret = pUnhookWinEvent(hwinevent_hook);
11841 ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
11842 }
11843
11844 SetLastError(0xdeadbeef);
11845 ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
11846 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
11847 GetLastError() == 0xdeadbeef, /* Win9x */
11848 "unexpected error %ld\n", GetLastError());
11849 }
11850
11851 static HWND hook_hwnd;
11852 static HHOOK recursive_hook;
11853 static int hook_depth, max_hook_depth;
11854
11855 static LRESULT WINAPI rec_get_message_hook(int code, WPARAM w, LPARAM l)
11856 {
11857 LRESULT res;
11858 MSG msg;
11859 BOOL b;
11860
11861 hook_depth++;
11862 if(hook_depth > max_hook_depth)
11863 max_hook_depth = hook_depth;
11864
11865 b = PeekMessageW(&msg, hook_hwnd, 0, 0, PM_NOREMOVE);
11866 ok(b, "PeekMessage failed\n");
11867
11868 res = CallNextHookEx(recursive_hook, code, w, l);
11869
11870 hook_depth--;
11871 return res;
11872 }
11873
11874 static void test_recursive_hook(void)
11875 {
11876 MSG msg;
11877 BOOL b;
11878
11879 hook_hwnd = CreateWindowA("Static", NULL, WS_POPUP, 0, 0, 200, 60, NULL, NULL, NULL, NULL);
11880 ok(hook_hwnd != NULL, "CreateWindow failed\n");
11881
11882 recursive_hook = SetWindowsHookExW(WH_GETMESSAGE, rec_get_message_hook, NULL, GetCurrentThreadId());
11883 ok(recursive_hook != NULL, "SetWindowsHookEx failed\n");
11884
11885 PostMessageW(hook_hwnd, WM_USER, 0, 0);
11886 PostMessageW(hook_hwnd, WM_USER+1, 0, 0);
11887
11888 hook_depth = 0;
11889 GetMessageW(&msg, hook_hwnd, 0, 0);
11890 ok(15 <= max_hook_depth && max_hook_depth < 45, "max_hook_depth = %d\n", max_hook_depth);
11891 if (winetest_debug > 1) trace("max_hook_depth = %d\n", max_hook_depth);
11892
11893 b = UnhookWindowsHookEx(recursive_hook);
11894 ok(b, "UnhokWindowsHookEx failed\n");
11895
11896 DestroyWindow(hook_hwnd);
11897 }
11898
11899 static const struct message ScrollWindowPaint1[] = {
11900 { WM_PAINT, sent },
11901 { WM_ERASEBKGND, sent|beginpaint },
11902 { WM_GETTEXTLENGTH, sent|optional },
11903 { WM_PAINT, sent|optional },
11904 { WM_NCPAINT, sent|beginpaint|optional },
11905 { WM_GETTEXT, sent|beginpaint|optional },
11906 { WM_GETTEXT, sent|beginpaint|optional },
11907 { WM_GETTEXT, sent|beginpaint|optional },
11908 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
11909 { WM_ERASEBKGND, sent|beginpaint|optional },
11910 { 0 }
11911 };
11912
11913 static const struct message ScrollWindowPaint2[] = {
11914 { WM_PAINT, sent },
11915 { 0 }
11916 };
11917
11918 static void test_scrollwindowex(void)
11919 {
11920 HWND hwnd, hchild;
11921 RECT rect={0,0,130,130};
11922
11923 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
11924 WS_VISIBLE|WS_OVERLAPPEDWINDOW,
11925 100, 100, 200, 200, 0, 0, 0, NULL);
11926 ok (hwnd != 0, "Failed to create overlapped window\n");
11927 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
11928 WS_VISIBLE|WS_CAPTION|WS_CHILD,
11929 10, 10, 150, 150, hwnd, 0, 0, NULL);
11930 ok (hchild != 0, "Failed to create child\n");
11931 UpdateWindow(hwnd);
11932 flush_events();
11933 flush_sequence();
11934
11935 /* scroll without the child window */
11936 if (winetest_debug > 1) trace("start scroll\n");
11937 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
11938 SW_ERASE|SW_INVALIDATE);
11939 ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
11940 if (winetest_debug > 1) trace("end scroll\n");
11941 flush_sequence();
11942 flush_events();
11943 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
11944 flush_events();
11945 flush_sequence();
11946
11947 /* Now without the SW_ERASE flag */
11948 if (winetest_debug > 1) trace("start scroll\n");
11949 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
11950 ok_sequence(WmEmptySeq, "ScrollWindowEx", FALSE);
11951 if (winetest_debug > 1) trace("end scroll\n");
11952 flush_sequence();
11953 flush_events();
11954 ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", FALSE);
11955 flush_events();
11956 flush_sequence();
11957
11958 /* now scroll the child window as well */
11959 if (winetest_debug > 1) trace("start scroll\n");
11960 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
11961 SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
11962 /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
11963 /* windows sometimes a WM_MOVE */
11964 ok_sequence(WmEmptySeq, "ScrollWindowEx", TRUE);
11965 if (winetest_debug > 1) trace("end scroll\n");
11966 flush_sequence();
11967 flush_events();
11968 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", FALSE);
11969 flush_events();
11970 flush_sequence();
11971
11972 /* now scroll with ScrollWindow() */
11973 if (winetest_debug > 1) trace("start scroll with ScrollWindow\n");
11974 ScrollWindow( hwnd, 5, 5, NULL, NULL);
11975 if (winetest_debug > 1) trace("end scroll\n");
11976 flush_sequence();
11977 flush_events();
11978 ok_sequence(ScrollWindowPaint1, "ScrollWindow", FALSE);
11979
11980 ok(DestroyWindow(hchild), "failed to destroy window\n");
11981 ok(DestroyWindow(hwnd), "failed to destroy window\n");
11982 flush_sequence();
11983 }
11984
11985 static const struct message destroy_window_with_children[] = {
11986 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* popup */
11987 { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
11988 { 0x0090, sent|optional },
11989 { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
11990 { 0x0090, sent|optional },
11991 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* popup */
11992 { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
11993 { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
11994 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
11995 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 }, /* parent */
11996 { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
11997 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
11998 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
11999 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
12000 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
12001 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
12002 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
12003 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
12004 { 0 }
12005 };
12006
12007 static void test_DestroyWindow(void)
12008 {
12009 BOOL ret;
12010 HWND parent, child1, child2, child3, child4, test;
12011 UINT_PTR child_id = WND_CHILD_ID + 1;
12012
12013 parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
12014 100, 100, 200, 200, 0, 0, 0, NULL);
12015 assert(parent != 0);
12016 child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
12017 0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
12018 assert(child1 != 0);
12019 child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
12020 0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
12021 assert(child2 != 0);
12022 child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
12023 0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
12024 assert(child3 != 0);
12025 child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
12026 0, 0, 50, 50, parent, 0, 0, NULL);
12027 assert(child4 != 0);
12028
12029 /* test owner/parent of child2 */
12030 test = GetParent(child2);
12031 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
12032 ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
12033 test = GetAncestor(child2, GA_PARENT);
12034 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
12035 test = GetWindow(child2, GW_OWNER);
12036 ok(!test, "wrong owner %p\n", test);
12037
12038 test = SetParent(child2, parent);
12039 ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
12040
12041 /* test owner/parent of the parent */
12042 test = GetParent(parent);
12043 ok(!test, "wrong parent %p\n", test);
12044 ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
12045 test = GetAncestor(parent, GA_PARENT);
12046 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
12047 test = GetWindow(parent, GW_OWNER);
12048 ok(!test, "wrong owner %p\n", test);
12049
12050 /* test owner/parent of child1 */
12051 test = GetParent(child1);
12052 ok(test == parent, "wrong parent %p\n", test);
12053 ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
12054 test = GetAncestor(child1, GA_PARENT);
12055 ok(test == parent, "wrong parent %p\n", test);
12056 test = GetWindow(child1, GW_OWNER);
12057 ok(!test, "wrong owner %p\n", test);
12058
12059 /* test owner/parent of child2 */
12060 test = GetParent(child2);
12061 ok(test == parent, "wrong parent %p\n", test);
12062 ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
12063 test = GetAncestor(child2, GA_PARENT);
12064 ok(test == parent, "wrong parent %p\n", test);
12065 test = GetWindow(child2, GW_OWNER);
12066 ok(!test, "wrong owner %p\n", test);
12067
12068 /* test owner/parent of child3 */
12069 test = GetParent(child3);
12070 ok(test == child1, "wrong parent %p\n", test);
12071 ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
12072 test = GetAncestor(child3, GA_PARENT);
12073 ok(test == child1, "wrong parent %p\n", test);
12074 test = GetWindow(child3, GW_OWNER);
12075 ok(!test, "wrong owner %p\n", test);
12076
12077 /* test owner/parent of child4 */
12078 test = GetParent(child4);
12079 ok(test == parent, "wrong parent %p\n", test);
12080 ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
12081 test = GetAncestor(child4, GA_PARENT);
12082 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
12083 test = GetWindow(child4, GW_OWNER);
12084 ok(test == parent, "wrong owner %p\n", test);
12085
12086 flush_sequence();
12087
12088 if (winetest_debug > 1) trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
12089 parent, child1, child2, child3, child4);
12090
12091 SetCapture(child4);
12092 test = GetCapture();
12093 ok(test == child4, "wrong capture window %p\n", test);
12094
12095 test_DestroyWindow_flag = TRUE;
12096 ret = DestroyWindow(parent);
12097 ok( ret, "DestroyWindow() error %ld\n", GetLastError());
12098 test_DestroyWindow_flag = FALSE;
12099 ok_sequence(destroy_window_with_children, "destroy window with children", FALSE);
12100
12101 ok(!IsWindow(parent), "parent still exists\n");
12102 ok(!IsWindow(child1), "child1 still exists\n");
12103 ok(!IsWindow(child2), "child2 still exists\n");
12104 ok(!IsWindow(child3), "child3 still exists\n");
12105 ok(!IsWindow(child4), "child4 still exists\n");
12106
12107 test = GetCapture();
12108 ok(!test, "wrong capture window %p\n", test);
12109 }
12110
12111
12112 static const struct message WmDispatchPaint[] = {
12113 { WM_NCPAINT, sent },
12114 { WM_GETTEXT, sent|defwinproc|optional },
12115 { WM_GETTEXT, sent|defwinproc|optional },
12116 { WM_ERASEBKGND, sent },
12117 { 0 }
12118 };
12119
12120 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12121 {
12122 if (message == WM_PAINT) return 0;
12123 return MsgCheckProcA( hwnd, message, wParam, lParam );
12124 }
12125
12126 static void test_DispatchMessage(void)
12127 {
12128 RECT rect;
12129 MSG msg;
12130 int count;
12131 HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
12132 100, 100, 200, 200, 0, 0, 0, NULL);
12133 ShowWindow( hwnd, SW_SHOW );
12134 UpdateWindow( hwnd );
12135 flush_events();
12136 flush_sequence();
12137 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
12138
12139 SetRect( &rect, -5, -5, 5, 5 );
12140 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
12141 count = 0;
12142 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
12143 {
12144 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
12145 else
12146 {
12147 flush_sequence();
12148 DispatchMessageA( &msg );
12149 /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
12150 if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
12151 else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
12152 if (++count > 10) break;
12153 }
12154 }
12155 ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
12156
12157 if (winetest_debug > 1) trace("now without DispatchMessage\n");
12158 flush_sequence();
12159 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
12160 count = 0;
12161 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
12162 {
12163 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
12164 else
12165 {
12166 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
12167 flush_sequence();
12168 /* this will send WM_NCCPAINT just like DispatchMessage does */
12169 GetUpdateRgn( hwnd, hrgn, TRUE );
12170 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
12171 DeleteObject( hrgn );
12172 GetClientRect( hwnd, &rect );
12173 ValidateRect( hwnd, &rect ); /* this will stop WM_PAINTs */
12174 ok( !count, "Got multiple WM_PAINTs\n" );
12175 if (++count > 10) break;
12176 }
12177 }
12178
12179 flush_sequence();
12180 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
12181 count = 0;
12182 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
12183 {
12184 if (msg.message != WM_PAINT) DispatchMessageA( &msg );
12185 else
12186 {
12187 HDC hdc;
12188
12189 flush_sequence();
12190 hdc = BeginPaint( hwnd, NULL );
12191 ok( !hdc, "got valid hdc %p from BeginPaint\n", hdc );
12192 ok( !EndPaint( hwnd, NULL ), "EndPaint succeeded\n" );
12193 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
12194 ok( !count, "Got multiple WM_PAINTs\n" );
12195 if (++count > 10) break;
12196 }
12197 }
12198 DestroyWindow(hwnd);
12199 }
12200
12201
12202 static const struct message WmUser[] = {
12203 { WM_USER, sent },
12204 { 0 }
12205 };
12206
12207 struct sendmsg_info
12208 {
12209 HWND hwnd;
12210 DWORD timeout;
12211 DWORD ret;
12212 HANDLE ready;
12213 };
12214
12215 static DWORD CALLBACK send_msg_thread( LPVOID arg )
12216 {
12217 struct sendmsg_info *info = arg;
12218 SetLastError( 0xdeadbeef );
12219 SetEvent( info->ready );
12220 info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
12221 if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT ||
12222 broken(GetLastError() == 0), /* win9x */
12223 "unexpected error %ld\n", GetLastError());
12224 return 0;
12225 }
12226
12227 static void wait_for_thread( HANDLE thread )
12228 {
12229 while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
12230 {
12231 MSG msg;
12232 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA(&msg);
12233 }
12234 }
12235
12236 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12237 {
12238 if (message == WM_USER) Sleep(200);
12239 return MsgCheckProcA( hwnd, message, wParam, lParam );
12240 }
12241
12242 static void test_SendMessageTimeout(void)
12243 {
12244 HANDLE thread;
12245 struct sendmsg_info info;
12246 DWORD tid;
12247 BOOL is_win9x;
12248
12249 info.ready = CreateEventA( NULL, 0, 0, NULL );
12250 info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
12251 100, 100, 200, 200, 0, 0, 0, NULL);
12252 flush_events();
12253 flush_sequence();
12254
12255 info.timeout = 1000;
12256 info.ret = 0xdeadbeef;
12257 ResetEvent( info.ready );
12258 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
12259 WaitForSingleObject( info.ready, INFINITE );
12260 wait_for_thread( thread );
12261 CloseHandle( thread );
12262 ok( info.ret == 1, "SendMessageTimeout failed\n" );
12263 ok_sequence( WmUser, "WmUser", FALSE );
12264
12265 info.timeout = 1;
12266 info.ret = 0xdeadbeef;
12267 ResetEvent( info.ready );
12268 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
12269 WaitForSingleObject( info.ready, INFINITE );
12270 Sleep(100); /* SendMessageTimeout should time out here */
12271 wait_for_thread( thread );
12272 CloseHandle( thread );
12273 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
12274 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
12275
12276 /* 0 means infinite timeout (but not on win9x) */
12277 info.timeout = 0;
12278 info.ret = 0xdeadbeef;
12279 ResetEvent( info.ready );
12280 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
12281 WaitForSingleObject( info.ready, INFINITE );
12282 Sleep(100);
12283 wait_for_thread( thread );
12284 CloseHandle( thread );
12285 is_win9x = !info.ret;
12286 if (is_win9x) ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
12287 else ok_sequence( WmUser, "WmUser", FALSE );
12288
12289 /* timeout is treated as signed despite the prototype (but not on win9x) */
12290 info.timeout = 0x7fffffff;
12291 info.ret = 0xdeadbeef;
12292 ResetEvent( info.ready );
12293 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
12294 WaitForSingleObject( info.ready, INFINITE );
12295 Sleep(100);
12296 wait_for_thread( thread );
12297 CloseHandle( thread );
12298 ok( info.ret == 1, "SendMessageTimeout failed\n" );
12299 ok_sequence( WmUser, "WmUser", FALSE );
12300
12301 info.timeout = 0x80000000;
12302 info.ret = 0xdeadbeef;
12303 ResetEvent( info.ready );
12304 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
12305 WaitForSingleObject( info.ready, INFINITE );
12306 Sleep(100);
12307 wait_for_thread( thread );
12308 CloseHandle( thread );
12309 if (is_win9x)
12310 {
12311 ok( info.ret == 1, "SendMessageTimeout failed\n" );
12312 ok_sequence( WmUser, "WmUser", FALSE );
12313 }
12314 else
12315 {
12316 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
12317 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
12318 }
12319
12320 /* now check for timeout during message processing */
12321 SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
12322 info.timeout = 100;
12323 info.ret = 0xdeadbeef;
12324 ResetEvent( info.ready );
12325 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
12326 WaitForSingleObject( info.ready, INFINITE );
12327 wait_for_thread( thread );
12328 CloseHandle( thread );
12329 /* we should time out but still get the message */
12330 ok( info.ret == 0, "SendMessageTimeout failed\n" );
12331 ok_sequence( WmUser, "WmUser", FALSE );
12332
12333 DestroyWindow( info.hwnd );
12334 CloseHandle( info.ready );
12335 }
12336
12337
12338 /****************** edit message test *************************/
12339 #define ID_EDIT 0x1234
12340 static const struct message sl_edit_setfocus[] =
12341 {
12342 { HCBT_SETFOCUS, hook },
12343 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
12344 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12345 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
12346 { WM_SETFOCUS, sent|wparam, 0 },
12347 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
12348 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 15 },
12349 { WM_CTLCOLOREDIT, sent|parent },
12350 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12351 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12352 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12353 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
12354 { 0 }
12355 };
12356 static const struct message sl_edit_invisible[] =
12357 {
12358 { HCBT_SETFOCUS, hook },
12359 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
12360 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12361 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Sent for IME. */
12362 { WM_KILLFOCUS, sent|parent },
12363 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
12364 { WM_SETFOCUS, sent },
12365 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12366 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12367 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
12368 { 0 }
12369 };
12370 static const struct message ml_edit_setfocus[] =
12371 {
12372 { HCBT_SETFOCUS, hook },
12373 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
12374 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12375 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
12376 { WM_SETFOCUS, sent|wparam, 0 },
12377 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
12378 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12379 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12380 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12381 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CARET, 0 },
12382 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
12383 { 0 }
12384 };
12385 static const struct message sl_edit_killfocus[] =
12386 {
12387 { HCBT_SETFOCUS, hook },
12388 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
12389 { WM_KILLFOCUS, sent|wparam, 0 },
12390 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12391 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12392 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
12393 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
12394 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
12395 { 0 }
12396 };
12397 static const struct message sl_edit_lbutton_dblclk[] =
12398 {
12399 { WM_LBUTTONDBLCLK, sent },
12400 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
12401 { 0 }
12402 };
12403 static const struct message sl_edit_lbutton_down[] =
12404 {
12405 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
12406 { HCBT_SETFOCUS, hook },
12407 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12408 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12409 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
12410 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
12411 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
12412 { WM_CTLCOLOREDIT, sent|parent },
12413 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12414 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12415 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CARET, 0 },
12416 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12417 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
12418 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
12419 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12420 { WM_CTLCOLOREDIT, sent|parent|optional },
12421 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12422 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CARET, 0 },
12423 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12424 { 0 }
12425 };
12426 static const struct message ml_edit_lbutton_down[] =
12427 {
12428 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
12429 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
12430 { HCBT_SETFOCUS, hook },
12431 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
12432 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
12433 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
12434 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
12435 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
12436 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
12437 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12438 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12439 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
12440 { 0 }
12441 };
12442 static const struct message sl_edit_lbutton_up[] =
12443 {
12444 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
12445 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12446 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
12447 { WM_CAPTURECHANGED, sent|defwinproc },
12448 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
12449 { 0 }
12450 };
12451 static const struct message ml_edit_lbutton_up[] =
12452 {
12453 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
12454 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
12455 { WM_CAPTURECHANGED, sent|defwinproc },
12456 { 0 }
12457 };
12458
12459 static WNDPROC old_edit_proc;
12460
12461 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12462 {
12463 static LONG defwndproc_counter = 0;
12464 LRESULT ret;
12465 struct recvd_message msg;
12466
12467 if (ignore_message( message )) return 0;
12468
12469 msg.hwnd = hwnd;
12470 msg.message = message;
12471 msg.flags = sent|wparam|lparam;
12472 if (defwndproc_counter) msg.flags |= defwinproc;
12473 msg.wParam = wParam;
12474 msg.lParam = lParam;
12475 msg.descr = "edit";
12476 add_message(&msg);
12477
12478 defwndproc_counter++;
12479 ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
12480 defwndproc_counter--;
12481
12482 return ret;
12483 }
12484
12485 static const struct message edit_wm_ime_composition_seq[] =
12486 {
12487 {WM_IME_STARTCOMPOSITION, sent},
12488 {WM_IME_COMPOSITION, sent | wparam, 'W'},
12489 {WM_IME_CHAR, sent | wparam | defwinproc, 'W'},
12490 {WM_IME_CHAR, sent | wparam | defwinproc, 'i'},
12491 {WM_IME_CHAR, sent | wparam | defwinproc, 'n'},
12492 {WM_IME_CHAR, sent | wparam | defwinproc, 'e'},
12493 {WM_IME_ENDCOMPOSITION, sent},
12494 {WM_CHAR, sent | wparam, 'W'},
12495 {WM_CHAR, sent | wparam, 'i'},
12496 {WM_CHAR, sent | wparam, 'n'},
12497 {WM_CHAR, sent | wparam, 'e'},
12498 {0}
12499 };
12500
12501 static const struct message edit_wm_ime_char_seq[] =
12502 {
12503 {WM_IME_CHAR, sent | wparam, '0'},
12504 {WM_CHAR, sent | wparam, '0'},
12505 {0}
12506 };
12507
12508 static const struct message edit_eimes_getcompstratonce_seq[] =
12509 {
12510 {WM_IME_STARTCOMPOSITION, sent},
12511 {WM_IME_COMPOSITION, sent | wparam, 'W'},
12512 {WM_IME_ENDCOMPOSITION, sent},
12513 {0}
12514 };
12515
12516 static LRESULT CALLBACK edit_ime_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
12517 {
12518 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
12519 static LONG defwndproc_counter = 0;
12520 struct recvd_message msg = {0};
12521 LRESULT ret;
12522
12523 msg.message = message;
12524 msg.flags = sent | wparam;
12525 if (defwndproc_counter)
12526 msg.flags |= defwinproc;
12527 msg.wParam = wParam;
12528
12529 if (message < 0xc000 &&
12530 message != WM_GETTEXTLENGTH &&
12531 message != WM_GETTEXT &&
12532 message != WM_GETFONT &&
12533 message != WM_GETICON &&
12534 message != WM_IME_SETCONTEXT &&
12535 message != WM_IME_NOTIFY &&
12536 message != WM_CTLCOLOREDIT &&
12537 message != WM_PAINT &&
12538 message != WM_ERASEBKGND &&
12539 message != WM_NCHITTEST &&
12540 message != WM_SETCURSOR &&
12541 message != WM_MOUSEMOVE &&
12542 message != WM_MOUSEACTIVATE &&
12543 message != WM_KEYUP &&
12544 (message < EM_GETSEL || message > EM_GETIMESTATUS))
12545 {
12546 add_message(&msg);
12547 }
12548
12549 defwndproc_counter++;
12550 if (IsWindowUnicode(hwnd))
12551 ret = CallWindowProcW(oldproc, hwnd, message, wParam, lParam);
12552 else
12553 ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
12554 defwndproc_counter--;
12555
12556 return ret;
12557 }
12558
12559 static DWORD WINAPI test_edit_ime_messages(void *unused_arg)
12560 {
12561 WNDPROC old_proc;
12562 LRESULT lr;
12563 HIMC himc;
12564 HWND hwnd;
12565 BOOL ret;
12566 MSG msg;
12567
12568 hwnd = CreateWindowA(WC_EDITA, "Test", WS_POPUP | WS_VISIBLE, 10, 10, 300, 300, NULL, NULL,
12569 NULL, NULL);
12570 ok(hwnd != NULL, "CreateWindowA failed.\n");
12571
12572 /* Test EM_{GET|SET}IMESTATUS */
12573 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12574 ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
12575
12576 /* Note that EM_SETIMESTATUS always return 1, which is contrary to what MSDN says about
12577 * returning the previous LPARAM value */
12578 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_GETCOMPSTRATONCE);
12579 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12580 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12581 ok(lr == EIMES_GETCOMPSTRATONCE, "Got unexpected lr %#Ix.\n", lr);
12582
12583 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_CANCELCOMPSTRINFOCUS);
12584 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12585 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12586 ok(lr == EIMES_CANCELCOMPSTRINFOCUS, "Got unexpected lr %#Ix.\n", lr);
12587
12588 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_COMPLETECOMPSTRKILLFOCUS);
12589 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12590 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12591 ok(lr == EIMES_COMPLETECOMPSTRKILLFOCUS, "Got unexpected lr %#Ix.\n", lr);
12592
12593 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_GETCOMPSTRATONCE
12594 | EIMES_CANCELCOMPSTRINFOCUS | EIMES_COMPLETECOMPSTRKILLFOCUS);
12595 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12596 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12597 ok(lr == (EIMES_GETCOMPSTRATONCE | EIMES_CANCELCOMPSTRINFOCUS | EIMES_COMPLETECOMPSTRKILLFOCUS),
12598 "Got unexpected lr %#Ix.\n", lr);
12599
12600 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12601 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12602 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12603 ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
12604
12605 /* Invalid EM_{GET|SET}IMESTATUS status types and flags */
12606 lr = SendMessageA(hwnd, EM_GETIMESTATUS, 0, 0);
12607 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12608
12609 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING + 1, 0);
12610 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12611
12612 lr = SendMessageA(hwnd, EM_SETIMESTATUS, 0, EIMES_GETCOMPSTRATONCE);
12613 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12614 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12615 ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
12616
12617 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING + 1, EIMES_GETCOMPSTRATONCE);
12618 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12619 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12620 ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
12621
12622 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0xFFFFFFFF);
12623 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12624 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12625 ok(lr == 0xFFFF, "Got unexpected lr %#Ix.\n", lr);
12626
12627 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12628 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12629 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12630 ok(lr == 0, "Got unexpected lr %#Ix.\n", lr);
12631
12632 /* Test IME messages when EIMES_GETCOMPSTRATONCE is not set */
12633 old_proc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)edit_ime_subclass_proc);
12634 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)old_proc);
12635
12636 himc = ImmGetContext(hwnd);
12637 ret = ImmSetCompositionStringA(himc, SCS_SETSTR, "Wine", 4, NULL, 0);
12638 ok(ret, "ImmSetCompositionStringA failed.\n");
12639 flush_sequence();
12640 ret = ImmNotifyIME(himc, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
12641 ok(ret, "ImmNotifyIME failed.\n");
12642 /* Note that the following message loop is necessary to get the WM_CHAR messages because they
12643 * are posted. Same for the later message loops in this function. */
12644 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
12645 ok_sequence(edit_wm_ime_composition_seq, "WM_IME_COMPOSITION", TRUE);
12646
12647 /* Test that WM_IME_CHAR is passed to DefWindowProc() to get WM_CHAR */
12648 flush_sequence();
12649 SendMessageA(hwnd, WM_IME_CHAR, '0', 1);
12650 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
12651 ok_sequence(edit_wm_ime_char_seq, "WM_IME_CHAR", FALSE);
12652
12653 /* Test IME messages when EIMES_GETCOMPSTRATONCE is set */
12654 lr = SendMessageA(hwnd, EM_SETIMESTATUS, EMSIS_COMPOSITIONSTRING, EIMES_GETCOMPSTRATONCE);
12655 ok(lr == 1, "Got unexpected lr %#Ix.\n", lr);
12656 lr = SendMessageA(hwnd, EM_GETIMESTATUS, EMSIS_COMPOSITIONSTRING, 0);
12657 ok(lr == EIMES_GETCOMPSTRATONCE, "Got unexpected lr %#Ix.\n", lr);
12658
12659 ret = ImmSetCompositionStringA(himc, SCS_SETSTR, "Wine", 4, NULL, 0);
12660 ok(ret, "ImmSetCompositionStringA failed.\n");
12661 flush_sequence();
12662 ret = ImmNotifyIME(himc, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
12663 ok(ret, "ImmNotifyIME failed.\n");
12664 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
12665 ok_sequence(edit_eimes_getcompstratonce_seq,
12666 "WM_IME_COMPOSITION with EIMES_GETCOMPSTRATONCE", TRUE);
12667
12668 /* Test that WM_IME_CHAR is passed to DefWindowProc() to get WM_CHAR with EIMES_GETCOMPSTRATONCE */
12669 flush_sequence();
12670 SendMessageA(hwnd, WM_IME_CHAR, '0', 1);
12671 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
12672 ok_sequence(edit_wm_ime_char_seq, "WM_IME_CHAR", FALSE);
12673
12674 ImmReleaseContext(hwnd, himc);
12675 DestroyWindow(hwnd);
12676 return 0;
12677 }
12678
12679 static void subclass_edit(void)
12680 {
12681 WNDCLASSA cls;
12682
12683 if (!GetClassInfoA(0, "edit", &cls)) assert(0);
12684
12685 old_edit_proc = cls.lpfnWndProc;
12686
12687 cls.hInstance = GetModuleHandleA(NULL);
12688 cls.lpfnWndProc = edit_hook_proc;
12689 cls.lpszClassName = "my_edit_class";
12690 UnregisterClassA(cls.lpszClassName, cls.hInstance);
12691 if (!RegisterClassA(&cls)) assert(0);
12692 }
12693
12694 static void test_edit_messages(void)
12695 {
12696 HWND hwnd, parent;
12697 DWORD dlg_code;
12698 HANDLE thread;
12699
12700 subclass_edit();
12701 log_all_parent_messages++;
12702
12703 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
12704 100, 100, 200, 200, 0, 0, 0, NULL);
12705 ok (parent != 0, "Failed to create parent window\n");
12706
12707 /* test single line edit */
12708 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
12709 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
12710 ok(hwnd != 0, "Failed to create edit window\n");
12711
12712 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
12713 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08lx\n", dlg_code);
12714
12715 flush_sequence();
12716 SetFocus(hwnd);
12717 ok_sequence(sl_edit_invisible, "SetFocus(hwnd) on an invisible edit", FALSE);
12718
12719 ShowWindow(hwnd, SW_SHOW);
12720 UpdateWindow(hwnd);
12721 SetFocus(0);
12722 flush_sequence();
12723
12724 SetFocus(hwnd);
12725 ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
12726
12727 SetFocus(0);
12728 ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
12729
12730 SetFocus(0);
12731 ReleaseCapture();
12732 flush_sequence();
12733
12734 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
12735 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
12736
12737 SetFocus(0);
12738 ReleaseCapture();
12739 flush_sequence();
12740
12741 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
12742 ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
12743
12744 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
12745 ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
12746
12747 DestroyWindow(hwnd);
12748
12749 /* test multiline edit */
12750 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
12751 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
12752 ok(hwnd != 0, "Failed to create edit window\n");
12753
12754 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
12755 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
12756 "wrong dlg_code %08lx\n", dlg_code);
12757
12758 ShowWindow(hwnd, SW_SHOW);
12759 UpdateWindow(hwnd);
12760 SetFocus(0);
12761 flush_sequence();
12762
12763 SetFocus(hwnd);
12764 ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
12765
12766 SetFocus(0);
12767 ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
12768
12769 SetFocus(0);
12770 ReleaseCapture();
12771 flush_sequence();
12772
12773 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
12774 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
12775
12776 SetFocus(0);
12777 ReleaseCapture();
12778 flush_sequence();
12779
12780 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
12781 ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
12782
12783 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
12784 ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
12785
12786 DestroyWindow(hwnd);
12787 DestroyWindow(parent);
12788
12789 log_all_parent_messages--;
12790
12791 /* Test IME messages in another thread because IME is disabled in the current thread */
12792 thread = CreateThread(NULL, 0, test_edit_ime_messages, NULL, 0, NULL);
12793 WaitForSingleObject(thread, INFINITE);
12794 CloseHandle(thread);
12795 }
12796
12797 /**************************** End of Edit test ******************************/
12798
12799 static const struct message WmKeyDownSkippedSeq[] =
12800 {
12801 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
12802 { 0 }
12803 };
12804 static const struct message WmKeyDownWasDownSkippedSeq[] =
12805 {
12806 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x40000001 }, /* XP */
12807 { 0 }
12808 };
12809 static const struct message WmKeyUpSkippedSeq[] =
12810 {
12811 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
12812 { 0 }
12813 };
12814 static const struct message WmUserKeyUpSkippedSeq[] =
12815 {
12816 { WM_USER, sent },
12817 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
12818 { 0 }
12819 };
12820
12821 #define EV_STOP 0
12822 #define EV_SENDMSG 1
12823 #define EV_ACK 2
12824
12825 struct peekmsg_info
12826 {
12827 HWND hwnd;
12828 HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
12829 };
12830
12831 static DWORD CALLBACK send_msg_thread_2(void *param)
12832 {
12833 DWORD ret;
12834 struct peekmsg_info *info = param;
12835
12836 if (winetest_debug > 1) trace("thread: looping\n");
12837 SetEvent(info->hevent[EV_ACK]);
12838
12839 while (1)
12840 {
12841 ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
12842
12843 switch (ret)
12844 {
12845 case WAIT_OBJECT_0 + EV_STOP:
12846 if (winetest_debug > 1) trace("thread: exiting\n");
12847 return 0;
12848
12849 case WAIT_OBJECT_0 + EV_SENDMSG:
12850 if (winetest_debug > 1) trace("thread: sending message\n");
12851 ret = SendNotifyMessageA(info->hwnd, WM_USER, 0, 0);
12852 ok(ret, "SendNotifyMessageA failed error %lu\n", GetLastError());
12853 SetEvent(info->hevent[EV_ACK]);
12854 break;
12855
12856 default:
12857 if (winetest_debug > 1) trace("unexpected return: %04lx\n", ret);
12858 assert(0);
12859 break;
12860 }
12861 }
12862 return 0;
12863 }
12864
12865 static void test_PeekMessage(void)
12866 {
12867 MSG msg;
12868 HANDLE hthread;
12869 DWORD tid, qstatus;
12870 UINT qs_all_input = QS_ALLINPUT;
12871 UINT qs_input = QS_INPUT;
12872 BOOL ret;
12873 struct peekmsg_info info;
12874
12875 info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
12876 100, 100, 200, 200, 0, 0, 0, NULL);
12877 assert(info.hwnd);
12878 ShowWindow(info.hwnd, SW_SHOW);
12879 UpdateWindow(info.hwnd);
12880 SetFocus(info.hwnd);
12881
12882 info.hevent[EV_STOP] = CreateEventA(NULL, 0, 0, NULL);
12883 info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
12884 info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
12885
12886 hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
12887 WaitForSingleObject(info.hevent[EV_ACK], 10000);
12888
12889 flush_events();
12890 flush_sequence();
12891
12892 SetLastError(0xdeadbeef);
12893 qstatus = GetQueueStatus(qs_all_input);
12894 if (GetLastError() == ERROR_INVALID_FLAGS)
12895 {
12896 trace("QS_RAWINPUT not supported on this platform\n");
12897 qs_all_input &= ~QS_RAWINPUT;
12898 qs_input &= ~QS_RAWINPUT;
12899 }
12900 if (qstatus & QS_POSTMESSAGE)
12901 {
12902 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) /* nothing */ ;
12903 qstatus = GetQueueStatus(qs_all_input);
12904 }
12905 ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
12906
12907 if (winetest_debug > 1) trace("signalling to send message\n");
12908 SetEvent(info.hevent[EV_SENDMSG]);
12909 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
12910
12911 /* pass invalid QS_xxxx flags */
12912 SetLastError(0xdeadbeef);
12913 qstatus = GetQueueStatus(0xffffffff);
12914 ok(qstatus == 0 || broken(qstatus) /* win9x */, "GetQueueStatus should fail: %08lx\n", qstatus);
12915 if (!qstatus)
12916 {
12917 ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %ld\n", GetLastError());
12918 qstatus = GetQueueStatus(qs_all_input);
12919 }
12920 qstatus &= ~MAKELONG( 0x4000, 0x4000 ); /* sometimes set on Win95 */
12921 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
12922 "wrong qstatus %08lx\n", qstatus);
12923
12924 msg.message = 0;
12925 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
12926 ok(!ret,
12927 "PeekMessageA should have returned FALSE instead of msg %04x\n",
12928 msg.message);
12929 ok_sequence(WmUser, "WmUser", FALSE);
12930
12931 qstatus = GetQueueStatus(qs_all_input);
12932 ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
12933
12934 keybd_event('N', 0, 0, 0);
12935 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
12936 qstatus = GetQueueStatus(qs_all_input);
12937 if (!(qstatus & MAKELONG(QS_KEY, QS_KEY)))
12938 {
12939 skip( "queuing key events not supported\n" );
12940 goto done;
12941 }
12942 ok(qstatus == MAKELONG(QS_KEY, QS_KEY) ||
12943 /* keybd_event seems to trigger a sent message on NT4 */
12944 qstatus == MAKELONG(QS_KEY|QS_SENDMESSAGE, QS_KEY|QS_SENDMESSAGE),
12945 "wrong qstatus %08lx\n", qstatus);
12946
12947 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
12948 qstatus = GetQueueStatus(qs_all_input);
12949 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY) ||
12950 qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
12951 "wrong qstatus %08lx\n", qstatus);
12952
12953 InvalidateRect(info.hwnd, NULL, FALSE);
12954 qstatus = GetQueueStatus(qs_all_input);
12955 ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY) ||
12956 qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY|QS_SENDMESSAGE),
12957 "wrong qstatus %08lx\n", qstatus);
12958
12959 if (winetest_debug > 1) trace("signalling to send message\n");
12960 SetEvent(info.hevent[EV_SENDMSG]);
12961 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
12962
12963 qstatus = GetQueueStatus(qs_all_input);
12964 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
12965 "wrong qstatus %08lx\n", qstatus);
12966
12967 msg.message = 0;
12968 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
12969 if (ret && msg.message == WM_CHAR)
12970 {
12971 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
12972 goto done;
12973 }
12974 ok(!ret,
12975 "PeekMessageA should have returned FALSE instead of msg %04x\n",
12976 msg.message);
12977 if (!sequence_cnt) /* nt4 doesn't fetch anything with PM_QS_* flags */
12978 {
12979 win_skip( "PM_QS_* flags not supported in PeekMessage\n" );
12980 goto done;
12981 }
12982 ok_sequence(WmUser, "WmUser", FALSE);
12983
12984 qstatus = GetQueueStatus(qs_all_input);
12985 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
12986 "wrong qstatus %08lx\n", qstatus);
12987
12988 if (winetest_debug > 1) trace("signalling to send message\n");
12989 SetEvent(info.hevent[EV_SENDMSG]);
12990 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
12991
12992 qstatus = GetQueueStatus(qs_all_input);
12993 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
12994 "wrong qstatus %08lx\n", qstatus);
12995
12996 msg.message = 0;
12997 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE );
12998 ok(!ret,
12999 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13000 msg.message);
13001 ok_sequence(WmUser, "WmUser", FALSE);
13002
13003 qstatus = GetQueueStatus(qs_all_input);
13004 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
13005 "wrong qstatus %08lx\n", qstatus);
13006
13007 msg.message = 0;
13008 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
13009 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
13010 "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
13011 ret, msg.message, msg.wParam);
13012 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13013
13014 qstatus = GetQueueStatus(qs_all_input);
13015 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
13016 "wrong qstatus %08lx\n", qstatus);
13017
13018 msg.message = 0;
13019 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
13020 ok(!ret,
13021 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13022 msg.message);
13023 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13024
13025 qstatus = GetQueueStatus(qs_all_input);
13026 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
13027 "wrong qstatus %08lx\n", qstatus);
13028
13029 msg.message = 0;
13030 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
13031 ok(ret && msg.message == WM_PAINT,
13032 "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
13033 DispatchMessageA(&msg);
13034 ok_sequence(WmPaint, "WmPaint", FALSE);
13035
13036 qstatus = GetQueueStatus(qs_all_input);
13037 ok(qstatus == MAKELONG(0, QS_KEY),
13038 "wrong qstatus %08lx\n", qstatus);
13039
13040 msg.message = 0;
13041 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
13042 ok(!ret,
13043 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13044 msg.message);
13045 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13046
13047 qstatus = GetQueueStatus(qs_all_input);
13048 ok(qstatus == MAKELONG(0, QS_KEY),
13049 "wrong qstatus %08lx\n", qstatus);
13050
13051 if (winetest_debug > 1) trace("signalling to send message\n");
13052 SetEvent(info.hevent[EV_SENDMSG]);
13053 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
13054
13055 qstatus = GetQueueStatus(qs_all_input);
13056 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
13057 "wrong qstatus %08lx\n", qstatus);
13058
13059 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
13060
13061 qstatus = GetQueueStatus(qs_all_input);
13062 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
13063 "wrong qstatus %08lx\n", qstatus);
13064
13065 msg.message = 0;
13066 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
13067 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
13068 "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
13069 ret, msg.message, msg.wParam);
13070 ok_sequence(WmUser, "WmUser", FALSE);
13071
13072 qstatus = GetQueueStatus(qs_all_input);
13073 ok(qstatus == MAKELONG(0, QS_KEY),
13074 "wrong qstatus %08lx\n", qstatus);
13075
13076 msg.message = 0;
13077 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
13078 ok(!ret,
13079 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13080 msg.message);
13081 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13082
13083 qstatus = GetQueueStatus(qs_all_input);
13084 ok(qstatus == MAKELONG(0, QS_KEY),
13085 "wrong qstatus %08lx\n", qstatus);
13086
13087 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
13088
13089 qstatus = GetQueueStatus(qs_all_input);
13090 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
13091 "wrong qstatus %08lx\n", qstatus);
13092
13093 if (winetest_debug > 1) trace("signalling to send message\n");
13094 SetEvent(info.hevent[EV_SENDMSG]);
13095 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
13096
13097 qstatus = GetQueueStatus(qs_all_input);
13098 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
13099 "wrong qstatus %08lx\n", qstatus);
13100
13101 msg.message = 0;
13102 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
13103 ok(!ret,
13104 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13105 msg.message);
13106 ok_sequence(WmUser, "WmUser", FALSE);
13107
13108 qstatus = GetQueueStatus(qs_all_input);
13109 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
13110 "wrong qstatus %08lx\n", qstatus);
13111
13112 msg.message = 0;
13113 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
13114 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
13115 else /* workaround for a missing QS_RAWINPUT support */
13116 ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
13117 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
13118 "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
13119 ret, msg.message, msg.wParam);
13120 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
13121
13122 qstatus = GetQueueStatus(qs_all_input);
13123 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
13124 "wrong qstatus %08lx\n", qstatus);
13125
13126 msg.message = 0;
13127 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
13128 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
13129 else /* workaround for a missing QS_RAWINPUT support */
13130 ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
13131 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
13132 "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYUP wParam 'N'\n",
13133 ret, msg.message, msg.wParam);
13134 ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
13135
13136 qstatus = GetQueueStatus(qs_all_input);
13137 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
13138 "wrong qstatus %08lx\n", qstatus);
13139
13140 msg.message = 0;
13141 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
13142 ok(!ret,
13143 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13144 msg.message);
13145 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13146
13147 qstatus = GetQueueStatus(qs_all_input);
13148 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
13149 "wrong qstatus %08lx\n", qstatus);
13150
13151 msg.message = 0;
13152 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
13153 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
13154 "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
13155 ret, msg.message, msg.wParam);
13156 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13157
13158 qstatus = GetQueueStatus(qs_all_input);
13159 ok(qstatus == 0,
13160 "wrong qstatus %08lx\n", qstatus);
13161
13162 msg.message = 0;
13163 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
13164 ok(!ret,
13165 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13166 msg.message);
13167 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13168
13169 qstatus = GetQueueStatus(qs_all_input);
13170 ok(qstatus == 0,
13171 "wrong qstatus %08lx\n", qstatus);
13172
13173 /* test whether presence of the quit flag in the queue affects
13174 * the queue state
13175 */
13176 PostQuitMessage(0x1234abcd);
13177
13178 qstatus = GetQueueStatus(qs_all_input);
13179 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
13180 "wrong qstatus %08lx\n", qstatus);
13181
13182 PostMessageA(info.hwnd, WM_USER, 0, 0);
13183
13184 qstatus = GetQueueStatus(qs_all_input);
13185 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
13186 "wrong qstatus %08lx\n", qstatus);
13187
13188 msg.message = 0;
13189 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
13190 ok(ret && msg.message == WM_USER,
13191 "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
13192 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13193
13194 qstatus = GetQueueStatus(qs_all_input);
13195 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
13196 "wrong qstatus %08lx\n", qstatus);
13197
13198 msg.message = 0;
13199 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
13200 ok(ret && msg.message == WM_QUIT,
13201 "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
13202 ok(msg.wParam == 0x1234abcd, "got wParam %08Ix instead of 0x1234abcd\n", msg.wParam);
13203 ok(msg.lParam == 0, "got lParam %08Ix instead of 0\n", msg.lParam);
13204 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13205
13206 qstatus = GetQueueStatus(qs_all_input);
13207 todo_wine {
13208 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
13209 "wrong qstatus %08lx\n", qstatus);
13210 }
13211
13212 msg.message = 0;
13213 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
13214 ok(!ret,
13215 "PeekMessageA should have returned FALSE instead of msg %04x\n",
13216 msg.message);
13217 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
13218
13219 qstatus = GetQueueStatus(qs_all_input);
13220 ok(qstatus == 0,
13221 "wrong qstatus %08lx\n", qstatus);
13222
13223 /* some GetMessage tests */
13224
13225 keybd_event('N', 0, 0, 0);
13226 qstatus = GetQueueStatus(qs_all_input);
13227 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08lx\n", qstatus);
13228
13229 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
13230 qstatus = GetQueueStatus(qs_all_input);
13231 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08lx\n", qstatus);
13232
13233 if (qstatus)
13234 {
13235 ret = GetMessageA( &msg, 0, 0, 0 );
13236 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
13237 "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
13238 ret, msg.message, msg.wParam);
13239 qstatus = GetQueueStatus(qs_all_input);
13240 ok(qstatus == MAKELONG(0, QS_KEY), "wrong qstatus %08lx\n", qstatus);
13241 }
13242
13243 if (qstatus)
13244 {
13245 ret = GetMessageA( &msg, 0, 0, 0 );
13246 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
13247 "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
13248 ret, msg.message, msg.wParam);
13249 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
13250 qstatus = GetQueueStatus(qs_all_input);
13251 ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
13252 }
13253
13254 keybd_event('N', 0, 0, 0);
13255 qstatus = GetQueueStatus(qs_all_input);
13256 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08lx\n", qstatus);
13257
13258 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
13259 qstatus = GetQueueStatus(qs_all_input);
13260 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08lx\n", qstatus);
13261
13262 if (qstatus & (QS_KEY << 16))
13263 {
13264 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
13265 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
13266 "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
13267 ret, msg.message, msg.wParam);
13268 ok_sequence(WmKeyDownWasDownSkippedSeq, "WmKeyDownWasDownSkippedSeq", FALSE);
13269 qstatus = GetQueueStatus(qs_all_input);
13270 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08lx\n", qstatus);
13271 }
13272
13273 if (qstatus)
13274 {
13275 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
13276 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
13277 "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
13278 ret, msg.message, msg.wParam);
13279 qstatus = GetQueueStatus(qs_all_input);
13280 ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
13281 }
13282
13283 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
13284 qstatus = GetQueueStatus(qs_all_input);
13285 ok(qstatus == MAKELONG(QS_KEY, QS_KEY), "wrong qstatus %08lx\n", qstatus);
13286
13287 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
13288 qstatus = GetQueueStatus(qs_all_input);
13289 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY), "wrong qstatus %08lx\n", qstatus);
13290
13291 if (winetest_debug > 1) trace("signalling to send message\n");
13292 SetEvent(info.hevent[EV_SENDMSG]);
13293 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
13294 qstatus = GetQueueStatus(qs_all_input);
13295 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
13296 "wrong qstatus %08lx\n", qstatus);
13297
13298 if (qstatus & (QS_KEY << 16))
13299 {
13300 ret = GetMessageA( &msg, 0, WM_KEYDOWN, WM_KEYUP );
13301 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
13302 "got %d and %04x wParam %08Ix instead of TRUE and WM_KEYDOWN wParam 'N'\n",
13303 ret, msg.message, msg.wParam);
13304 ok_sequence(WmUserKeyUpSkippedSeq, "WmUserKeyUpSkippedSeq", FALSE);
13305 qstatus = GetQueueStatus(qs_all_input);
13306 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE), "wrong qstatus %08lx\n", qstatus);
13307 }
13308
13309 if (qstatus)
13310 {
13311 ret = GetMessageA( &msg, 0, WM_CHAR, WM_CHAR );
13312 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
13313 "got %d and %04x wParam %08Ix instead of TRUE and WM_CHAR wParam 'z'\n",
13314 ret, msg.message, msg.wParam);
13315 qstatus = GetQueueStatus(qs_all_input);
13316 ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
13317 }
13318
13319 PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
13320 ret = PeekMessageA(&msg, (HWND)-1, 0, 0, PM_NOREMOVE);
13321 ok(ret == TRUE, "wrong ret %d\n", ret);
13322 ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
13323 ret = GetMessageA(&msg, (HWND)-1, 0, 0);
13324 ok(ret == TRUE, "wrong ret %d\n", ret);
13325 ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
13326
13327 PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
13328 ret = PeekMessageA(&msg, (HWND)1, 0, 0, PM_NOREMOVE);
13329 ok(ret == TRUE, "wrong ret %d\n", ret);
13330 ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
13331 ret = GetMessageA(&msg, (HWND)1, 0, 0);
13332 ok(ret == TRUE, "wrong ret %d\n", ret);
13333 ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
13334
13335 PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
13336 ret = PeekMessageA(&msg, (HWND)0xffff, 0, 0, PM_NOREMOVE);
13337 ok(ret == TRUE, "wrong ret %d\n", ret);
13338 ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
13339 ret = GetMessageA(&msg, (HWND)0xffff, 0, 0);
13340 ok(ret == TRUE, "wrong ret %d\n", ret);
13341 ok(msg.message == WM_USER, "wrong message %u\n", msg.message);
13342
13343 done:
13344 if (winetest_debug > 1) trace("signalling to exit\n");
13345 SetEvent(info.hevent[EV_STOP]);
13346
13347 WaitForSingleObject(hthread, INFINITE);
13348
13349 CloseHandle(hthread);
13350 CloseHandle(info.hevent[0]);
13351 CloseHandle(info.hevent[1]);
13352 CloseHandle(info.hevent[2]);
13353
13354 DestroyWindow(info.hwnd);
13355 }
13356
13357 static void wait_move_event(HWND hwnd, int x, int y)
13358 {
13359 MSG msg;
13360 DWORD timeout = GetTickCount() + 500;
13361 BOOL ret;
13362 int delay;
13363
13364 while ((delay = timeout - GetTickCount()) > 0)
13365 {
13366 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
13367 if (ret && msg.pt.x > x && msg.pt.y > y) break;
13368 if (!ret) MsgWaitForMultipleObjects( 0, NULL, FALSE, delay, QS_ALLINPUT );
13369 else Sleep( delay );
13370 }
13371 }
13372
13373 #define STEP 5
13374 static void test_PeekMessage2(void)
13375 {
13376 HWND hwnd;
13377 BOOL ret;
13378 MSG msg;
13379 UINT message;
13380 DWORD time1, time2, time3;
13381 int x1, y1, x2, y2, x3, y3;
13382 POINT pos;
13383
13384 time1 = time2 = time3 = 0;
13385 x1 = y1 = x2 = y2 = x3 = y3 = 0;
13386
13387 /* Initialise window and make sure it is ready for events */
13388 hwnd = CreateWindowA("TestWindowClass", "PeekMessage2", WS_OVERLAPPEDWINDOW,
13389 10, 10, 800, 800, NULL, NULL, NULL, NULL);
13390 assert(hwnd);
13391 if (winetest_debug > 1) trace("Window for test_PeekMessage2 %p\n", hwnd);
13392 ShowWindow(hwnd, SW_SHOW);
13393 UpdateWindow(hwnd);
13394 SetFocus(hwnd);
13395 GetCursorPos(&pos);
13396 SetCursorPos(100, 100);
13397 mouse_event(MOUSEEVENTF_MOVE, -STEP, -STEP, 0, 0);
13398 flush_events();
13399
13400 /* Do initial mousemove, wait until we can see it
13401 and then do our test peek with PM_NOREMOVE. */
13402 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
13403 wait_move_event(hwnd, 100-STEP, 100-STEP);
13404
13405 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
13406 if (!ret)
13407 {
13408 skip( "queuing mouse events not supported\n" );
13409 goto done;
13410 }
13411 else
13412 {
13413 if (winetest_debug > 1) trace("1st move event: %04x %lx %ld %ld\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
13414 message = msg.message;
13415 time1 = msg.time;
13416 x1 = msg.pt.x;
13417 y1 = msg.pt.y;
13418 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
13419 }
13420
13421 /* Allow time to advance a bit, and then simulate the user moving their
13422 * mouse around. After that we peek again with PM_NOREMOVE.
13423 * Although the previous mousemove message was never removed, the
13424 * mousemove we now peek should reflect the recent mouse movements
13425 * because the input queue will merge the move events. */
13426 Sleep(100);
13427 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
13428 wait_move_event(hwnd, x1, y1);
13429
13430 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
13431 ok(ret, "no message available\n");
13432 if (ret) {
13433 if (winetest_debug > 1) trace("2nd move event: %04x %lx %ld %ld\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
13434 message = msg.message;
13435 time2 = msg.time;
13436 x2 = msg.pt.x;
13437 y2 = msg.pt.y;
13438 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
13439 ok(time2 > time1, "message time not advanced: %lx %lx\n", time1, time2);
13440 ok(x2 != x1 && y2 != y1, "coords not changed: (%d %d) (%d %d)\n", x1, y1, x2, y2);
13441 }
13442
13443 /* Have another go, to drive the point home */
13444 Sleep(100);
13445 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
13446 wait_move_event(hwnd, x2, y2);
13447
13448 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
13449 ok(ret, "no message available\n");
13450 if (ret) {
13451 if (winetest_debug > 1) trace("3rd move event: %04x %lx %ld %ld\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
13452 message = msg.message;
13453 time3 = msg.time;
13454 x3 = msg.pt.x;
13455 y3 = msg.pt.y;
13456 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
13457 ok(time3 > time2, "message time not advanced: %lx %lx\n", time2, time3);
13458 ok(x3 != x2 && y3 != y2, "coords not changed: (%d %d) (%d %d)\n", x2, y2, x3, y3);
13459 }
13460
13461 done:
13462 DestroyWindow(hwnd);
13463 SetCursorPos(pos.x, pos.y);
13464 flush_events();
13465 }
13466
13467 static void test_PeekMessage3(void)
13468 {
13469 HWND hwnd;
13470 BOOL ret;
13471 MSG msg;
13472
13473 hwnd = CreateWindowA("TestWindowClass", "PeekMessage3", WS_OVERLAPPEDWINDOW,
13474 10, 10, 800, 800, NULL, NULL, NULL, NULL);
13475 ok(hwnd != NULL, "expected hwnd != NULL\n");
13476 flush_events();
13477
13478 /* GetMessage() and PeekMessage(..., PM_REMOVE) should prefer messages which
13479 * were already seen. */
13480
13481 SetTimer(hwnd, 1, 100, NULL);
13482 while (!PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE));
13483 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13484 PostMessageA(hwnd, WM_USER, 0, 0);
13485 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
13486 todo_wine
13487 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13488 ret = GetMessageA(&msg, NULL, 0, 0);
13489 todo_wine
13490 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13491 ret = GetMessageA(&msg, NULL, 0, 0);
13492 todo_wine
13493 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13494 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13495 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13496
13497 SetTimer(hwnd, 1, 100, NULL);
13498 while (!PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE));
13499 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13500 PostMessageA(hwnd, WM_USER, 0, 0);
13501 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
13502 todo_wine
13503 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13504 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
13505 todo_wine
13506 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13507 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13508 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13509
13510 /* It doesn't matter if a message range is specified or not. */
13511
13512 SetTimer(hwnd, 1, 100, NULL);
13513 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
13514 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13515 PostMessageA(hwnd, WM_USER, 0, 0);
13516 ret = GetMessageA(&msg, NULL, 0, 0);
13517 todo_wine
13518 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13519 ret = GetMessageA(&msg, NULL, 0, 0);
13520 todo_wine
13521 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13522 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13523 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13524
13525 /* But not if the post messages were added before the PeekMessage() call. */
13526
13527 PostMessageA(hwnd, WM_USER, 0, 0);
13528 SetTimer(hwnd, 1, 100, NULL);
13529 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
13530 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13531 ret = GetMessageA(&msg, NULL, 0, 0);
13532 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13533 ret = GetMessageA(&msg, NULL, 0, 0);
13534 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13535 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13536 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13537
13538 /* More complicated test with multiple messages. */
13539
13540 PostMessageA(hwnd, WM_USER, 0, 0);
13541 SetTimer(hwnd, 1, 100, NULL);
13542 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
13543 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13544 PostMessageA(hwnd, WM_USER + 1, 0, 0);
13545 ret = GetMessageA(&msg, NULL, 0, 0);
13546 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13547 ret = GetMessageA(&msg, NULL, 0, 0);
13548 todo_wine
13549 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13550 ret = GetMessageA(&msg, NULL, 0, 0);
13551 todo_wine
13552 ok(ret && msg.message == WM_USER + 1, "msg.message = %u instead of WM_USER + 1\n", msg.message);
13553 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13554 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13555
13556 /* Also works for posted messages, but the situation is a bit different,
13557 * because both messages are in the same queue. */
13558
13559 PostMessageA(hwnd, WM_TIMER, 0, 0);
13560 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
13561 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13562 PostMessageA(hwnd, WM_USER, 0, 0);
13563 ret = GetMessageA(&msg, NULL, 0, 0);
13564 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13565 ret = GetMessageA(&msg, NULL, 0, 0);
13566 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13567 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13568 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13569
13570 PostMessageA(hwnd, WM_USER, 0, 0);
13571 PostMessageA(hwnd, WM_TIMER, 0, 0);
13572 while (!PeekMessageA(&msg, NULL, WM_TIMER, WM_TIMER, PM_NOREMOVE));
13573 ok(msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13574 ret = GetMessageA(&msg, NULL, 0, 0);
13575 ok(ret && msg.message == WM_USER, "msg.message = %u instead of WM_USER\n", msg.message);
13576 ret = GetMessageA(&msg, NULL, 0, 0);
13577 ok(ret && msg.message == WM_TIMER, "msg.message = %u instead of WM_TIMER\n", msg.message);
13578 ret = PeekMessageA(&msg, NULL, 0, 0, 0);
13579 ok(!ret, "expected PeekMessage to return FALSE, got %u\n", ret);
13580
13581 DestroyWindow(hwnd);
13582 flush_events();
13583 }
13584
13585 static INT_PTR CALLBACK wm_quit_dlg_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
13586 {
13587 struct recvd_message msg;
13588
13589 if (ignore_message( message )) return 0;
13590
13591 msg.hwnd = hwnd;
13592 msg.message = message;
13593 msg.flags = sent|wparam|lparam;
13594 msg.wParam = wp;
13595 msg.lParam = lp;
13596 msg.descr = "dialog";
13597 add_message(&msg);
13598
13599 switch (message)
13600 {
13601 case WM_INITDIALOG:
13602 PostMessageA(hwnd, WM_QUIT, 0x1234, 0x5678);
13603 PostMessageA(hwnd, WM_USER, 0xdead, 0xbeef);
13604 return 0;
13605
13606 case WM_GETDLGCODE:
13607 return 0;
13608
13609 case WM_USER:
13610 EndDialog(hwnd, 0);
13611 break;
13612 }
13613
13614 return 1;
13615 }
13616
13617 static const struct message WmQuitDialogSeq[] = {
13618 { HCBT_CREATEWND, hook },
13619 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
13620 { WM_SETFONT, sent },
13621 { WM_INITDIALOG, sent },
13622 { WM_CHANGEUISTATE, sent|optional },
13623 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
13624 { HCBT_DESTROYWND, hook },
13625 { 0x0090, sent|optional }, /* Vista */
13626 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
13627 { WM_DESTROY, sent },
13628 { WM_NCDESTROY, sent },
13629 { 0 }
13630 };
13631
13632 static const struct message WmStopQuitSeq[] = {
13633 { WM_DWMNCRENDERINGCHANGED, posted|optional },
13634 { WM_CLOSE, posted },
13635 { WM_QUIT, posted|wparam|lparam, 0x1234, 0 },
13636 { 0 }
13637 };
13638
13639 static void test_quit_message(void)
13640 {
13641 MSG msg;
13642 BOOL ret;
13643
13644 /* test using PostQuitMessage */
13645 flush_events();
13646 PostQuitMessage(0xbeef);
13647
13648 msg.message = 0;
13649 ret = PeekMessageA(&msg, 0, 0, 0, PM_QS_SENDMESSAGE);
13650 ok(!ret, "got %x message\n", msg.message);
13651
13652 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
13653 ok(ret, "PeekMessage failed with error %ld\n", GetLastError());
13654 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
13655 ok(msg.wParam == 0xbeef, "wParam was 0x%Ix instead of 0xbeef\n", msg.wParam);
13656
13657 ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
13658 ok(ret, "PostMessage failed with error %ld\n", GetLastError());
13659
13660 ret = GetMessageA(&msg, NULL, 0, 0);
13661 ok(ret > 0, "GetMessage failed with error %ld\n", GetLastError());
13662 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
13663
13664 /* note: WM_QUIT message received after WM_USER message */
13665 ret = GetMessageA(&msg, NULL, 0, 0);
13666 ok(!ret, "GetMessage return %d with error %ld instead of FALSE\n", ret, GetLastError());
13667 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
13668 ok(msg.wParam == 0xbeef, "wParam was 0x%Ix instead of 0xbeef\n", msg.wParam);
13669
13670 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
13671 ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
13672
13673 /* now test with PostThreadMessage - different behaviour! */
13674 PostThreadMessageA(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
13675
13676 ret = PeekMessageA(&msg, NULL, 0, 0, PM_NOREMOVE);
13677 ok(ret, "PeekMessage failed with error %ld\n", GetLastError());
13678 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
13679 ok(msg.wParam == 0xdead, "wParam was 0x%Ix instead of 0xdead\n", msg.wParam);
13680
13681 ret = PostThreadMessageA(GetCurrentThreadId(), WM_USER, 0, 0);
13682 ok(ret, "PostMessage failed with error %ld\n", GetLastError());
13683
13684 /* note: we receive the WM_QUIT message first this time */
13685 ret = GetMessageA(&msg, NULL, 0, 0);
13686 ok(!ret, "GetMessage return %d with error %ld instead of FALSE\n", ret, GetLastError());
13687 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
13688 ok(msg.wParam == 0xdead, "wParam was 0x%Ix instead of 0xdead\n", msg.wParam);
13689
13690 ret = GetMessageA(&msg, NULL, 0, 0);
13691 ok(ret > 0, "GetMessage failed with error %ld\n", GetLastError());
13692 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
13693
13694 flush_events();
13695 flush_sequence();
13696 ret = DialogBoxParamA(GetModuleHandleA(NULL), "TEST_EMPTY_DIALOG", 0, wm_quit_dlg_proc, 0);
13697 ok(ret == 1, "expected 1, got %d\n", ret);
13698 ok_sequence(WmQuitDialogSeq, "WmQuitDialogSeq", FALSE);
13699 memset(&msg, 0xab, sizeof(msg));
13700 ret = PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE);
13701 ok(ret, "PeekMessage failed\n");
13702 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
13703 ok(msg.wParam == 0x1234, "wParam was 0x%Ix instead of 0x1234\n", msg.wParam);
13704 ok(msg.lParam == 0, "lParam was 0x%Ix instead of 0\n", msg.lParam);
13705
13706 /* Check what happens to a WM_QUIT message posted to a window that gets
13707 * destroyed.
13708 */
13709 CreateWindowExA(0, "StopQuitClass", "Stop Quit Test", WS_OVERLAPPEDWINDOW,
13710 0, 0, 100, 100, NULL, NULL, NULL, NULL);
13711 flush_sequence();
13712 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13713 {
13714 struct recvd_message rmsg;
13715 rmsg.hwnd = msg.hwnd;
13716 rmsg.message = msg.message;
13717 rmsg.flags = posted|wparam|lparam;
13718 rmsg.wParam = msg.wParam;
13719 rmsg.lParam = msg.lParam;
13720 rmsg.descr = "stop/quit";
13721 if (msg.message == WM_QUIT)
13722 /* The hwnd can only be checked here */
13723 ok(!msg.hwnd, "The WM_QUIT hwnd was %p instead of NULL\n", msg.hwnd);
13724 add_message(&rmsg);
13725 DispatchMessageA(&msg);
13726 }
13727 ok_sequence(WmStopQuitSeq, "WmStopQuitSeq", FALSE);
13728 }
13729
13730 static const struct message WmNotifySeq[] = {
13731 { WM_NOTIFY, sent|wparam|lparam, 0x1234, 0xdeadbeef },
13732 { 0 }
13733 };
13734
13735 static void test_notify_message(void)
13736 {
13737 HWND hwnd;
13738 BOOL ret;
13739 MSG msg;
13740
13741 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
13742 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0, NULL, NULL, 0);
13743 ok(hwnd != 0, "Failed to create window\n");
13744 flush_events();
13745 flush_sequence();
13746
13747 ret = SendNotifyMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
13748 ok(ret == TRUE, "SendNotifyMessageA failed with error %lu\n", GetLastError());
13749 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13750
13751 ret = SendNotifyMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
13752 ok(ret == TRUE, "SendNotifyMessageW failed with error %lu\n", GetLastError());
13753 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13754
13755 ret = SendMessageCallbackA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
13756 ok(ret == TRUE, "SendMessageCallbackA failed with error %lu\n", GetLastError());
13757 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13758
13759 ret = SendMessageCallbackW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef, NULL, 0);
13760 ok(ret == TRUE, "SendMessageCallbackW failed with error %lu\n", GetLastError());
13761 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13762
13763 ret = PostMessageA(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
13764 ok(ret == TRUE, "PostMessageA failed with error %lu\n", GetLastError());
13765 flush_events();
13766 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13767
13768 ret = PostMessageW(hwnd, WM_NOTIFY, 0x1234, 0xdeadbeef);
13769 ok(ret == TRUE, "PostMessageW failed with error %lu\n", GetLastError());
13770 flush_events();
13771 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13772
13773 ret = PostThreadMessageA(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
13774 ok(ret == TRUE, "PostThreadMessageA failed with error %lu\n", GetLastError());
13775 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13776 {
13777 msg.hwnd = hwnd;
13778 DispatchMessageA(&msg);
13779 }
13780 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13781
13782 ret = PostThreadMessageW(GetCurrentThreadId(), WM_NOTIFY, 0x1234, 0xdeadbeef);
13783 ok(ret == TRUE, "PostThreadMessageW failed with error %lu\n", GetLastError());
13784 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13785 {
13786 msg.hwnd = hwnd;
13787 DispatchMessageA(&msg);
13788 }
13789 ok_sequence(WmNotifySeq, "WmNotifySeq", FALSE);
13790
13791 DestroyWindow(hwnd);
13792 }
13793
13794 static const struct message WmMouseHoverSeq[] = {
13795 { WM_GETMINMAXINFO, sent|optional }, /* sometimes seen on w1064v1809 */
13796 { WM_MOUSEACTIVATE, sent|optional }, /* we can get those when moving the mouse in focus-follow-mouse mode under X11 */
13797 { WM_MOUSEACTIVATE, sent|optional },
13798 { WM_TIMER, sent|optional }, /* XP sends it */
13799 { WM_SYSTIMER, sent },
13800 { WM_MOUSEHOVER, sent|wparam, 0 },
13801 { 0 }
13802 };
13803
13804 static void pump_msg_loop_timeout(DWORD timeout, BOOL inject_mouse_move)
13805 {
13806 MSG msg;
13807 DWORD start_ticks, end_ticks;
13808
13809 start_ticks = GetTickCount();
13810 /* add some deviation (50%) to cover not expected delays */
13811 start_ticks += timeout / 2;
13812
13813 do
13814 {
13815 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
13816 {
13817 /* Timer proc messages are not dispatched to the window proc,
13818 * and therefore not logged.
13819 */
13820 if ((msg.message == WM_TIMER || msg.message == WM_SYSTIMER) && msg.hwnd)
13821 {
13822 struct recvd_message s_msg;
13823
13824 s_msg.hwnd = msg.hwnd;
13825 s_msg.message = msg.message;
13826 s_msg.flags = sent|wparam|lparam;
13827 s_msg.wParam = msg.wParam;
13828 s_msg.lParam = msg.lParam;
13829 s_msg.descr = "msg_loop";
13830 add_message(&s_msg);
13831 }
13832 DispatchMessageA(&msg);
13833 }
13834
13835 end_ticks = GetTickCount();
13836
13837 /* inject WM_MOUSEMOVE to see how it changes tracking */
13838 if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
13839 {
13840 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
13841 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
13842
13843 inject_mouse_move = FALSE;
13844 }
13845 } while (start_ticks + timeout >= end_ticks);
13846 }
13847
13848 static void test_TrackMouseEvent(void)
13849 {
13850 TRACKMOUSEEVENT tme;
13851 BOOL ret;
13852 HWND hwnd, hchild;
13853 RECT rc_parent, rc_child;
13854 UINT default_hover_time, hover_width = 0, hover_height = 0;
13855
13856 #define track_hover(track_hwnd, track_hover_time) \
13857 tme.cbSize = sizeof(tme); \
13858 tme.dwFlags = TME_HOVER; \
13859 tme.hwndTrack = track_hwnd; \
13860 tme.dwHoverTime = track_hover_time; \
13861 SetLastError(0xdeadbeef); \
13862 ret = pTrackMouseEvent(&tme); \
13863 ok(ret, "TrackMouseEvent(TME_HOVER) error %ld\n", GetLastError())
13864
13865 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
13866 tme.cbSize = sizeof(tme); \
13867 tme.dwFlags = TME_QUERY; \
13868 tme.hwndTrack = (HWND)0xdeadbeef; \
13869 tme.dwHoverTime = 0xdeadbeef; \
13870 SetLastError(0xdeadbeef); \
13871 ret = pTrackMouseEvent(&tme); \
13872 ok(ret, "TrackMouseEvent(TME_QUERY) error %ld\n", GetLastError());\
13873 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %lu\n", tme.cbSize); \
13874 ok(tme.dwFlags == (expected_track_flags), \
13875 "wrong tme.dwFlags %08lx, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
13876 ok(tme.hwndTrack == (expected_track_hwnd), \
13877 "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
13878 ok(tme.dwHoverTime == (expected_hover_time), \
13879 "wrong tme.dwHoverTime %lu, expected %u\n", tme.dwHoverTime, (expected_hover_time))
13880
13881 #define track_hover_cancel(track_hwnd) \
13882 tme.cbSize = sizeof(tme); \
13883 tme.dwFlags = TME_HOVER | TME_CANCEL; \
13884 tme.hwndTrack = track_hwnd; \
13885 tme.dwHoverTime = 0xdeadbeef; \
13886 SetLastError(0xdeadbeef); \
13887 ret = pTrackMouseEvent(&tme); \
13888 ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %ld\n", GetLastError())
13889
13890 default_hover_time = 0xdeadbeef;
13891 SetLastError(0xdeadbeef);
13892 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERTIME, 0, &default_hover_time, 0);
13893 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
13894 "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %lu\n", GetLastError());
13895 if (!ret) default_hover_time = 400;
13896 if (winetest_debug > 1) trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time);
13897
13898 SetLastError(0xdeadbeef);
13899 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0);
13900 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
13901 "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %lu\n", GetLastError());
13902 if (!ret) hover_width = 4;
13903 SetLastError(0xdeadbeef);
13904 ret = SystemParametersInfoA(SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0);
13905 ok(ret || broken(GetLastError() == 0xdeadbeef), /* win9x */
13906 "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %lu\n", GetLastError());
13907 if (!ret) hover_height = 4;
13908 if (winetest_debug > 1) trace("hover rect is %u x %d\n", hover_width, hover_height);
13909
13910 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
13911 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
13912 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
13913 NULL, NULL, 0);
13914 assert(hwnd);
13915
13916 hchild = CreateWindowExA(0, "TestWindowClass", NULL,
13917 WS_CHILD | WS_BORDER | WS_VISIBLE,
13918 50, 50, 200, 200, hwnd,
13919 NULL, NULL, 0);
13920 assert(hchild);
13921
13922 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE );
13923 flush_events();
13924 flush_sequence();
13925
13926 tme.cbSize = 0;
13927 tme.dwFlags = TME_QUERY;
13928 tme.hwndTrack = (HWND)0xdeadbeef;
13929 tme.dwHoverTime = 0xdeadbeef;
13930 SetLastError(0xdeadbeef);
13931 ret = pTrackMouseEvent(&tme);
13932 ok(!ret, "TrackMouseEvent should fail\n");
13933 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef),
13934 "not expected error %lu\n", GetLastError());
13935
13936 tme.cbSize = sizeof(tme);
13937 tme.dwFlags = TME_HOVER;
13938 tme.hwndTrack = (HWND)0xdeadbeef;
13939 tme.dwHoverTime = 0xdeadbeef;
13940 SetLastError(0xdeadbeef);
13941 ret = pTrackMouseEvent(&tme);
13942 ok(!ret, "TrackMouseEvent should fail\n");
13943 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
13944 "not expected error %lu\n", GetLastError());
13945
13946 tme.cbSize = sizeof(tme);
13947 tme.dwFlags = TME_HOVER | TME_CANCEL;
13948 tme.hwndTrack = (HWND)0xdeadbeef;
13949 tme.dwHoverTime = 0xdeadbeef;
13950 SetLastError(0xdeadbeef);
13951 ret = pTrackMouseEvent(&tme);
13952 ok(!ret, "TrackMouseEvent should fail\n");
13953 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
13954 "not expected error %lu\n", GetLastError());
13955
13956 GetWindowRect(hwnd, &rc_parent);
13957 GetWindowRect(hchild, &rc_child);
13958 SetCursorPos(rc_child.left - 10, rc_child.top - 10);
13959
13960 /* Process messages so that the system updates its internal current
13961 * window and hittest, otherwise TrackMouseEvent calls don't have any
13962 * effect.
13963 */
13964 flush_events();
13965 flush_sequence();
13966
13967 track_query(0, NULL, 0);
13968 track_hover(hchild, 0);
13969 track_query(0, NULL, 0);
13970
13971 flush_events();
13972 flush_sequence();
13973
13974 track_hover(hwnd, 0);
13975 tme.cbSize = sizeof(tme);
13976 tme.dwFlags = TME_QUERY;
13977 tme.hwndTrack = (HWND)0xdeadbeef;
13978 tme.dwHoverTime = 0xdeadbeef;
13979 SetLastError(0xdeadbeef);
13980 ret = pTrackMouseEvent(&tme);
13981 ok(ret, "TrackMouseEvent(TME_QUERY) error %ld\n", GetLastError());
13982 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %lu\n", tme.cbSize);
13983 if (!tme.dwFlags)
13984 {
13985 skip( "Cursor not inside window, skipping TrackMouseEvent tests\n" );
13986 DestroyWindow( hwnd );
13987 return;
13988 }
13989 ok(tme.dwFlags == TME_HOVER, "wrong tme.dwFlags %08lx, expected TME_HOVER\n", tme.dwFlags);
13990 ok(tme.hwndTrack == hwnd, "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, hwnd);
13991 ok(tme.dwHoverTime == default_hover_time, "wrong tme.dwHoverTime %lu, expected %u\n",
13992 tme.dwHoverTime, default_hover_time);
13993
13994 pump_msg_loop_timeout(default_hover_time, FALSE);
13995 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
13996
13997 track_query(0, NULL, 0);
13998
13999 track_hover(hwnd, HOVER_DEFAULT);
14000 track_query(TME_HOVER, hwnd, default_hover_time);
14001
14002 Sleep(default_hover_time / 2);
14003 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
14004 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
14005
14006 track_query(TME_HOVER, hwnd, default_hover_time);
14007
14008 pump_msg_loop_timeout(default_hover_time, FALSE);
14009 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
14010
14011 track_query(0, NULL, 0);
14012
14013 track_hover(hwnd, HOVER_DEFAULT);
14014 track_query(TME_HOVER, hwnd, default_hover_time);
14015
14016 pump_msg_loop_timeout(default_hover_time, TRUE);
14017 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
14018
14019 track_query(0, NULL, 0);
14020
14021 track_hover(hwnd, HOVER_DEFAULT);
14022 track_query(TME_HOVER, hwnd, default_hover_time);
14023 track_hover_cancel(hwnd);
14024
14025 DestroyWindow(hwnd);
14026
14027 #undef track_hover
14028 #undef track_query
14029 #undef track_hover_cancel
14030 }
14031
14032
14033 static const struct message WmSetWindowRgn[] = {
14034 { WM_WINDOWPOSCHANGING, sent|wparam|lparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE
14035 |SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE, 0 },
14036 { WM_NCCALCSIZE, sent|wparam, 1 },
14037 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
14038 { WM_GETTEXT, sent|defwinproc|optional },
14039 { WM_ERASEBKGND, sent|optional },
14040 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
14041 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14042 { 0 }
14043 };
14044
14045 static const struct message WmSetWindowRgn_no_redraw[] = {
14046 { WM_WINDOWPOSCHANGING, sent|wparam|lparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE
14047 |SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW, 0 },
14048 { WM_NCCALCSIZE, sent|wparam, 1 },
14049 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
14050 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14051 { 0 }
14052 };
14053
14054 static const struct message WmSetWindowRgn_clear[] = {
14055 { WM_WINDOWPOSCHANGING, sent/*|wparam|lparam*/, SWP_NOACTIVATE|SWP_FRAMECHANGED
14056 |SWP_NOSIZE|SWP_NOMOVE/*|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE only on some Windows versions */
14057 /* Some newer Windows versions set window coordinates instead of zeros in WINDOWPOS structure */},
14058 { WM_NCCALCSIZE, sent|wparam, 1 },
14059 { WM_NCPAINT, sent|optional },
14060 { WM_GETTEXT, sent|defwinproc|optional },
14061 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
14062 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
14063 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
14064 { WM_NCPAINT, sent|optional },
14065 { WM_GETTEXT, sent|defwinproc|optional },
14066 { WM_ERASEBKGND, sent|optional },
14067 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14068 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14069 { WM_WINDOWPOSCHANGING, sent|optional },
14070 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
14071 { WM_NCPAINT, sent|optional },
14072 { WM_GETTEXT, sent|defwinproc|optional },
14073 { WM_ERASEBKGND, sent|optional },
14074 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
14075 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
14076 { WM_NCPAINT, sent|optional },
14077 { WM_GETTEXT, sent|defwinproc|optional },
14078 { WM_ERASEBKGND, sent|optional },
14079 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14080 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Not always sent. */
14081 { 0 }
14082 };
14083
14084 static void test_SetWindowRgn(void)
14085 {
14086 HRGN hrgn;
14087 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
14088 100, 100, 200, 200, 0, 0, 0, NULL);
14089 ok( hwnd != 0, "Failed to create overlapped window\n" );
14090
14091 ShowWindow( hwnd, SW_SHOW );
14092 UpdateWindow( hwnd );
14093 flush_events();
14094 flush_sequence();
14095
14096 if (winetest_debug > 1) trace("testing SetWindowRgn\n");
14097 hrgn = CreateRectRgn( 0, 0, 150, 150 );
14098 SetWindowRgn( hwnd, hrgn, TRUE );
14099 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn", FALSE );
14100
14101 hrgn = CreateRectRgn( 30, 30, 160, 160 );
14102 SetWindowRgn( hwnd, hrgn, FALSE );
14103 ok_sequence( WmSetWindowRgn_no_redraw, "WmSetWindowRgn_no_redraw", FALSE );
14104
14105 hrgn = CreateRectRgn( 0, 0, 180, 180 );
14106 SetWindowRgn( hwnd, hrgn, TRUE );
14107 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn2", FALSE );
14108
14109 SetWindowRgn( hwnd, 0, TRUE );
14110 ok_sequence( WmSetWindowRgn_clear, "WmSetWindowRgn_clear", FALSE );
14111
14112 DestroyWindow( hwnd );
14113 }
14114
14115 /*************************** ShowWindow() test ******************************/
14116 static const struct message WmShowNormal[] = {
14117 { WM_SHOWWINDOW, sent|wparam, 1 },
14118 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14119 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14120 { HCBT_ACTIVATE, hook },
14121 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14122 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
14123 { HCBT_SETFOCUS, hook },
14124 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
14125 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14126 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends it, but Win8+ doesn't. */
14127 { 0 }
14128 };
14129 static const struct message WmShow[] = {
14130 { WM_SHOWWINDOW, sent|wparam, 1 },
14131 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14132 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14133 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
14134 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
14135 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
14136 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14137 { 0 }
14138 };
14139 static const struct message WmShowNoActivate_1[] = {
14140 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
14141 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14142 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14143 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14144 { WM_MOVE, sent|defwinproc|optional },
14145 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
14146 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14147 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14148 { 0 }
14149 };
14150 static const struct message WmShowNoActivate_2[] = {
14151 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
14152 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
14153 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14154 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14155 { HCBT_ACTIVATE, hook|optional },
14156 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends this. */
14157 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14158 { WM_WINDOWPOSCHANGED, sent|optional }, /* Sometimes sent on Win8+. */
14159 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
14160 { HCBT_SETFOCUS, hook|optional },
14161 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 }, /* Win7 sends this. */
14162 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
14163 { WM_MOVE, sent|defwinproc },
14164 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
14165 { HCBT_SETFOCUS, hook|optional },
14166 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
14167 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
14168 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14169 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
14170 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14171 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14172 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14173 { 0 }
14174 };
14175 static const struct message WmShowNA_1[] = {
14176 { WM_SHOWWINDOW, sent|wparam, 1 },
14177 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
14178 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14179 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14180 { 0 }
14181 };
14182 static const struct message WmShowNA_2[] = {
14183 { WM_SHOWWINDOW, sent|wparam, 1 },
14184 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
14185 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14186 { 0 }
14187 };
14188 static const struct message WmRestore_1[] = {
14189 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
14190 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14191 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14192 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14193 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
14194 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
14195 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
14196 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14197 { WM_MOVE, sent|defwinproc },
14198 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
14199 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14200 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14201 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14202 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
14203 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
14204 { 0 }
14205 };
14206 static const struct message WmRestore_2[] = {
14207 { WM_SHOWWINDOW, sent|wparam, 1 },
14208 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14209 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14210 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
14211 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
14212 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
14213 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14214 { 0 }
14215 };
14216 static const struct message WmRestore_3[] = {
14217 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
14218 { WM_GETMINMAXINFO, sent },
14219 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14220 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14221 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
14222 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14223 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
14224 { WM_WINDOWPOSCHANGED, sent|optional }, /* Win8+ sometimes sends this. */
14225 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
14226 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
14227 { WM_WINDOWPOSCHANGED, sent|optional },
14228 { WM_MOVE, sent|defwinproc },
14229 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
14230 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
14231 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14232 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14233 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14234 { 0 }
14235 };
14236 static const struct message WmRestore_4[] = {
14237 { HCBT_MINMAX, hook|lparam|optional, 0, SW_RESTORE },
14238 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14239 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14240 { WM_MOVE, sent|defwinproc|optional },
14241 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_RESTORED },
14242 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14243 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14244 { 0 }
14245 };
14246 static const struct message WmRestore_5[] = {
14247 { HCBT_MINMAX, hook|lparam|optional, 0, SW_SHOWNORMAL },
14248 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14249 { HCBT_ACTIVATE, hook|optional },
14250 { HCBT_SETFOCUS, hook|optional },
14251 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14252 { WM_MOVE, sent|defwinproc|optional },
14253 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_RESTORED },
14254 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
14255 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14256 { 0 }
14257 };
14258 static const struct message WmHide_1[] = {
14259 { WM_SHOWWINDOW, sent|wparam, 0 },
14260 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE, 0, SWP_NOACTIVATE },
14261 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14262 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0, SWP_NOACTIVATE },
14263 { HCBT_ACTIVATE, hook|optional },
14264 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
14265 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
14266 { 0 }
14267 };
14268 static const struct message WmHide_2[] = {
14269 { WM_SHOWWINDOW, sent|wparam, 0 },
14270 { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
14271 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14272 { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
14273 { HCBT_ACTIVATE, hook|optional },
14274 { 0 }
14275 };
14276 static const struct message WmHide_3[] = {
14277 { WM_SHOWWINDOW, sent|wparam, 0 },
14278 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
14279 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14280 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14281 { HCBT_SETFOCUS, hook|optional },
14282 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
14283 { 0 }
14284 };
14285 static const struct message WmShowMinimized_1[] = {
14286 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
14287 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14288 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14289 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14290 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
14291 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
14292 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14293 { WM_MOVE, sent|defwinproc },
14294 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
14295 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14296 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14297 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14298 { 0 }
14299 };
14300 static const struct message WmMinimize_1[] = {
14301 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
14302 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
14303 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
14304 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14305 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14306 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14307 { WM_MOVE, sent|defwinproc },
14308 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
14309 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14310 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14311 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14312 { 0 }
14313 };
14314 static const struct message WmMinimize_2[] = {
14315 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
14316 { HCBT_SETFOCUS, hook|optional },
14317 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
14318 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14319 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
14320 { WM_MOVE, sent|defwinproc },
14321 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
14322 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14323 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14324 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14325 { 0 }
14326 };
14327 static const struct message WmMinimize_3[] = {
14328 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
14329 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED, 0, SWP_NOACTIVATE },
14330 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14331 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14332 { HCBT_ACTIVATE, hook|optional },
14333 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sometimes sent on Win8/10. */
14334 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14335 { WM_WINDOWPOSCHANGED, sent|optional },
14336 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sometimes sent on Win7. */
14337 { WM_WINDOWPOSCHANGED, sent|optional },
14338 { WM_MOVE, sent|defwinproc },
14339 { WM_SIZE, sent|wparam|lparam|defwinproc, SIZE_MINIMIZED, 0 },
14340 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14341 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14342 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14343 { 0 }
14344 };
14345 static const struct message WmShowMinNoActivate[] = {
14346 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
14347 { WM_WINDOWPOSCHANGING, sent },
14348 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14349 { WM_WINDOWPOSCHANGED, sent },
14350 { WM_MOVE, sent|defwinproc|optional },
14351 { WM_SIZE, sent|wparam|lparam|defwinproc|optional, SIZE_MINIMIZED, 0 },
14352 { 0 }
14353 };
14354 static const struct message WmMinMax_1[] = {
14355 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
14356 { 0 }
14357 };
14358 static const struct message WmMinMax_2[] = {
14359 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
14360 { WM_GETMINMAXINFO, sent|optional },
14361 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED },
14362 { HCBT_ACTIVATE, hook|optional },
14363 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14364 { HCBT_SETFOCUS, hook|optional },
14365 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14366 { WM_MOVE, sent|defwinproc|optional },
14367 { WM_SIZE, sent|wparam|defwinproc|optional, SIZE_MAXIMIZED },
14368 { HCBT_SETFOCUS, hook|optional },
14369 { 0 }
14370 };
14371 static const struct message WmMinMax_3[] = {
14372 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
14373 { HCBT_SETFOCUS, hook|optional },
14374 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14375 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14376 { WM_MOVE, sent|defwinproc|optional },
14377 { WM_SIZE, sent|wparam|lparam|defwinproc|optional, SIZE_MINIMIZED, 0 },
14378 { 0 }
14379 };
14380 static const struct message WmMinMax_4[] = {
14381 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
14382 { 0 }
14383 };
14384 static const struct message WmShowMaximized_1[] = {
14385 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
14386 { WM_GETMINMAXINFO, sent },
14387 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14388 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14389 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14390 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
14391 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
14392 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
14393 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14394 { WM_MOVE, sent|defwinproc },
14395 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
14396 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14397 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14398 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14399 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
14400 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
14401 { 0 }
14402 };
14403 static const struct message WmShowMaximized_2[] = {
14404 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
14405 { WM_GETMINMAXINFO, sent },
14406 { WM_WINDOWPOSCHANGING, sent|optional },
14407 { HCBT_ACTIVATE, hook|optional },
14408 { WM_WINDOWPOSCHANGED, sent|optional },
14409 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
14410 { WM_MOVE, sent|optional }, /* Win9x doesn't send it */
14411 { WM_SIZE, sent|wparam|optional, SIZE_MAXIMIZED }, /* Win9x doesn't send it */
14412 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 sends this. */
14413 { WM_WINDOWPOSCHANGING, sent|optional },
14414 { HCBT_SETFOCUS, hook|optional },
14415 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
14416 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
14417 { WM_MOVE, sent|defwinproc },
14418 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
14419 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14420 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14421 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14422 { HCBT_SETFOCUS, hook|optional },
14423 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
14424 { 0 }
14425 };
14426 static const struct message WmShowMaximized_3[] = {
14427 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
14428 { WM_GETMINMAXINFO, sent|optional },
14429 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14430 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
14431 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
14432 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
14433 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED, 0, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOSIZE|SWP_NOMOVE },
14434 { WM_MOVE, sent|defwinproc|optional },
14435 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
14436 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14437 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
14438 { 0 }
14439 };
14440
14441 static void test_ShowWindow(void)
14442 {
14443 /* ShowWindow commands in random order */
14444 static const struct
14445 {
14446 INT cmd; /* ShowWindow command */
14447 LPARAM ret; /* ShowWindow return value */
14448 DWORD style; /* window style after the command */
14449 const struct message *msg; /* message sequence the command produces */
14450 INT wp_cmd, wp_flags; /* window placement after the command */
14451 POINT wp_min, wp_max; /* window placement after the command */
14452 BOOL todo_msg; /* message sequence doesn't match what Wine does */
14453 } sw[] =
14454 {
14455 /* 1 */ { SW_SHOWNORMAL, FALSE, WS_VISIBLE, WmShowNormal,
14456 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
14457 /* 2 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq,
14458 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
14459 /* 3 */ { SW_HIDE, TRUE, 0, WmHide_1,
14460 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
14461 /* 4 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
14462 SW_SHOWNORMAL, 0, {-1,-1}, {-1,-1}, FALSE },
14463 /* 5 */ { SW_SHOWMINIMIZED, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinimized_1,
14464 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14465 /* 6 */ { SW_SHOWMINIMIZED, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_1,
14466 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14467 /* 7 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_1,
14468 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14469 /* 8 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
14470 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14471 /* 9 */ { SW_SHOWMAXIMIZED, FALSE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_1,
14472 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14473 /* 10 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2,
14474 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14475 /* 11 */ { SW_HIDE, TRUE, WS_MAXIMIZE, WmHide_1,
14476 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14477 /* 12 */ { SW_HIDE, FALSE, WS_MAXIMIZE, WmEmptySeq,
14478 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14479 /* 13 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_1,
14480 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14481 /* 14 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq,
14482 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14483 /* 15 */ { SW_HIDE, TRUE, 0, WmHide_2,
14484 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14485 /* 16 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
14486 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14487 /* 17 */ { SW_SHOW, FALSE, WS_VISIBLE, WmShow,
14488 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14489 /* 18 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq,
14490 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14491 /* 19 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1,
14492 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14493 /* 20 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
14494 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14495 /* 21 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
14496 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14497 /* 22 */ { SW_SHOWMINNOACTIVE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinNoActivate,
14498 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, TRUE },
14499 /* 23 */ { SW_SHOWMINNOACTIVE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_4,
14500 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14501 /* 24 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
14502 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14503 /* 25 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
14504 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14505 /* 26 */ { SW_SHOWNA, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_1,
14506 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14507 /* 27 */ { SW_SHOWNA, TRUE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_2,
14508 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14509 /* 28 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
14510 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14511 /* 29 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq,
14512 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14513 /* 30 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_1,
14514 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14515 /* 31 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq,
14516 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14517 /* 32 */ { SW_HIDE, TRUE, 0, WmHide_3,
14518 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14519 /* 33 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
14520 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14521 /* 34 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, /* what does this mean?! */
14522 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14523 /* 35 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq,
14524 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14525 /* 36 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
14526 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14527 /* 37 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_2,
14528 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14529 /* 38 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq,
14530 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14531 /* 39 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq,
14532 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14533 /* 40 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_2,
14534 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14535 /* 41 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
14536 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14537 /* 42 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_2,
14538 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14539 /* 43 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2,
14540 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14541 /* 44 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1,
14542 SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14543 /* 45 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3,
14544 SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14545 /* 46 */ { SW_RESTORE, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmRestore_3,
14546 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14547 /* 47 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmRestore_4,
14548 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14549 /* 48 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_3,
14550 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14551 /* 49 */ { SW_SHOW, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmEmptySeq,
14552 SW_SHOWMAXIMIZED, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14553 /* 50 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5,
14554 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14555 /* 51 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5,
14556 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14557 /* 52 */ { SW_HIDE, TRUE, 0, WmHide_1,
14558 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14559 /* 53 */ { SW_HIDE, FALSE, 0, WmEmptySeq,
14560 SW_SHOWNORMAL, WPF_RESTORETOMAXIMIZED, {-32000,-32000}, {-1,-1}, FALSE },
14561 /* 54 */ { SW_MINIMIZE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_3,
14562 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14563 /* 55 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2,
14564 SW_SHOWMINIMIZED, 0, {-32000,-32000}, {-1,-1}, FALSE },
14565 /* 56 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_2,
14566 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE },
14567 /* 57 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq,
14568 SW_SHOWNORMAL, 0, {-32000,-32000}, {-1,-1}, FALSE }
14569 };
14570 HWND hwnd;
14571 DWORD style;
14572 LPARAM ret;
14573 INT i;
14574 WINDOWPLACEMENT wp;
14575 RECT win_rc, work_rc = {0, 0, 0, 0};
14576 HMONITOR hmon;
14577 MONITORINFO mi;
14578 POINT pt = {0, 0};
14579
14580 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
14581 hwnd = CreateWindowExA(0, "ShowWindowClass", NULL, WS_BASE,
14582 120, 120, 90, 90,
14583 0, 0, 0, NULL);
14584 assert(hwnd);
14585
14586 style = GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BASE;
14587 ok(style == 0, "expected style 0, got %08lx\n", style);
14588
14589 flush_events();
14590 flush_sequence();
14591
14592 SetLastError(0xdeadbeef);
14593 hmon = MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
14594 ok(hmon != 0, "MonitorFromPoint error %lu\n", GetLastError());
14595
14596 mi.cbSize = sizeof(mi);
14597 SetLastError(0xdeadbeef);
14598 ret = GetMonitorInfoA(hmon, &mi);
14599 ok(ret, "GetMonitorInfo error %lu\n", GetLastError());
14600 if (winetest_debug > 1) trace("monitor %s, work %s\n", wine_dbgstr_rect(&mi.rcMonitor),
14601 wine_dbgstr_rect(&mi.rcWork));
14602 work_rc = mi.rcWork;
14603
14604 GetWindowRect(hwnd, &win_rc);
14605 OffsetRect(&win_rc, -work_rc.left, -work_rc.top);
14606
14607 wp.length = sizeof(wp);
14608 SetLastError(0xdeadbeaf);
14609 ret = GetWindowPlacement(hwnd, &wp);
14610 ok(ret, "GetWindowPlacement error %lu\n", GetLastError());
14611 ok(wp.flags == 0, "expected 0, got %#x\n", wp.flags);
14612 ok(wp.showCmd == SW_SHOWNORMAL, "expected SW_SHOWNORMAL, got %d\n", wp.showCmd);
14613 ok(wp.ptMinPosition.x == -1 && wp.ptMinPosition.y == -1,
14614 "expected -1,-1 got %ld,%ld\n", wp.ptMinPosition.x, wp.ptMinPosition.y);
14615 ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1,
14616 "expected -1,-1 got %ld,%ld\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y);
14617 todo_wine_if (work_rc.left || work_rc.top) /* FIXME: remove once Wine is fixed */
14618 ok(EqualRect(&win_rc, &wp.rcNormalPosition), "expected %s got %s\n", wine_dbgstr_rect(&win_rc),
14619 wine_dbgstr_rect(&wp.rcNormalPosition));
14620
14621 for (i = 0; i < ARRAY_SIZE(sw); i++)
14622 {
14623 static const char * const sw_cmd_name[13] =
14624 {
14625 "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
14626 "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
14627 "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
14628 "SW_NORMALNA" /* 0xCC */
14629 };
14630 char comment[64];
14631 INT idx; /* index into the above array of names */
14632
14633 idx = (sw[i].cmd == SW_NORMALNA) ? 12 : sw[i].cmd;
14634
14635 style = GetWindowLongA(hwnd, GWL_STYLE);
14636 if (winetest_debug > 1) trace("%d: sending %s, current window style %08lx\n", i+1, sw_cmd_name[idx], style);
14637 ret = ShowWindow(hwnd, sw[i].cmd);
14638 ok(!ret == !sw[i].ret, "%d: cmd %s: expected ret %Iu, got %Iu\n", i+1, sw_cmd_name[idx], sw[i].ret, ret);
14639 style = GetWindowLongA(hwnd, GWL_STYLE) & ~WS_BASE;
14640 ok(style == sw[i].style, "%d: expected style %08lx, got %08lx\n", i+1, sw[i].style, style);
14641
14642 sprintf(comment, "%d: ShowWindow(%s)", i+1, sw_cmd_name[idx]);
14643 ok_sequence(sw[i].msg, comment, sw[i].todo_msg);
14644
14645 wp.length = sizeof(wp);
14646 SetLastError(0xdeadbeaf);
14647 ret = GetWindowPlacement(hwnd, &wp);
14648 ok(ret, "GetWindowPlacement error %lu\n", GetLastError());
14649 ok(wp.flags == sw[i].wp_flags, "expected %#x, got %#x\n", sw[i].wp_flags, wp.flags);
14650 ok(wp.showCmd == sw[i].wp_cmd, "expected %d, got %d\n", sw[i].wp_cmd, wp.showCmd);
14651
14652 /* NT moves the minimized window to -32000,-32000, win9x to 3000,3000 */
14653 if ((wp.ptMinPosition.x + work_rc.left == -32000 && wp.ptMinPosition.y + work_rc.top == -32000) ||
14654 (wp.ptMinPosition.x + work_rc.left == 3000 && wp.ptMinPosition.y + work_rc.top == 3000))
14655 {
14656 ok((wp.ptMinPosition.x + work_rc.left == sw[i].wp_min.x && wp.ptMinPosition.y + work_rc.top == sw[i].wp_min.y) ||
14657 (wp.ptMinPosition.x + work_rc.left == 3000 && wp.ptMinPosition.y + work_rc.top == 3000),
14658 "expected %ld,%ld got %ld,%ld\n", sw[i].wp_min.x, sw[i].wp_min.y, wp.ptMinPosition.x, wp.ptMinPosition.y);
14659 }
14660 else
14661 {
14662 ok(wp.ptMinPosition.x == sw[i].wp_min.x && wp.ptMinPosition.y == sw[i].wp_min.y,
14663 "expected %ld,%ld got %ld,%ld\n", sw[i].wp_min.x, sw[i].wp_min.y, wp.ptMinPosition.x, wp.ptMinPosition.y);
14664 }
14665
14666 todo_wine_if(wp.ptMaxPosition.x != sw[i].wp_max.x || wp.ptMaxPosition.y != sw[i].wp_max.y)
14667 ok(wp.ptMaxPosition.x == sw[i].wp_max.x && wp.ptMaxPosition.y == sw[i].wp_max.y,
14668 "expected %ld,%ld got %ld,%ld\n", sw[i].wp_max.x, sw[i].wp_max.y, wp.ptMaxPosition.x, wp.ptMaxPosition.y);
14669
14670 if (0) /* FIXME: Wine behaves completely different here */
14671 ok(EqualRect(&win_rc, &wp.rcNormalPosition), "expected %s got %s\n",
14672 wine_dbgstr_rect(&win_rc), wine_dbgstr_rect(&wp.rcNormalPosition));
14673 }
14674 DestroyWindow(hwnd);
14675 flush_events();
14676 }
14677
14678 static INT_PTR WINAPI test_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
14679 {
14680 struct recvd_message msg;
14681
14682 if (ignore_message( message )) return 0;
14683
14684 msg.hwnd = hwnd;
14685 msg.message = message;
14686 msg.flags = sent|wparam|lparam;
14687 msg.wParam = wParam;
14688 msg.lParam = lParam;
14689 msg.descr = "dialog";
14690 add_message(&msg);
14691
14692 /* calling DefDlgProc leads to a recursion under XP */
14693
14694 switch (message)
14695 {
14696 case WM_INITDIALOG:
14697 return lParam;
14698
14699 case WM_GETDLGCODE:
14700 return 0;
14701 }
14702 return 1;
14703 }
14704
14705 static WNDPROC orig_edit_proc;
14706 static LRESULT WINAPI dlg_creation_edit_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
14707 {
14708 struct recvd_message msg;
14709
14710 if (ignore_message( message )) return 0;
14711
14712 msg.hwnd = hwnd;
14713 msg.message = message;
14714 msg.flags = sent|wparam|lparam;
14715 msg.wParam = wp;
14716 msg.lParam = lp;
14717 msg.descr = "edit";
14718 add_message(&msg);
14719
14720 return CallWindowProcW(orig_edit_proc, hwnd, message, wp, lp);
14721 }
14722
14723 static INT_PTR WINAPI test_dlg_proc2(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
14724 {
14725 struct recvd_message msg;
14726
14727 if (ignore_message( message )) return 0;
14728
14729 msg.hwnd = hwnd;
14730 msg.message = message;
14731 msg.flags = sent|wparam|lparam|parent;
14732 msg.wParam = wParam;
14733 msg.lParam = lParam;
14734 msg.descr = "dialog";
14735 add_message(&msg);
14736
14737 if (message == WM_INITDIALOG)
14738 {
14739 orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
14740 GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
14741 }
14742
14743 return 1;
14744 }
14745
14746 static INT_PTR WINAPI test_dlg_proc3(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
14747 {
14748 ok( 0, "should not be called since DefDlgProc is not used\n" );
14749 return 0;
14750 }
14751
14752 static LRESULT WINAPI test_dlg_proc4(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
14753 {
14754 struct recvd_message msg;
14755
14756 if (!ignore_message( message ))
14757 {
14758 msg.hwnd = hwnd;
14759 msg.message = message;
14760 msg.flags = sent|wparam|lparam|parent;
14761 msg.wParam = wParam;
14762 msg.lParam = lParam;
14763 msg.descr = "dialog";
14764 add_message(&msg);
14765 }
14766 if (message == WM_INITDIALOG)
14767 {
14768 orig_edit_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwnd, 200),
14769 GWLP_WNDPROC, (LONG_PTR)dlg_creation_edit_proc);
14770 return 1;
14771 }
14772 return DefWindowProcW( hwnd, message, wParam, lParam );
14773 }
14774
14775 static const struct message WmDefDlgSetFocus_1[] = {
14776 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
14777 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
14778 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
14779 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
14780 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
14781 { HCBT_SETFOCUS, hook },
14782 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
14783 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
14784 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
14785 { WM_SETFOCUS, sent|wparam, 0 },
14786 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
14787 { WM_CTLCOLOREDIT, sent },
14788 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
14789 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
14790 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
14791 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
14792 { WM_COMMAND, sent|wparam, MAKEWPARAM(1, EN_SETFOCUS) },
14793 { 0 }
14794 };
14795 static const struct message WmDefDlgSetFocus_2[] = {
14796 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
14797 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
14798 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
14799 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
14800 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
14801 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
14802 { WM_CTLCOLOREDIT, sent|optional }, /* XP */
14803 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CARET, 0 },
14804 { 0 }
14805 };
14806 /* Creation of a dialog */
14807 static const struct message WmCreateDialogParamSeq_0[] = {
14808 { HCBT_CREATEWND, hook },
14809 { WM_NCCREATE, sent },
14810 { WM_NCCALCSIZE, sent|wparam, 0 },
14811 { WM_CREATE, sent },
14812 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14813 { WM_SIZE, sent|wparam, SIZE_RESTORED },
14814 { WM_MOVE, sent },
14815 { WM_SETFONT, sent },
14816 { WM_INITDIALOG, sent },
14817 { WM_CHANGEUISTATE, sent|optional },
14818 { 0 }
14819 };
14820 /* Creation of a dialog */
14821 static const struct message WmCreateDialogParamSeq_1[] = {
14822 { HCBT_CREATEWND, hook },
14823 { WM_NCCREATE, sent },
14824 { WM_NCCALCSIZE, sent|wparam, 0 },
14825 { WM_CREATE, sent },
14826 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14827 { WM_SIZE, sent|wparam, SIZE_RESTORED },
14828 { WM_MOVE, sent },
14829 { WM_SETFONT, sent },
14830 { WM_INITDIALOG, sent },
14831 { WM_GETDLGCODE, sent|wparam|lparam|optional, 0, 0 }, /* FIXME: Wine doesn't send it */
14832 { HCBT_SETFOCUS, hook },
14833 { HCBT_ACTIVATE, hook },
14834 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14835 { WM_QUERYNEWPALETTE, sent|optional },
14836 { WM_PALETTEISCHANGING, sent|optional },
14837 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14838 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOREDRAW },
14839 { WM_ACTIVATEAPP, sent|wparam, 1 },
14840 { WM_NCACTIVATE, sent },
14841 { WM_ACTIVATE, sent|wparam, 1 },
14842 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
14843 { WM_SETFOCUS, sent },
14844 { WM_CHANGEUISTATE, sent|optional },
14845 { 0 }
14846 };
14847 /* Creation of a dialog */
14848 static const struct message WmCreateDialogParamSeq_2[] = {
14849 { HCBT_CREATEWND, hook },
14850 { WM_NCCREATE, sent },
14851 { WM_NCCALCSIZE, sent|wparam, 0 },
14852 { WM_CREATE, sent },
14853 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14854 { WM_SIZE, sent|wparam, SIZE_RESTORED },
14855 { WM_MOVE, sent },
14856 { WM_CHANGEUISTATE, sent|optional },
14857 { 0 }
14858 };
14859
14860 static const struct message WmCreateDialogParamSeq_3[] = {
14861 { HCBT_CREATEWND, hook },
14862 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14863 { WM_SETFONT, sent|parent },
14864 { WM_INITDIALOG, sent|parent },
14865 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
14866 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
14867 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
14868 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
14869 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
14870 { HCBT_ACTIVATE, hook },
14871 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14872 { WM_QUERYNEWPALETTE, sent|parent|optional }, /* TODO: this message should not be sent */
14873 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14874 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14875 { WM_WINDOWPOSCHANGED, sent|parent|wparam|optional, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14876 { WM_WINDOWPOSCHANGED, sent|parent|wparam|optional, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14877 { WM_NCCALCSIZE, sent|parent|optional, 0 },
14878 { WM_MOVE, sent|parent|optional },
14879 { WM_SIZE, sent|parent|optional },
14880 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
14881 { WM_ACTIVATEAPP, sent|parent|wparam, 1 },
14882 { WM_NCACTIVATE, sent|parent },
14883 { WM_ACTIVATE, sent|parent|wparam, 1 },
14884 { WM_SETFOCUS, sent },
14885 { WM_COMMAND, sent|parent|wparam, MAKELONG(200, EN_SETFOCUS) },
14886 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
14887 { WM_USER, sent|parent },
14888 { WM_CHANGEUISTATE, sent|parent|optional },
14889 { 0 }
14890 };
14891
14892 static const struct message WmCreateDialogParamSeq_4[] = {
14893 { HCBT_CREATEWND, hook },
14894 { WM_NCCREATE, sent|parent },
14895 { WM_NCCALCSIZE, sent|parent|wparam, 0 },
14896 { WM_CREATE, sent|parent },
14897 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14898 { WM_SIZE, sent|parent|wparam, SIZE_RESTORED },
14899 { WM_MOVE, sent|parent },
14900 { WM_SETFONT, sent|parent },
14901 { WM_INITDIALOG, sent|parent },
14902 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
14903 { EM_SETSEL, sent|wparam|lparam, 0, INT_MAX },
14904 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
14905 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
14906 { EM_SETSEL, sent|wparam|lparam|optional, 0, INT_MAX },
14907 { HCBT_ACTIVATE, hook },
14908 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
14909 { WM_QUERYNEWPALETTE, sent|parent|optional }, /* TODO: this message should not be sent */
14910 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14911 { WM_WINDOWPOSCHANGING, sent|parent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
14912 { WM_WINDOWPOSCHANGED, sent|parent|wparam|optional, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
14913 { WM_NCCALCSIZE, sent|parent|optional, 0 },
14914 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
14915 { WM_ACTIVATEAPP, sent|parent|wparam, 1 },
14916 { WM_NCACTIVATE, sent|parent },
14917 { WM_ACTIVATE, sent|parent|wparam, 1 },
14918 { HCBT_SETFOCUS, hook },
14919 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
14920 { WM_SETFOCUS, sent|parent },
14921 { WM_KILLFOCUS, sent|parent },
14922 { WM_SETFOCUS, sent },
14923 { WM_COMMAND, sent|parent|wparam, MAKELONG(200, EN_SETFOCUS) },
14924 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
14925 { WM_USER, sent|parent },
14926 { WM_CHANGEUISTATE, sent|parent|optional },
14927 { WM_UPDATEUISTATE, sent|parent|optional },
14928 { WM_UPDATEUISTATE, sent|optional },
14929 { 0 }
14930 };
14931
14932 static void test_dialog_messages(void)
14933 {
14934 WNDCLASSA cls;
14935 HWND hdlg, hedit1, hedit2, hfocus, parent, child, child2;
14936 LRESULT ret;
14937
14938 #define set_selection(hctl, start, end) \
14939 ret = SendMessageA(hctl, EM_SETSEL, start, end); \
14940 ok(ret == 1, "EM_SETSEL returned %Id\n", ret);
14941
14942 #define check_selection(hctl, start, end) \
14943 ret = SendMessageA(hctl, EM_GETSEL, 0, 0); \
14944 ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
14945
14946 subclass_edit();
14947
14948 hdlg = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
14949 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
14950 0, 0, 100, 100, 0, 0, 0, NULL);
14951 ok(hdlg != 0, "Failed to create custom dialog window\n");
14952
14953 hedit1 = CreateWindowExA(0, "my_edit_class", NULL,
14954 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
14955 0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
14956 ok(hedit1 != 0, "Failed to create edit control\n");
14957 hedit2 = CreateWindowExA(0, "my_edit_class", NULL,
14958 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
14959 0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
14960 ok(hedit2 != 0, "Failed to create edit control\n");
14961
14962 SendMessageA(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
14963 SendMessageA(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
14964
14965 hfocus = GetFocus();
14966 ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
14967
14968 SetFocus(hedit2);
14969 hfocus = GetFocus();
14970 ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
14971
14972 check_selection(hedit1, 0, 0);
14973 check_selection(hedit2, 0, 0);
14974
14975 set_selection(hedit2, 0, -1);
14976 check_selection(hedit2, 0, 3);
14977
14978 SetFocus(0);
14979 hfocus = GetFocus();
14980 ok(hfocus == 0, "wrong focus %p\n", hfocus);
14981
14982 flush_sequence();
14983 ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
14984 ok(ret == 0, "WM_SETFOCUS returned %Id\n", ret);
14985 ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
14986
14987 hfocus = GetFocus();
14988 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
14989
14990 check_selection(hedit1, 0, 5);
14991 check_selection(hedit2, 0, 3);
14992
14993 flush_sequence();
14994 ret = DefDlgProcA(hdlg, WM_SETFOCUS, 0, 0);
14995 ok(ret == 0, "WM_SETFOCUS returned %Id\n", ret);
14996 ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
14997
14998 hfocus = GetFocus();
14999 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
15000
15001 check_selection(hedit1, 0, 5);
15002 check_selection(hedit2, 0, 3);
15003
15004 EndDialog(hdlg, 0);
15005 DestroyWindow(hedit1);
15006 DestroyWindow(hedit2);
15007 DestroyWindow(hdlg);
15008 flush_sequence();
15009
15010 #undef set_selection
15011 #undef check_selection
15012
15013 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
15014 cls.lpszClassName = "MyDialogClass";
15015 cls.hInstance = GetModuleHandleA(NULL);
15016 /* need a cast since a dlgproc is used as a wndproc */
15017 cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
15018 if (!RegisterClassA(&cls)) assert(0);
15019
15020 SetFocus(0);
15021 flush_sequence();
15022 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
15023 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15024 ok_sequence(WmCreateDialogParamSeq_0, "CreateDialogParam_0", FALSE);
15025 hfocus = GetFocus();
15026 ok(hfocus == 0, "wrong focus %p\n", hfocus);
15027 EndDialog(hdlg, 0);
15028 DestroyWindow(hdlg);
15029 flush_sequence();
15030
15031 SetFocus(0);
15032 flush_sequence();
15033 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 1);
15034 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15035 ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
15036 hfocus = GetFocus();
15037 ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
15038 EndDialog(hdlg, 0);
15039 DestroyWindow(hdlg);
15040 flush_sequence();
15041
15042 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
15043 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15044 ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
15045 EndDialog(hdlg, 0);
15046 DestroyWindow(hdlg);
15047 flush_sequence();
15048
15049 hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_3", 0, test_dlg_proc2, 0);
15050 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15051 ok_sequence(WmCreateDialogParamSeq_3, "CreateDialogParam_3", TRUE);
15052 EndDialog(hdlg, 0);
15053 DestroyWindow(hdlg);
15054 flush_sequence();
15055
15056 UnregisterClassA( cls.lpszClassName, cls.hInstance );
15057 cls.lpfnWndProc = test_dlg_proc4;
15058 ok( RegisterClassA(&cls), "failed to register class again\n" );
15059 hdlg = CreateDialogParamA(0, "FOCUS_TEST_DIALOG_4", 0, test_dlg_proc3, 0);
15060 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15061 ok_sequence(WmCreateDialogParamSeq_4, "CreateDialogParam_4", TRUE);
15062 EndDialog(hdlg, 0);
15063 DestroyWindow(hdlg);
15064 flush_sequence();
15065
15066 UnregisterClassA(cls.lpszClassName, cls.hInstance);
15067
15068 parent = CreateWindowExA(0, "TestParentClass", "Test parent",
15069 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15070 100, 100, 200, 200, 0, 0, 0, NULL);
15071 ok (parent != 0, "Failed to create parent window\n");
15072
15073 /* This child has no parent set. We will later call SetParent on it,
15074 * so that it will have a parent set, but no WS_CHILD style. */
15075 child = CreateWindowExA(0, "TestWindowClass", "Test child",
15076 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15077 100, 100, 200, 200, 0, 0, 0, NULL);
15078 ok (child != 0, "Failed to create child window\n");
15079
15080 /* This is a regular child window. When used as an owner, the other
15081 * child window will be used. */
15082 child2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2",
15083 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CHILD,
15084 100, 100, 200, 200, child, 0, 0, NULL);
15085 ok (child2 != 0, "Failed to create child window\n");
15086
15087 SetParent(child, parent);
15088 SetFocus(child);
15089
15090 flush_sequence();
15091 DialogBoxA( 0, "TEST_DIALOG", child2, TestModalDlgProc2 );
15092 ok_sequence(WmModalDialogSeq_2, "ModalDialog2", TRUE);
15093
15094 DestroyWindow(child2);
15095 DestroyWindow(child);
15096 DestroyWindow(parent);
15097 flush_sequence();
15098 }
15099
15100 static void test_enddialog_seq(HWND dialog, HWND owner)
15101 {
15102 const struct message seq[] = {
15103 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15104 { WM_ENABLE, sent },
15105 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
15106 { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
15107 { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
15108 { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
15109 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15110 /* FIXME: Following two are optional because Wine sends WM_QUERYNEWPALETTE instead of WM_WINDOWPOSCHANGING */
15111 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
15112 { WM_QUERYNEWPALETTE, sent|optional },
15113 { WM_NCACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
15114 { WM_GETTEXT, sent|optional|defwinproc },
15115 { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, (LPARAM)dialog },
15116 { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
15117 { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
15118 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
15119 { WM_SETFOCUS, sent|defwinproc|wparam, (WPARAM)dialog },
15120 { 0 }
15121 };
15122
15123 flush_sequence();
15124 EndDialog(dialog, 0);
15125 ok_sequence(seq, "EndDialog", FALSE);
15126 }
15127
15128 static void test_enddialog_seq2(HWND dialog, HWND owner)
15129 {
15130 const struct message seq[] = {
15131 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15132 { WM_ENABLE, parent|sent },
15133 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
15134 { HCBT_ACTIVATE, hook|wparam, (WPARAM)owner },
15135 { WM_NCACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
15136 { WM_ACTIVATE, sent|wparam|lparam, WA_INACTIVE, (LPARAM)owner },
15137 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15138 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
15139 { WM_WINDOWPOSCHANGING, sent|optional|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
15140 { HCBT_SETFOCUS, hook|wparam, (WPARAM)owner },
15141 { WM_KILLFOCUS, sent|wparam, (WPARAM)owner },
15142 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
15143 { WM_SETFOCUS, sent|parent|defwinproc|wparam, (WPARAM)dialog },
15144 { 0 }
15145 };
15146
15147 flush_sequence();
15148 EndDialog(dialog, 0);
15149 ok_sequence(seq, "EndDialog2", FALSE);
15150 }
15151
15152 static void test_EndDialog(void)
15153 {
15154 HWND hparent, hother, hactive, hdlg, hchild;
15155 WNDCLASSA cls;
15156
15157 hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
15158 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
15159 100, 100, 200, 200, 0, 0, 0, NULL);
15160 ok (hparent != 0, "Failed to create parent window\n");
15161
15162 hother = CreateWindowExA(0, "TestParentClass", "Test parent 2",
15163 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15164 200, 100, 200, 200, 0, 0, 0, NULL);
15165 ok (hother != 0, "Failed to create parent window\n");
15166
15167 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
15168 cls.lpszClassName = "MyDialogClass";
15169 cls.hInstance = GetModuleHandleA(NULL);
15170 cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
15171 if (!RegisterClassA(&cls)) assert(0);
15172
15173 flush_sequence();
15174 SetForegroundWindow(hother);
15175 hactive = GetForegroundWindow();
15176 ok(hother == hactive, "Wrong window has focus (%p != %p)\n", hother, hactive);
15177
15178 /* create a dialog where the parent is disabled, this parent should be
15179 * enabled and receive focus when dialog exits */
15180 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hparent, test_dlg_proc, 0);
15181 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15182 SetForegroundWindow(hdlg);
15183 hactive = GetForegroundWindow();
15184 ok(hdlg == hactive, "Wrong window has focus (%p != %p)\n", hdlg, hactive);
15185 EndDialog(hdlg, 0);
15186 ok(IsWindowEnabled(hparent), "parent is not enabled\n");
15187 hactive = GetForegroundWindow();
15188 ok(hparent == hactive, "Wrong window has focus (parent != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
15189 DestroyWindow(hdlg);
15190 flush_sequence();
15191
15192 /* create a dialog where the parent is disabled and set active window to other window before calling EndDialog */
15193 EnableWindow(hparent, FALSE);
15194 hdlg = CreateWindowExA(0, "TestDialogClass", NULL,
15195 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
15196 0, 0, 100, 100, hparent, 0, 0, NULL);
15197 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15198 flush_sequence();
15199 SetForegroundWindow(hother);
15200 flush_sequence();
15201 hactive = GetForegroundWindow();
15202 ok(hactive == hother, "Wrong foreground (%p != %p)\n", hactive, hother);
15203 hactive = GetActiveWindow();
15204 ok(hactive == hother, "Wrong active window (%p != %p)\n", hactive, hother);
15205 EndDialog(hdlg, 0);
15206 ok(IsWindowEnabled(hparent), "parent is not enabled\n");
15207 hactive = GetForegroundWindow();
15208 ok(hother == hactive, "Wrong window has focus (other != active) (active: %p, parent: %p, dlg: %p, other: %p)\n", hactive, hparent, hdlg, hother);
15209 DestroyWindow(hdlg);
15210 flush_sequence();
15211
15212 DestroyWindow( hparent );
15213
15214 hparent = CreateWindowExA(0, "TestParentClass", "Test parent",
15215 WS_POPUP | WS_VISIBLE | WS_DISABLED,
15216 100, 100, 200, 200, 0, 0, 0, NULL);
15217 ok (hparent != 0, "Failed to create parent window\n");
15218
15219 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
15220 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_DISABLED,
15221 0, 0, 0, 0, 0, 0, 0, NULL);
15222 ok (hchild != 0, "Failed to create child window\n");
15223
15224 SetParent(hchild, hparent);
15225
15226 flush_sequence();
15227 SetForegroundWindow(hother);
15228 hactive = GetForegroundWindow();
15229 ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
15230
15231 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
15232 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15233
15234 SetForegroundWindow(hdlg);
15235 test_enddialog_seq(hdlg, hchild);
15236
15237 hactive = GetForegroundWindow();
15238 ok(hactive == hchild, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
15239
15240 DestroyWindow(hdlg);
15241
15242 /* Now set WS_CHILD style flag so that it's a real child and its parent will be dialog's owner. */
15243 SetWindowLongW(hchild, GWL_STYLE, GetWindowLongW(hchild, GWL_STYLE) | WS_CHILD);
15244
15245 SetForegroundWindow(hother);
15246 hactive = GetForegroundWindow();
15247 ok(hother == hactive, "Wrong foreground window (%p != %p)\n", hother, hactive);
15248
15249 hdlg = CreateDialogParamA(0, "CLASS_TEST_DIALOG_2", hchild, test_dlg_proc, 0);
15250 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
15251
15252 SetForegroundWindow(hdlg);
15253 test_enddialog_seq2(hdlg, hparent);
15254
15255 hactive = GetForegroundWindow();
15256 ok(hactive == hparent, "Wrong foreground window (active: %p, parent: %p, dlg: %p, other: %p child: %p)\n", hactive, hparent, hdlg, hother, hchild);
15257 DestroyWindow(hdlg);
15258 DestroyWindow(hchild);
15259 DestroyWindow(hparent);
15260 DestroyWindow(hother);
15261 flush_sequence();
15262
15263 UnregisterClassA(cls.lpszClassName, cls.hInstance);
15264 }
15265
15266 static void test_nullCallback(void)
15267 {
15268 HWND hwnd;
15269
15270 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
15271 100, 100, 200, 200, 0, 0, 0, NULL);
15272 ok (hwnd != 0, "Failed to create overlapped window\n");
15273
15274 SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
15275 flush_events();
15276 DestroyWindow(hwnd);
15277 }
15278
15279 /* SetActiveWindow( 0 ) hwnd visible */
15280 static const struct message SetActiveWindowSeq0[] =
15281 {
15282 { HCBT_ACTIVATE, hook|optional },
15283 { WM_NCACTIVATE, sent|wparam, 0 },
15284 { WM_GETTEXT, sent|defwinproc|optional },
15285 { WM_ACTIVATE, sent|wparam, 0 },
15286 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15287 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
15288 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
15289 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
15290 { WM_KILLFOCUS, sent|optional },
15291 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
15292 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
15293 { WM_NCACTIVATE, sent|wparam|optional, 1 },
15294 { WM_GETTEXT, sent|defwinproc|optional },
15295 { WM_ACTIVATE, sent|wparam|optional, 1 },
15296 { HCBT_SETFOCUS, hook|optional },
15297 { WM_KILLFOCUS, sent|defwinproc|optional },
15298 { WM_IME_SETCONTEXT, sent|defwinproc|optional },
15299 { WM_IME_SETCONTEXT, sent|defwinproc|optional },
15300 { WM_IME_SETCONTEXT, sent|optional },
15301 { WM_IME_SETCONTEXT, sent|optional },
15302 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
15303 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
15304 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
15305 { WM_SETFOCUS, sent|defwinproc|optional },
15306 { WM_GETTEXT, sent|optional },
15307 { 0 }
15308 };
15309 /* SetActiveWindow( hwnd ) hwnd visible */
15310 static const struct message SetActiveWindowSeq1[] =
15311 {
15312 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
15313 { 0 }
15314 };
15315 /* SetActiveWindow( popup ) hwnd visible, popup visible */
15316 static const struct message SetActiveWindowSeq2[] =
15317 {
15318 { HCBT_ACTIVATE, hook },
15319 { WM_NCACTIVATE, sent|wparam, 0 },
15320 { WM_GETTEXT, sent|defwinproc|optional },
15321 { WM_ACTIVATE, sent|wparam, 0 },
15322 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15323 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
15324 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
15325 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
15326 { WM_NCPAINT, sent|optional },
15327 { WM_GETTEXT, sent|defwinproc|optional },
15328 { WM_ERASEBKGND, sent|optional },
15329 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15330 { WM_NCACTIVATE, sent|wparam, 1 },
15331 { WM_GETTEXT, sent|defwinproc|optional },
15332 { WM_ACTIVATE, sent|wparam, 1 },
15333 { HCBT_SETFOCUS, hook },
15334 { WM_KILLFOCUS, sent|defwinproc },
15335 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
15336 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
15337 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
15338 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
15339 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
15340 { WM_SETFOCUS, sent|defwinproc },
15341 { WM_GETTEXT, sent|optional },
15342 { 0 }
15343 };
15344
15345 /* SetActiveWindow( hwnd ) hwnd not visible */
15346 static const struct message SetActiveWindowSeq3[] =
15347 {
15348 { HCBT_ACTIVATE, hook },
15349 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15350 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
15351 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
15352 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
15353 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15354 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15355 { WM_ACTIVATEAPP, sent|wparam, 1 },
15356 { WM_ACTIVATEAPP, sent|wparam, 1 },
15357 { WM_NCACTIVATE, sent|wparam, 1 },
15358 { WM_ACTIVATE, sent|wparam, 1 },
15359 { HCBT_SETFOCUS, hook },
15360 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
15361 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
15362 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
15363 { WM_SETFOCUS, sent|defwinproc },
15364 { 0 }
15365 };
15366 /* SetActiveWindow( popup ) hwnd not visible, popup not visible */
15367 static const struct message SetActiveWindowSeq4[] =
15368 {
15369 { HCBT_ACTIVATE, hook },
15370 { WM_NCACTIVATE, sent|wparam, 0 },
15371 { WM_GETTEXT, sent|defwinproc|optional },
15372 { WM_ACTIVATE, sent|wparam, 0 },
15373 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15374 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
15375 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
15376 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
15377 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15378 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
15379 { WM_NCACTIVATE, sent|wparam, 1 },
15380 { WM_GETTEXT, sent|defwinproc|optional },
15381 { WM_ACTIVATE, sent|wparam, 1 },
15382 { HCBT_SETFOCUS, hook },
15383 { WM_KILLFOCUS, sent|defwinproc },
15384 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
15385 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
15386 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
15387 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
15388 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
15389 { WM_SETFOCUS, sent|defwinproc },
15390 { 0 }
15391 };
15392
15393
15394 static void test_SetActiveWindow(void)
15395 {
15396 HWND hwnd, popup, ret;
15397
15398 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
15399 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15400 100, 100, 200, 200, 0, 0, 0, NULL);
15401
15402 popup = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
15403 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_POPUP,
15404 100, 100, 200, 200, hwnd, 0, 0, NULL);
15405
15406 ok(hwnd != 0, "Failed to create overlapped window\n");
15407 ok(popup != 0, "Failed to create popup window\n");
15408 SetForegroundWindow( popup );
15409 flush_sequence();
15410
15411 if (winetest_debug > 1) trace("SetActiveWindow(0)\n");
15412 ret = SetActiveWindow(0);
15413 ok( ret == popup || broken(ret == 0) /* w1064v1809 */, "Failed to SetActiveWindow(0), ret:%p\n", ret);
15414 if (ret == popup) ok_sequence(SetActiveWindowSeq0, "SetActiveWindow(0)", FALSE);
15415 flush_sequence();
15416
15417 if (winetest_debug > 1) trace("SetActiveWindow(hwnd), hwnd visible\n");
15418 ret = SetActiveWindow(hwnd);
15419 if (ret == hwnd) ok_sequence(SetActiveWindowSeq1, "SetActiveWindow(hwnd), hwnd visible", TRUE);
15420 flush_sequence();
15421
15422 if (winetest_debug > 1) trace("SetActiveWindow(popup), hwnd visible, popup visible\n");
15423 ret = SetActiveWindow(popup);
15424 ok( ret == hwnd, "Failed to SetActiveWindow(popup), popup visible\n");
15425 ok_sequence(SetActiveWindowSeq2, "SetActiveWindow(popup), hwnd visible, popup visible", FALSE);
15426 flush_sequence();
15427
15428 ShowWindow(hwnd, SW_HIDE);
15429 ShowWindow(popup, SW_HIDE);
15430 flush_sequence();
15431
15432 if (winetest_debug > 1) trace("SetActiveWindow(hwnd), hwnd not visible\n");
15433 ret = SetActiveWindow(hwnd);
15434 ok( ret == NULL, "SetActiveWindow(hwnd), hwnd not visible, previous is %p\n", ret );
15435 ok_sequence(SetActiveWindowSeq3, "SetActiveWindow(hwnd), hwnd not visible", TRUE);
15436 flush_sequence();
15437
15438 if (winetest_debug > 1) trace("SetActiveWindow(popup), hwnd not visible, popup not visible\n");
15439 ret = SetActiveWindow(popup);
15440 ok( ret == hwnd, "Failed to SetActiveWindow(popup)\n");
15441 ok_sequence(SetActiveWindowSeq4, "SetActiveWindow(popup), hwnd not visible, popup not visible", TRUE);
15442 flush_sequence();
15443
15444 if (winetest_debug > 1) trace("done\n");
15445
15446 DestroyWindow(hwnd);
15447 }
15448
15449 static const struct message SetForegroundWindowSeq[] =
15450 {
15451 { WM_NCACTIVATE, sent|wparam, 0 },
15452 { WM_GETTEXT, sent|defwinproc|optional },
15453 { WM_ACTIVATE, sent|wparam, 0 },
15454 { WM_ACTIVATEAPP, sent|wparam, 0 },
15455 { WM_KILLFOCUS, sent },
15456 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
15457 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
15458 { 0 }
15459 };
15460
15461 static void test_SetForegroundWindow(void)
15462 {
15463 HWND hwnd;
15464
15465 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetForegroundWindow",
15466 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
15467 100, 100, 200, 200, 0, 0, 0, NULL);
15468 ok (hwnd != 0, "Failed to create overlapped window\n");
15469 SetForegroundWindow( hwnd );
15470 flush_sequence();
15471
15472 if (winetest_debug > 1) trace("SetForegroundWindow( 0 )\n");
15473 SetForegroundWindow( 0 );
15474 ok_sequence(WmEmptySeq, "SetForegroundWindow( 0 ) away from foreground top level window", FALSE);
15475 if (winetest_debug > 1) trace("SetForegroundWindow( GetDesktopWindow() )\n");
15476 SetForegroundWindow( GetDesktopWindow() );
15477 ok_sequence(SetForegroundWindowSeq, "SetForegroundWindow( desktop ) away from "
15478 "foreground top level window", FALSE);
15479 if (winetest_debug > 1) trace("done\n");
15480
15481 DestroyWindow(hwnd);
15482 }
15483
15484 static DWORD get_input_codepage( void )
15485 {
15486 DWORD cp;
15487 int ret;
15488 HKL hkl = GetKeyboardLayout( 0 );
15489
15490 ret = GetLocaleInfoW( LOWORD(hkl), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
15491 (WCHAR *)&cp, sizeof(cp) / sizeof(WCHAR) );
15492 if (!ret) cp = CP_ACP;
15493 return cp;
15494 }
15495
15496 static void test_dbcs_wm_char(void)
15497 {
15498 BYTE dbch[2];
15499 WCHAR wch, bad_wch;
15500 HWND hwnd, hwnd2;
15501 MSG msg;
15502 DWORD time;
15503 POINT pt;
15504 DWORD_PTR res;
15505 CPINFOEXA cpinfo;
15506 UINT i, j, k;
15507 struct message wmCharSeq[2];
15508 BOOL ret;
15509 DWORD cp = get_input_codepage();
15510
15511 if (!pGetCPInfoExA)
15512 {
15513 win_skip("GetCPInfoExA is not available\n");
15514 return;
15515 }
15516
15517 pGetCPInfoExA( cp, 0, &cpinfo );
15518 if (cpinfo.MaxCharSize != 2)
15519 {
15520 skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
15521 return;
15522 }
15523
15524 dbch[0] = dbch[1] = 0;
15525 wch = 0;
15526 bad_wch = cpinfo.UnicodeDefaultChar;
15527 for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
15528 for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
15529 for (k = 128; k <= 255; k++)
15530 {
15531 char str[2];
15532 WCHAR wstr[2];
15533 str[0] = j;
15534 str[1] = k;
15535 if (MultiByteToWideChar( cp, 0, str, 2, wstr, 2 ) == 1 &&
15536 WideCharToMultiByte( cp, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
15537 (BYTE)str[0] == j && (BYTE)str[1] == k &&
15538 HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
15539 {
15540 dbch[0] = j;
15541 dbch[1] = k;
15542 wch = wstr[0];
15543 break;
15544 }
15545 }
15546
15547 if (!wch)
15548 {
15549 skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
15550 return;
15551 }
15552 if (winetest_debug > 1) trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
15553 dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
15554
15555 hwnd = CreateWindowExW(0, testWindowClassW, NULL,
15556 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
15557 hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
15558 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
15559 ok (hwnd != 0, "Failed to create overlapped window\n");
15560 ok (hwnd2 != 0, "Failed to create overlapped window\n");
15561 flush_events();
15562 flush_sequence();
15563
15564 memset( wmCharSeq, 0, sizeof(wmCharSeq) );
15565 wmCharSeq[0].message = WM_CHAR;
15566 wmCharSeq[0].flags = sent|wparam;
15567 wmCharSeq[0].wParam = wch;
15568
15569 /* posted message */
15570 PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
15571 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15572 ok( !ret, "got message %x\n", msg.message );
15573 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15574 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15575 ok( ret, "no message\n" );
15576 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15577 ok( msg.wParam == wch, "bad wparam %Ix/%x\n", msg.wParam, wch );
15578 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15579 ok( !ret, "got message %x\n", msg.message );
15580
15581 /* posted thread message */
15582 PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
15583 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15584 ok( !ret, "got message %x\n", msg.message );
15585 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15586 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15587 ok( ret, "no message\n" );
15588 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15589 ok( msg.wParam == wch, "bad wparam %Ix/%x\n", msg.wParam, wch );
15590 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15591 ok( !ret, "got message %x\n", msg.message );
15592
15593 /* sent message */
15594 flush_sequence();
15595 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
15596 ok_sequence( WmEmptySeq, "no messages", FALSE );
15597 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15598 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15599 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15600 ok( !ret, "got message %x\n", msg.message );
15601
15602 /* sent message with timeout */
15603 flush_sequence();
15604 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
15605 ok_sequence( WmEmptySeq, "no messages", FALSE );
15606 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
15607 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15608 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15609 ok( !ret, "got message %x\n", msg.message );
15610
15611 /* sent message with timeout and callback */
15612 flush_sequence();
15613 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
15614 ok_sequence( WmEmptySeq, "no messages", FALSE );
15615 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
15616 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15617 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15618 ok( !ret, "got message %x\n", msg.message );
15619
15620 /* sent message with callback */
15621 flush_sequence();
15622 SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
15623 ok_sequence( WmEmptySeq, "no messages", FALSE );
15624 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
15625 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15626 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15627 ok( !ret, "got message %x\n", msg.message );
15628
15629 /* direct window proc call */
15630 flush_sequence();
15631 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
15632 ok_sequence( WmEmptySeq, "no messages", FALSE );
15633 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
15634 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15635
15636 /* dispatch message */
15637 msg.hwnd = hwnd;
15638 msg.message = WM_CHAR;
15639 msg.wParam = dbch[0];
15640 msg.lParam = 0;
15641 DispatchMessageA( &msg );
15642 ok_sequence( WmEmptySeq, "no messages", FALSE );
15643 msg.wParam = dbch[1];
15644 DispatchMessageA( &msg );
15645 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15646
15647 /* window handle is irrelevant */
15648 flush_sequence();
15649 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
15650 ok_sequence( WmEmptySeq, "no messages", FALSE );
15651 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15652 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15653 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15654 ok( !ret, "got message %x\n", msg.message );
15655
15656 /* interleaved post and send */
15657 flush_sequence();
15658 PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
15659 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
15660 ok_sequence( WmEmptySeq, "no messages", FALSE );
15661 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15662 ok( !ret, "got message %x\n", msg.message );
15663 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15664 ok_sequence( WmEmptySeq, "no messages", FALSE );
15665 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15666 ok( ret, "no message\n" );
15667 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15668 ok( msg.wParam == wch, "bad wparam %Ix/%x\n", msg.wParam, wch );
15669 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15670 ok( !ret, "got message %x\n", msg.message );
15671 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15672 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15673 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15674 ok( !ret, "got message %x\n", msg.message );
15675
15676 /* interleaved sent message and winproc */
15677 flush_sequence();
15678 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
15679 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
15680 ok_sequence( WmEmptySeq, "no messages", FALSE );
15681 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15682 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15683 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
15684 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15685
15686 /* interleaved winproc and dispatch */
15687 msg.hwnd = hwnd;
15688 msg.message = WM_CHAR;
15689 msg.wParam = dbch[0];
15690 msg.lParam = 0;
15691 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
15692 DispatchMessageA( &msg );
15693 ok_sequence( WmEmptySeq, "no messages", FALSE );
15694 msg.wParam = dbch[1];
15695 DispatchMessageA( &msg );
15696 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15697 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
15698 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15699
15700 /* interleaved sends */
15701 flush_sequence();
15702 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
15703 SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
15704 ok_sequence( WmEmptySeq, "no messages", FALSE );
15705 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
15706 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15707 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
15708 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15709
15710 /* dbcs WM_CHAR */
15711 flush_sequence();
15712 SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
15713 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
15714 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15715 ok( !ret, "got message %x\n", msg.message );
15716
15717 /* other char messages are not magic */
15718 PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
15719 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15720 ok( ret, "no message\n" );
15721 ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
15722 ok( msg.wParam == bad_wch, "bad wparam %Ix/%x\n", msg.wParam, bad_wch );
15723 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15724 ok( !ret, "got message %x\n", msg.message );
15725 PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
15726 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15727 ok( ret, "no message\n" );
15728 ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
15729 ok( msg.wParam == bad_wch, "bad wparam %Ix/%x\n", msg.wParam, bad_wch );
15730 ret = PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE );
15731 ok( !ret, "got message %x\n", msg.message );
15732
15733 /* test retrieving messages */
15734
15735 PostMessageW( hwnd, WM_CHAR, wch, 0 );
15736 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15737 ok( ret, "no message\n" );
15738 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15739 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15740 ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15741 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15742 ok( ret, "no message\n" );
15743 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15744 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15745 ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15746 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15747 ok( !ret, "got message %x\n", msg.message );
15748
15749 /* message filters */
15750 PostMessageW( hwnd, WM_CHAR, wch, 0 );
15751 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15752 ok( ret, "no message\n" );
15753 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15754 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15755 ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15756 /* message id is filtered, hwnd is not */
15757 ret = PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE );
15758 ok( !ret, "no message\n" );
15759 ret = PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE );
15760 ok( ret, "no message\n" );
15761 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15762 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15763 ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15764 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15765 ok( !ret, "got message %x\n", msg.message );
15766
15767 /* mixing GetMessage and PostMessage */
15768 PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
15769 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
15770 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15771 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15772 ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15773 ok( msg.lParam == 0xbeef, "bad lparam %Ix\n", msg.lParam );
15774 time = msg.time;
15775 pt = msg.pt;
15776 ok( time - GetTickCount() <= 100, "bad time %lx\n", msg.time );
15777 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
15778 ok( ret, "no message\n" );
15779 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15780 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15781 ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15782 ok( msg.lParam == 0xbeef, "bad lparam %Ix\n", msg.lParam );
15783 ok( msg.time == time, "bad time %lx/%lx\n", msg.time, time );
15784 ok( msg.pt.x == pt.x && msg.pt.y == pt.y, "bad point %lu,%lu/%lu,%lu\n", msg.pt.x, msg.pt.y, pt.x, pt.y );
15785 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15786 ok( !ret, "got message %x\n", msg.message );
15787
15788 /* without PM_REMOVE */
15789 PostMessageW( hwnd, WM_CHAR, wch, 0 );
15790 ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
15791 ok( ret, "no message\n" );
15792 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15793 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15794 ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15795 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
15796 ok( ret, "no message\n" );
15797 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15798 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15799 ok( msg.wParam == dbch[0], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15800 ret = PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
15801 ok( ret, "no message\n" );
15802 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15803 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15804 ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15805 ret = PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
15806 ok( ret, "no message\n" );
15807 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15808 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15809 ok( msg.wParam == dbch[1], "bad wparam %Ix/%x\n", msg.wParam, dbch[0] );
15810 ret = PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE );
15811 ok( !ret, "got message %x\n", msg.message );
15812
15813 DestroyWindow(hwnd);
15814 DestroyWindow(hwnd2);
15815 }
15816
15817 static void test_unicode_wm_char(void)
15818 {
15819 HWND hwnd;
15820 MSG msg;
15821 struct message seq[2];
15822 HKL hkl_orig, hkl_greek;
15823 DWORD cp;
15824 LCID thread_locale;
15825
15826 hkl_orig = GetKeyboardLayout( 0 );
15827 GetLocaleInfoW( LOWORD( hkl_orig ), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER, (WCHAR*)&cp, sizeof(cp) / sizeof(WCHAR) );
15828 if (cp != 1252)
15829 {
15830 skip( "Default codepage %ld\n", cp );
15831 return;
15832 }
15833
15834 hkl_greek = LoadKeyboardLayoutA( "00000408", 0 );
15835 if (!hkl_greek || hkl_greek == hkl_orig /* win2k */)
15836 {
15837 skip( "Unable to load Greek keyboard layout\n" );
15838 return;
15839 }
15840
15841 hwnd = CreateWindowExW( 0, testWindowClassW, NULL, WS_OVERLAPPEDWINDOW,
15842 100, 100, 200, 200, 0, 0, 0, NULL );
15843 flush_sequence();
15844
15845 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
15846
15847 while (GetMessageW( &msg, hwnd, 0, 0 ))
15848 {
15849 if (!ignore_message( msg.message )) break;
15850 }
15851
15852 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15853 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15854 ok( msg.wParam == 0x3b1, "bad wparam %Ix\n", msg.wParam );
15855 ok( msg.lParam == 0, "bad lparam %Ix\n", msg.lParam );
15856
15857 DispatchMessageW( &msg );
15858
15859 memset( seq, 0, sizeof(seq) );
15860 seq[0].message = WM_CHAR;
15861 seq[0].flags = sent|wparam;
15862 seq[0].wParam = 0x3b1;
15863
15864 ok_sequence( seq, "unicode WM_CHAR", FALSE );
15865
15866 flush_sequence();
15867
15868 /* greek alpha -> 'a' in cp1252 */
15869 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
15870
15871 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
15872 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15873 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15874 ok( msg.wParam == 0x61, "bad wparam %Ix\n", msg.wParam );
15875 ok( msg.lParam == 0, "bad lparam %Ix\n", msg.lParam );
15876
15877 DispatchMessageA( &msg );
15878
15879 seq[0].wParam = 0x61;
15880 ok_sequence( seq, "unicode WM_CHAR", FALSE );
15881
15882 thread_locale = GetThreadLocale();
15883 ActivateKeyboardLayout( hkl_greek, 0 );
15884 ok( GetThreadLocale() == thread_locale, "locale changed from %08lx to %08lx\n",
15885 thread_locale, GetThreadLocale() );
15886
15887 flush_sequence();
15888
15889 /* greek alpha -> 0xe1 in cp1253 */
15890 PostMessageW( hwnd, WM_CHAR, 0x3b1, 0 );
15891
15892 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
15893 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
15894 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
15895 ok( msg.wParam == 0xe1, "bad wparam %Ix\n", msg.wParam );
15896 ok( msg.lParam == 0, "bad lparam %Ix\n", msg.lParam );
15897
15898 DispatchMessageA( &msg );
15899
15900 seq[0].wParam = 0x3b1;
15901 ok_sequence( seq, "unicode WM_CHAR", FALSE );
15902
15903 DestroyWindow( hwnd );
15904 ActivateKeyboardLayout( hkl_orig, 0 );
15905 UnloadKeyboardLayout( hkl_greek );
15906 }
15907
15908 #define ID_LISTBOX 0x000f
15909
15910 static const struct message wm_lb_setcursel_0[] =
15911 {
15912 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
15913 { WM_CTLCOLORLISTBOX, sent|parent },
15914 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
15915 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15916 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15917 { 0 }
15918 };
15919 static const struct message wm_lb_setcursel_1[] =
15920 {
15921 { LB_SETCURSEL, sent|wparam|lparam, 1, 0 },
15922 { WM_CTLCOLORLISTBOX, sent|parent },
15923 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000020f2 },
15924 { WM_CTLCOLORLISTBOX, sent|parent },
15925 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000121f2 },
15926 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 2 },
15927 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 2 },
15928 { 0 }
15929 };
15930 static const struct message wm_lb_setcursel_2[] =
15931 {
15932 { LB_SETCURSEL, sent|wparam|lparam, 2, 0 },
15933 { WM_CTLCOLORLISTBOX, sent|parent },
15934 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000021f2 },
15935 { WM_CTLCOLORLISTBOX, sent|parent },
15936 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000122f2 },
15937 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 3 },
15938 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 3 },
15939 { 0 }
15940 };
15941 static const struct message wm_lb_click_0[] =
15942 {
15943 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, MAKELPARAM(1,1) },
15944 { HCBT_SETFOCUS, hook },
15945 { WM_KILLFOCUS, sent|parent },
15946 { WM_IME_SETCONTEXT, sent|wparam|optional|parent, 0 },
15947 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
15948 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
15949 { WM_SETFOCUS, sent|defwinproc },
15950
15951 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001142f2 },
15952 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SETFOCUS) },
15953 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 3 },
15954 { WM_LBTRACKPOINT, sent|wparam|lparam|parent, 0, MAKELPARAM(1,1) },
15955 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15956
15957 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000142f2 },
15958 { WM_CTLCOLORLISTBOX, sent|parent },
15959 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000022f2 },
15960 { WM_CTLCOLORLISTBOX, sent|parent },
15961 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
15962 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001140f2 },
15963
15964 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15965 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15966
15967 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
15968 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
15969 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
15970 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SELCHANGE) },
15971 { 0 }
15972 };
15973 static const struct message wm_lb_deletestring[] =
15974 {
15975 { LB_DELETESTRING, sent|wparam|lparam, 0, 0 },
15976 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15977 { WM_DELETEITEM, sent|wparam|parent|optional, ID_LISTBOX, 0 },
15978 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
15979 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
15980 { 0 }
15981 };
15982 static const struct message wm_lb_deletestring_reset[] =
15983 {
15984 { LB_DELETESTRING, sent|wparam|lparam, 0, 0 },
15985 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15986 { LB_RESETCONTENT, sent|wparam|lparam|defwinproc|optional, 0, 0 },
15987 { WM_DELETEITEM, sent|wparam|parent|optional, ID_LISTBOX, 0 },
15988 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
15989 { WM_DRAWITEM, sent|wparam|parent|optional, ID_LISTBOX },
15990 { 0 }
15991 };
15992 static const struct message wm_lb_addstring[] =
15993 {
15994 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ef },
15995 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
15996 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ed },
15997 /* Child ID changes each test, don't test lparam. */
15998 { EVENT_OBJECT_CREATE, winevent_hook|wparam|winevent_hook_todo, OBJID_CLIENT, 0 },
15999 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ee },
16000 { EVENT_OBJECT_CREATE, winevent_hook|wparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16001 { 0 }
16002 };
16003 static const struct message wm_lb_addstring_ownerdraw[] =
16004 {
16005 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ed },
16006 { WM_MEASUREITEM, sent|wparam|lparam|parent, 0xf0f2, 0xf30604ed },
16007 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16008 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ee },
16009 { WM_MEASUREITEM, sent|wparam|lparam|parent, 0xf1f2, 0xf30604ee },
16010 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 2 },
16011 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ef },
16012 { WM_MEASUREITEM, sent|wparam|lparam|parent, 0xf2f2, 0xf30604ef },
16013 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 3 },
16014 { 0 }
16015 };
16016 static const struct message wm_lb_addstring_sort_ownerdraw[] =
16017 {
16018 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ed },
16019 { WM_MEASUREITEM, sent|wparam|lparam|parent, 0xf0f2, 0xf30604ed },
16020 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16021 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ee },
16022 { WM_COMPAREITEM, sent|wparam|lparam|parent, 0xf30604ed, 0xf30604ee },
16023 { WM_MEASUREITEM, sent|wparam|lparam|parent, 0xf1f2, 0xf30604ee },
16024 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 2 },
16025 { LB_ADDSTRING, sent|wparam|lparam, 0, 0xf30604ef },
16026 { WM_COMPAREITEM, sent|wparam|lparam|parent, 0xf30604ed, 0xf30604ef },
16027 { WM_COMPAREITEM, sent|wparam|lparam|parent, 0xf30604ee, 0xf30604ef },
16028 { WM_MEASUREITEM, sent|wparam|lparam|parent, 0xf2f2, 0xf30604ef },
16029 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 3 },
16030 { 0 }
16031 };
16032
16033 #define check_lb_state(a1, a2, a3, a4, a5) check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)
16034
16035 static LRESULT (WINAPI *listbox_orig_proc)(HWND, UINT, WPARAM, LPARAM);
16036
16037 static LRESULT WINAPI listbox_hook_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
16038 {
16039 static LONG defwndproc_counter = 0;
16040 LRESULT ret;
16041 struct recvd_message msg;
16042
16043 /* do not log painting messages */
16044 if (message != WM_PAINT &&
16045 message != WM_NCPAINT &&
16046 message != WM_SYNCPAINT &&
16047 message != WM_ERASEBKGND &&
16048 message != WM_NCHITTEST &&
16049 message != WM_GETTEXT &&
16050 !ignore_message( message ))
16051 {
16052 msg.hwnd = hwnd;
16053 msg.message = message;
16054 msg.flags = sent|wparam|lparam;
16055 if (defwndproc_counter) msg.flags |= defwinproc;
16056 msg.wParam = wp;
16057 if (message == LB_ADDSTRING)
16058 msg.lParam = lp ? hash_Ly((const char *)lp) : 0;
16059 else
16060 msg.lParam = lp;
16061 msg.descr = "listbox";
16062 add_message(&msg);
16063 }
16064
16065 defwndproc_counter++;
16066 ret = CallWindowProcA(listbox_orig_proc, hwnd, message, wp, lp);
16067 defwndproc_counter--;
16068
16069 return ret;
16070 }
16071
16072 static void check_lb_state_dbg(HWND listbox, int count, int cur_sel,
16073 int caret_index, int top_index, int line)
16074 {
16075 LRESULT ret;
16076
16077 /* calling an orig proc helps to avoid unnecessary message logging */
16078 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCOUNT, 0, 0);
16079 ok_(__FILE__, line)(ret == count, "expected count %d, got %Id\n", count, ret);
16080 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCURSEL, 0, 0);
16081 ok_(__FILE__, line)(ret == cur_sel, "expected cur sel %d, got %Id\n", cur_sel, ret);
16082 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCARETINDEX, 0, 0);
16083 ok_(__FILE__, line)(ret == caret_index ||
16084 broken(cur_sel == -1 && caret_index == 0 && ret == -1), /* nt4 */
16085 "expected caret index %d, got %Id\n", caret_index, ret);
16086 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETTOPINDEX, 0, 0);
16087 ok_(__FILE__, line)(ret == top_index, "expected top index %d, got %Id\n", top_index, ret);
16088 }
16089
16090 static void test_listbox_messages(void)
16091 {
16092 HWND parent, listbox;
16093 LRESULT ret;
16094
16095 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
16096 100, 100, 200, 200, 0, 0, 0, NULL);
16097 /* with LBS_HASSTRINGS */
16098 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
16099 WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | WS_VISIBLE,
16100 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
16101 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
16102
16103 check_lb_state(listbox, 0, LB_ERR, 0, 0);
16104
16105 flush_sequence();
16106
16107 log_all_parent_messages++;
16108
16109 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
16110 ok(ret == 0, "expected 0, got %Id\n", ret);
16111 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
16112 ok(ret == 1, "expected 1, got %Id\n", ret);
16113 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
16114 ok(ret == 2, "expected 2, got %Id\n", ret);
16115
16116 ok_sequence(wm_lb_addstring_ownerdraw, "LB_ADDSTRING", FALSE);
16117 check_lb_state(listbox, 3, LB_ERR, 0, 0);
16118
16119 flush_sequence();
16120
16121 if (winetest_debug > 1) trace("selecting item 0\n");
16122 ret = SendMessageA(listbox, LB_SETCURSEL, 0, 0);
16123 ok(ret == 0, "expected 0, got %Id\n", ret);
16124 ok_sequence(wm_lb_setcursel_0, "LB_SETCURSEL 0", FALSE );
16125 check_lb_state(listbox, 3, 0, 0, 0);
16126 flush_sequence();
16127
16128 if (winetest_debug > 1) trace("selecting item 1\n");
16129 ret = SendMessageA(listbox, LB_SETCURSEL, 1, 0);
16130 ok(ret == 1, "expected 1, got %Id\n", ret);
16131 ok_sequence(wm_lb_setcursel_1, "LB_SETCURSEL 1", FALSE );
16132 check_lb_state(listbox, 3, 1, 1, 0);
16133
16134 if (winetest_debug > 1) trace("selecting item 2\n");
16135 ret = SendMessageA(listbox, LB_SETCURSEL, 2, 0);
16136 ok(ret == 2, "expected 2, got %Id\n", ret);
16137 ok_sequence(wm_lb_setcursel_2, "LB_SETCURSEL 2", FALSE );
16138 check_lb_state(listbox, 3, 2, 2, 0);
16139
16140 if (winetest_debug > 1) trace("clicking on item 0\n");
16141 ret = SendMessageA(listbox, WM_LBUTTONDOWN, 0, MAKELPARAM(1, 1));
16142 ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
16143 ret = SendMessageA(listbox, WM_LBUTTONUP, 0, 0);
16144 ok(ret == LB_OKAY, "expected LB_OKAY, got %Id\n", ret);
16145 ok_sequence(wm_lb_click_0, "WM_LBUTTONDOWN 0", FALSE );
16146 check_lb_state(listbox, 3, 0, 0, 0);
16147 flush_sequence();
16148
16149 if (winetest_debug > 1) trace("deleting item 0\n");
16150 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
16151 ok(ret == 2, "expected 2, got %Id\n", ret);
16152 ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
16153 check_lb_state(listbox, 2, -1, 0, 0);
16154 flush_sequence();
16155
16156 if (winetest_debug > 1) trace("deleting item 0\n");
16157 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
16158 ok(ret == 1, "expected 1, got %Id\n", ret);
16159 ok_sequence(wm_lb_deletestring, "LB_DELETESTRING 0", FALSE );
16160 check_lb_state(listbox, 1, -1, 0, 0);
16161 flush_sequence();
16162
16163 if (winetest_debug > 1) trace("deleting item 0\n");
16164 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
16165 ok(ret == 0, "expected 0, got %Id\n", ret);
16166 ok_sequence(wm_lb_deletestring_reset, "LB_DELETESTRING 0", FALSE );
16167 check_lb_state(listbox, 0, -1, 0, 0);
16168 flush_sequence();
16169
16170 if (winetest_debug > 1) trace("deleting item 0\n");
16171 ret = SendMessageA(listbox, LB_DELETESTRING, 0, 0);
16172 ok(ret == LB_ERR, "expected LB_ERR, got %Id\n", ret);
16173 check_lb_state(listbox, 0, -1, 0, 0);
16174 flush_sequence();
16175
16176 log_all_parent_messages--;
16177
16178 DestroyWindow(listbox);
16179
16180 /* with LBS_SORT and without LBS_HASSTRINGS */
16181 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
16182 WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_SORT | WS_VISIBLE,
16183 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
16184 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
16185
16186 check_lb_state(listbox, 0, LB_ERR, 0, 0);
16187
16188 flush_sequence();
16189
16190 log_all_parent_messages++;
16191
16192 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
16193 ok(ret == 0, "expected 0, got %Id\n", ret);
16194 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
16195 ok(ret == 1, "expected 1, got %Id\n", ret);
16196 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
16197 ok(ret == 2, "expected 2, got %Id\n", ret);
16198
16199 ok_sequence(wm_lb_addstring_sort_ownerdraw, "LB_ADDSTRING", FALSE);
16200 check_lb_state(listbox, 3, LB_ERR, 0, 0);
16201
16202 log_all_parent_messages--;
16203
16204 DestroyWindow(listbox);
16205
16206 /* with LBS_HASSTRINGS */
16207 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
16208 WS_CHILD | LBS_NOTIFY | LBS_HASSTRINGS | WS_VISIBLE,
16209 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
16210 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
16211
16212 check_lb_state(listbox, 0, LB_ERR, 0, 0);
16213
16214 flush_sequence();
16215
16216 log_all_parent_messages++;
16217
16218 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
16219 ok(ret == 0, "expected 0, got %Id\n", ret);
16220 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
16221 ok(ret == 1, "expected 1, got %Id\n", ret);
16222 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
16223 ok(ret == 2, "expected 2, got %Id\n", ret);
16224
16225 ok_sequence(wm_lb_addstring, "LB_ADDSTRING", FALSE);
16226 check_lb_state(listbox, 3, LB_ERR, 0, 0);
16227
16228 log_all_parent_messages--;
16229
16230 DestroyWindow(listbox);
16231
16232 /* with LBS_HASSTRINGS and LBS_SORT */
16233 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
16234 WS_CHILD | LBS_NOTIFY | LBS_HASSTRINGS | LBS_SORT | WS_VISIBLE,
16235 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
16236 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
16237
16238 check_lb_state(listbox, 0, LB_ERR, 0, 0);
16239
16240 flush_sequence();
16241
16242 log_all_parent_messages++;
16243
16244 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
16245 ok(ret == 0, "expected 0, got %Id\n", ret);
16246 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
16247 ok(ret == 0, "expected 0, got %Id\n", ret);
16248 ret = SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
16249 ok(ret == 1, "expected 1, got %Id\n", ret);
16250
16251 ok_sequence(wm_lb_addstring, "LB_ADDSTRING", FALSE);
16252 check_lb_state(listbox, 3, LB_ERR, 0, 0);
16253
16254 log_all_parent_messages--;
16255
16256 DestroyWindow(listbox);
16257 DestroyWindow(parent);
16258 }
16259
16260 /*************************** Menu test ******************************/
16261 static const struct message wm_popup_menu_1[] =
16262 {
16263 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
16264 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
16265 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0x20000001 },
16266 { WM_SYSKEYDOWN, sent|wparam|lparam, 'E', 0x20000001 },
16267 { WM_SYSCHAR, sent|wparam|lparam, 'e', 0x20000001 },
16268 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'e' },
16269 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
16270 { WM_INITMENU, sent|lparam, 0, 0 },
16271 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(1,MF_HILITE|MF_POPUP) },
16272 { WM_INITMENUPOPUP, sent|lparam, 0, 1 },
16273 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't create a window */
16274 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16275 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16276 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16277 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16278 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16279 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(200,MF_HILITE) },
16280 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16281 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0xf0000001 },
16282 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
16283 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001, 0, 0x40000000 },
16284 { EVENT_OBJECT_INVOKED, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_MENU, 0 },
16285 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16286 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't create a window */
16287 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16288 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16289 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
16290 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
16291 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
16292 { WM_MENUCOMMAND, sent }, /* |wparam, 200 - Win9x */
16293 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
16294 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
16295 { 0 }
16296 };
16297 static const struct message wm_popup_menu_2[] =
16298 {
16299 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
16300 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
16301 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
16302 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
16303 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
16304 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
16305 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
16306 { WM_INITMENU, sent|lparam, 0, 0 },
16307 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
16308 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
16309 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
16310 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
16311 { HCBT_CREATEWND, hook },
16312 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16313 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16314 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16315 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16316 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16317 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
16318 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
16319 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16320 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
16321 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
16322 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
16323 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
16324 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
16325 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16326 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16327 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16328 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16329 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16330 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
16331 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16332 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
16333 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
16334 { EVENT_OBJECT_INVOKED, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_MENU, 0 },
16335 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16336 { HCBT_DESTROYWND, hook },
16337 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16338 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16339 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
16340 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16341 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
16342 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16343 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16344 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
16345 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
16346 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
16347 { WM_MENUCOMMAND, sent }, /* |wparam, 100 - Win9x */
16348 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
16349 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
16350 { 0 }
16351 };
16352 static const struct message wm_popup_menu_3[] =
16353 {
16354 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
16355 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
16356 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
16357 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
16358 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
16359 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
16360 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
16361 { WM_INITMENU, sent|lparam, 0, 0 },
16362 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
16363 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
16364 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
16365 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
16366 { HCBT_CREATEWND, hook },
16367 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16368 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16369 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16370 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16371 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16372 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
16373 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
16374 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16375 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
16376 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
16377 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
16378 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
16379 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
16380 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16381 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16382 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16383 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16384 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16385 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
16386 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 1 },
16387 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
16388 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
16389 { EVENT_OBJECT_INVOKED, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_MENU, 100 },
16390 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16391 { HCBT_DESTROYWND, hook },
16392 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16393 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16394 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
16395 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam|winevent_hook_todo, OBJID_CLIENT, 0 },
16396 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
16397 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16398 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16399 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
16400 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
16401 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
16402 { WM_COMMAND, sent|wparam|lparam, 100, 0 },
16403 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
16404 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
16405 { 0 }
16406 };
16407
16408 static const struct message wm_single_menu_item[] =
16409 {
16410 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
16411 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
16412 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'Q', 0x20000001 },
16413 { WM_SYSKEYDOWN, sent|wparam|lparam, 'Q', 0x20000001 },
16414 { WM_SYSCHAR, sent|wparam|lparam, 'q', 0x20000001 },
16415 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'q' },
16416 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
16417 { WM_INITMENU, sent|lparam, 0, 0 },
16418 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(300,MF_HILITE) },
16419 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
16420 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
16421 { WM_MENUCOMMAND, sent },
16422 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'Q', 0xe0000001 },
16423 { WM_SYSKEYUP, sent|wparam|lparam, 'Q', 0xe0000001 },
16424 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 },
16425 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
16426
16427 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 1 },
16428 { WM_KEYDOWN, sent|wparam|lparam, VK_ESCAPE, 1 },
16429 { WM_CHAR, sent|wparam|lparam, VK_ESCAPE, 0x00000001 },
16430 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_ESCAPE, 0xc0000001 },
16431 { WM_KEYUP, sent|wparam|lparam, VK_ESCAPE, 0xc0000001 },
16432 { 0 }
16433 };
16434
16435 static LRESULT WINAPI parent_menu_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
16436 {
16437 if (message == WM_ENTERIDLE ||
16438 message == WM_INITMENU ||
16439 message == WM_INITMENUPOPUP ||
16440 message == WM_MENUSELECT ||
16441 message == WM_PARENTNOTIFY ||
16442 message == WM_ENTERMENULOOP ||
16443 message == WM_EXITMENULOOP ||
16444 message == WM_UNINITMENUPOPUP ||
16445 message == WM_KEYDOWN ||
16446 message == WM_KEYUP ||
16447 message == WM_CHAR ||
16448 message == WM_SYSKEYDOWN ||
16449 message == WM_SYSKEYUP ||
16450 message == WM_SYSCHAR ||
16451 message == WM_COMMAND ||
16452 message == WM_MENUCOMMAND)
16453 {
16454 struct recvd_message msg;
16455
16456 msg.hwnd = hwnd;
16457 msg.message = message;
16458 msg.flags = sent|wparam|lparam;
16459 msg.wParam = wp;
16460 msg.lParam = lp;
16461 msg.descr = "parent_menu_proc";
16462 add_message(&msg);
16463 }
16464
16465 return DefWindowProcA(hwnd, message, wp, lp);
16466 }
16467
16468 static void set_menu_style(HMENU hmenu, DWORD style)
16469 {
16470 MENUINFO mi;
16471 BOOL ret;
16472
16473 mi.cbSize = sizeof(mi);
16474 mi.fMask = MIM_STYLE;
16475 mi.dwStyle = style;
16476 SetLastError(0xdeadbeef);
16477 ret = SetMenuInfo(hmenu, &mi);
16478 ok(ret, "SetMenuInfo error %lu\n", GetLastError());
16479 }
16480
16481 static DWORD get_menu_style(HMENU hmenu)
16482 {
16483 MENUINFO mi;
16484 BOOL ret;
16485
16486 mi.cbSize = sizeof(mi);
16487 mi.fMask = MIM_STYLE;
16488 mi.dwStyle = 0;
16489 SetLastError(0xdeadbeef);
16490 ret = GetMenuInfo(hmenu, &mi);
16491 ok(ret, "GetMenuInfo error %lu\n", GetLastError());
16492
16493 return mi.dwStyle;
16494 }
16495
16496 static void test_menu_messages(void)
16497 {
16498 MSG msg;
16499 WNDCLASSA cls;
16500 HMENU hmenu, hmenu_popup;
16501 HWND hwnd;
16502 DWORD style;
16503 BOOL us_kbd = (GetKeyboardLayout(0) == (HKL)(ULONG_PTR)0x04090409);
16504
16505 cls.style = 0;
16506 cls.lpfnWndProc = parent_menu_proc;
16507 cls.cbClsExtra = 0;
16508 cls.cbWndExtra = 0;
16509 cls.hInstance = GetModuleHandleA(0);
16510 cls.hIcon = 0;
16511 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
16512 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
16513 cls.lpszMenuName = NULL;
16514 cls.lpszClassName = "TestMenuClass";
16515 UnregisterClassA(cls.lpszClassName, cls.hInstance);
16516 if (!RegisterClassA(&cls)) assert(0);
16517
16518 SetLastError(0xdeadbeef);
16519 hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
16520 100, 100, 200, 200, 0, 0, 0, NULL);
16521 ok(hwnd != 0, "LoadMenuA error %lu\n", GetLastError());
16522
16523 SetLastError(0xdeadbeef);
16524 hmenu = LoadMenuA(GetModuleHandleA(NULL), MAKEINTRESOURCEA(1));
16525 ok(hmenu != 0, "LoadMenuA error %lu\n", GetLastError());
16526
16527 SetMenu(hwnd, hmenu);
16528 SetForegroundWindow( hwnd );
16529 flush_events();
16530
16531 set_menu_style(hmenu, MNS_NOTIFYBYPOS);
16532 style = get_menu_style(hmenu);
16533 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %lu\n", style);
16534
16535 hmenu_popup = GetSubMenu(hmenu, 0);
16536 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
16537 style = get_menu_style(hmenu_popup);
16538 ok(style == 0, "expected 0, got %lu\n", style);
16539
16540 hmenu_popup = GetSubMenu(hmenu_popup, 0);
16541 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
16542 style = get_menu_style(hmenu_popup);
16543 ok(style == 0, "expected 0, got %lu\n", style);
16544
16545 if (!us_kbd)
16546 {
16547 skip("skipping ascii VK events on non-us keyboard\n");
16548 goto done;
16549 }
16550
16551 /* Alt+E, Enter */
16552 if (winetest_debug > 1) trace("testing a popup menu command\n");
16553 flush_sequence();
16554 keybd_event(VK_MENU, 0, 0, 0);
16555 keybd_event('E', 0, 0, 0);
16556 keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
16557 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
16558 keybd_event(VK_RETURN, 0, 0, 0);
16559 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
16560 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
16561 {
16562 TranslateMessage(&msg);
16563 DispatchMessageA(&msg);
16564 }
16565 if (!sequence_cnt) /* we didn't get any message */
16566 {
16567 skip( "queuing key events not supported\n" );
16568 goto done;
16569 }
16570 /* win98 queues only a WM_KEYUP and doesn't start menu tracking */
16571 if (sequence[0].message == WM_KEYUP && sequence[0].wParam == VK_MENU)
16572 {
16573 win_skip( "menu tracking through VK_MENU not supported\n" );
16574 goto done;
16575 }
16576 ok_sequence(wm_popup_menu_1, "popup menu command", FALSE);
16577
16578 /* Alt+F, Right, Enter */
16579 if (winetest_debug > 1) trace("testing submenu of a popup menu command\n");
16580 flush_sequence();
16581 keybd_event(VK_MENU, 0, 0, 0);
16582 keybd_event('F', 0, 0, 0);
16583 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
16584 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
16585 keybd_event(VK_RIGHT, 0, 0, 0);
16586 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
16587 keybd_event(VK_RETURN, 0, 0, 0);
16588 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
16589 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
16590 {
16591 TranslateMessage(&msg);
16592 DispatchMessageA(&msg);
16593 }
16594 ok_sequence(wm_popup_menu_2, "submenu of a popup menu command", FALSE);
16595
16596 if (winetest_debug > 1) trace("testing single menu item command\n");
16597 flush_sequence();
16598 keybd_event(VK_MENU, 0, 0, 0);
16599 keybd_event('Q', 0, 0, 0);
16600 keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
16601 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
16602 keybd_event(VK_ESCAPE, 0, 0, 0);
16603 keybd_event(VK_ESCAPE, 0, KEYEVENTF_KEYUP, 0);
16604 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
16605 {
16606 TranslateMessage(&msg);
16607 DispatchMessageA(&msg);
16608 }
16609 ok_sequence(wm_single_menu_item, "single menu item command", FALSE);
16610
16611 set_menu_style(hmenu, 0);
16612 style = get_menu_style(hmenu);
16613 ok(style == 0, "expected 0, got %lu\n", style);
16614
16615 hmenu_popup = GetSubMenu(hmenu, 0);
16616 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
16617 set_menu_style(hmenu_popup, MNS_NOTIFYBYPOS);
16618 style = get_menu_style(hmenu_popup);
16619 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %lu\n", style);
16620
16621 hmenu_popup = GetSubMenu(hmenu_popup, 0);
16622 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
16623 style = get_menu_style(hmenu_popup);
16624 ok(style == 0, "expected 0, got %lu\n", style);
16625
16626 /* Alt+F, Right, Enter */
16627 if (winetest_debug > 1) trace("testing submenu of a popup menu command\n");
16628 flush_sequence();
16629 keybd_event(VK_MENU, 0, 0, 0);
16630 keybd_event('F', 0, 0, 0);
16631 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
16632 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
16633 keybd_event(VK_RIGHT, 0, 0, 0);
16634 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
16635 keybd_event(VK_RETURN, 0, 0, 0);
16636 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
16637 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
16638 {
16639 TranslateMessage(&msg);
16640 DispatchMessageA(&msg);
16641 }
16642 ok_sequence(wm_popup_menu_3, "submenu of a popup menu command", FALSE);
16643
16644 done:
16645 DestroyWindow(hwnd);
16646 DestroyMenu(hmenu);
16647 }
16648
16649
16650 static void test_paintingloop(void)
16651 {
16652 HWND hwnd;
16653
16654 paint_loop_done = FALSE;
16655 hwnd = CreateWindowExA(0x0,"PaintLoopWindowClass",
16656 "PaintLoopWindowClass",WS_OVERLAPPEDWINDOW,
16657 100, 100, 100, 100, 0, 0, 0, NULL );
16658 ok(hwnd != 0, "PaintLoop window error %lu\n", GetLastError());
16659 ShowWindow(hwnd,SW_NORMAL);
16660 SetFocus(hwnd);
16661
16662 while (!paint_loop_done)
16663 {
16664 MSG msg;
16665 if (PeekMessageA(&msg, 0, 0, 0, 1))
16666 {
16667 TranslateMessage(&msg);
16668 DispatchMessageA(&msg);
16669 }
16670 }
16671 DestroyWindow(hwnd);
16672 }
16673
16674 static const struct message NCRBUTTONDOWNSeq[] =
16675 {
16676 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16677 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16678 { WM_CAPTURECHANGED, sent },
16679 { WM_CONTEXTMENU, sent, /*hwnd*/0, -1 },
16680 { 0 }
16681 };
16682
16683 static const struct message NCXBUTTONUPSeq1[] =
16684 {
16685 { WM_APPCOMMAND, sent|lparam, /*hwnd*/0, MAKELPARAM(0, FAPPCOMMAND_MOUSE | APPCOMMAND_BROWSER_BACKWARD) },
16686 { 0 }
16687 };
16688
16689 static const struct message NCXBUTTONUPSeq2[] =
16690 {
16691 { WM_APPCOMMAND, sent|lparam, /*hwnd*/0, MAKELPARAM(0, FAPPCOMMAND_MOUSE | APPCOMMAND_BROWSER_FORWARD) },
16692 { 0 }
16693 };
16694
16695 /* DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0) to minimized visible window */
16696 static const struct message WmRestoreMinimizedOverlappedSeq[] =
16697 {
16698 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_RESTORE, 0 },
16699 { HCBT_MINMAX, hook },
16700 { WM_QUERYOPEN, sent },
16701 { WM_GETTEXT, sent|optional },
16702 { WM_NCACTIVATE, sent|optional },
16703 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
16704 { WM_WINDOWPOSCHANGED, sent|optional },
16705 { WM_WINDOWPOSCHANGING, sent|optional },
16706 { WM_GETMINMAXINFO, sent|defwinproc },
16707 { WM_NCCALCSIZE, sent|optional },
16708 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16709 { WM_NCPAINT, sent|optional },
16710 { WM_GETTEXT, sent|defwinproc|optional },
16711 { WM_ERASEBKGND, sent|optional },
16712 { WM_WINDOWPOSCHANGED, sent|optional },
16713 { HCBT_ACTIVATE, hook },
16714 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16715 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
16716 { WM_ACTIVATEAPP, sent|wparam, TRUE },
16717 { WM_NCACTIVATE, sent|wparam, TRUE },
16718 { WM_GETTEXT, sent|defwinproc|optional },
16719 { WM_ACTIVATE, sent|wparam, TRUE },
16720 { HCBT_SETFOCUS, hook },
16721 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
16722 { WM_SETFOCUS, sent|defwinproc },
16723 { WM_NCPAINT, sent },
16724 { WM_GETTEXT, sent|defwinproc|optional },
16725 { WM_ERASEBKGND, sent },
16726 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_FRAMECHANGED|SWP_STATECHANGED },
16727 { WM_MOVE, sent|defwinproc },
16728 { WM_SIZE, sent|defwinproc },
16729 { WM_NCCALCSIZE, sent|optional },
16730 { WM_NCPAINT, sent|optional },
16731 { WM_ERASEBKGND, sent|optional },
16732 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16733 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
16734 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16735 { WM_ACTIVATE, sent|wparam, TRUE },
16736 { WM_SYNCPAINT, sent|optional },
16737 { WM_PAINT, sent },
16738 { 0 }
16739 };
16740
16741 /* DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0) to an active minimized window */
16742 static const struct message WmRestoreActiveMinimizedOverlappedSeq[] =
16743 {
16744 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_RESTORE, 0 },
16745 { HCBT_MINMAX, hook },
16746 { WM_QUERYOPEN, sent },
16747 { WM_GETTEXT, sent|optional },
16748 { WM_NCACTIVATE, sent },
16749 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
16750 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
16751 { WM_NCCALCSIZE, sent|optional },
16752 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sent on Win7. */
16753 { WM_MOVE, sent|optional },
16754 { WM_SIZE, sent|optional },
16755 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sent on Win7. */
16756 { WM_GETTEXT, sent|optional },
16757 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
16758 { WM_GETMINMAXINFO, sent|defwinproc },
16759 { WM_NCCALCSIZE, sent },
16760 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Sent on Win8+. */
16761 { WM_NCPAINT, sent },
16762 { WM_GETTEXT, sent|defwinproc|optional },
16763 { WM_ERASEBKGND, sent },
16764 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
16765 { WM_MOVE, sent|defwinproc },
16766 { WM_SIZE, sent|defwinproc },
16767 { WM_NCCALCSIZE, sent|optional },
16768 { WM_NCPAINT, sent|optional },
16769 { WM_ERASEBKGND, sent|optional },
16770 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16771 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* Win7 seems to send this twice. */
16772 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
16773 { HCBT_SETFOCUS, hook },
16774 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
16775 { WM_SETFOCUS, sent },
16776 /* Note this WM_ACTIVATE messages even if the window is already active */
16777 { WM_ACTIVATE, sent|wparam|lparam, WA_ACTIVE, 0 },
16778 { WM_SYNCPAINT, sent|optional },
16779 { WM_PAINT, sent },
16780 { WM_GETMINMAXINFO, sent|optional },
16781 { 0 }
16782 };
16783
16784 static struct message WmContextMenuSeq[] = {
16785 { WM_CONTEXTMENU, sent|wparam, 0 }, /* wparams set in the code */
16786 { WM_CONTEXTMENU, sent|wparam|defwinproc, 0 },
16787 { WM_CONTEXTMENU, sent|wparam|defwinproc, 0 },
16788 { 0 }
16789 };
16790
16791 struct rbuttonup_thread_data
16792 {
16793 HWND hwnd;
16794 HANDLE wndproc_finished;
16795 };
16796
16797 static DWORD CALLBACK post_rbuttonup_msg( void *arg )
16798 {
16799 struct rbuttonup_thread_data *data = arg;
16800 DWORD ret;
16801
16802 ret = WaitForSingleObject( data->wndproc_finished, 500 );
16803 todo_wine ok( ret == WAIT_OBJECT_0, "WaitForSingleObject returned %lx\n", ret );
16804 if( ret == WAIT_OBJECT_0 ) return 0;
16805
16806 PostMessageA( data->hwnd, WM_RBUTTONUP, 0, 0 );
16807 return 0;
16808 }
16809
16810 static void test_defwinproc(void)
16811 {
16812 HWND hwnd, child[3];
16813 MSG msg;
16814 BOOL gotwmquit = FALSE;
16815 POINT pos;
16816 RECT rect;
16817 INT x, y;
16818 LRESULT res;
16819 struct rbuttonup_thread_data data;
16820 char buffA[64];
16821 HANDLE thread;
16822
16823 hwnd = CreateWindowExA(0, "TestWindowClass", "test_defwndproc",
16824 WS_VISIBLE | WS_CAPTION | WS_OVERLAPPEDWINDOW, 0,0,500,100,0,0,0, NULL);
16825 assert(hwnd);
16826 flush_events();
16827
16828 buffA[0] = 0;
16829 GetWindowTextA(hwnd, buffA, ARRAY_SIZE(buffA));
16830 ok(!strcmp(buffA, "test_defwndproc"), "unexpected window text, %s\n", buffA);
16831
16832 /* Zero high word of the lParam */
16833 res = DefWindowProcA(hwnd, WM_SETTEXT, 0, 0x1234);
16834 ok(res == 0, "WM_SETTEXT was expected to fail, %Id\n", res);
16835
16836 GetWindowTextA(hwnd, buffA, ARRAY_SIZE(buffA));
16837 ok(!strcmp(buffA, "test_defwndproc"), "unexpected window text, %s\n", buffA);
16838
16839 res = DefWindowProcW(hwnd, WM_SETTEXT, 0, 0x1234);
16840 ok(res == 0, "WM_SETTEXT was expected to fail, %Id\n", res);
16841
16842 GetWindowTextA(hwnd, buffA, ARRAY_SIZE(buffA));
16843 ok(!strcmp(buffA, "test_defwndproc"), "unexpected window text, %s\n", buffA);
16844
16845 ShowWindow(hwnd, SW_MINIMIZE);
16846 flush_events();
16847 flush_sequence();
16848
16849 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
16850 flush_events();
16851 ok_sequence(WmRestoreMinimizedOverlappedSeq, "DefWindowProcA(SC_RESTORE):overlapped", TRUE);
16852
16853 ShowWindow(hwnd, SW_MINIMIZE);
16854 SetActiveWindow(hwnd);
16855 ok(GetActiveWindow() == hwnd, "Unexpected active window\n");
16856 flush_events();
16857 flush_sequence();
16858 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
16859 flush_events();
16860 ok_sequence(WmRestoreActiveMinimizedOverlappedSeq, "DefWindowProcA(SC_RESTORE):active minimized overlapped", TRUE);
16861
16862 child[0] = CreateWindowExA(0, "TestWindowClass", "1st child",
16863 WS_VISIBLE | WS_CHILD, 0,0,500,100, hwnd, 0, 0, NULL);
16864 child[1] = CreateWindowExA(0, "TestWindowClass", "2nd child",
16865 WS_VISIBLE | WS_CHILD, 0,0,500,100, child[0], 0, 0, NULL);
16866 child[2] = CreateWindowExA(0, "TestWindowClass", "3rd child",
16867 WS_VISIBLE | WS_CHILD, 0,0,500,100, child[1], 0, 0, NULL);
16868 flush_events();
16869 flush_sequence();
16870 test_context_menu = TRUE;
16871 DefWindowProcA(child[2], WM_CONTEXTMENU, 0xcafe, 0);
16872 test_context_menu = FALSE;
16873 WmContextMenuSeq[0].wParam = (WPARAM)child[2];
16874 WmContextMenuSeq[1].wParam = (WPARAM)child[1];
16875 WmContextMenuSeq[2].wParam = (WPARAM)child[0];
16876 ok_sequence(WmContextMenuSeq, "DefWindowProcA(WM_CONTEXTMENU)", FALSE);
16877 DestroyWindow(child[0]);
16878
16879 GetCursorPos(&pos);
16880 GetWindowRect(hwnd, &rect);
16881 x = (rect.left+rect.right) / 2;
16882 y = rect.top + GetSystemMetrics(SM_CYFRAME) + 1;
16883 SetCursorPos(x, y);
16884 flush_events();
16885 res = DefWindowProcA( hwnd, WM_NCHITTEST, 0, MAKELPARAM(x, y));
16886 ok(res == HTCAPTION, "WM_NCHITTEST returned %Id\n", res);
16887
16888 mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 );
16889 mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 );
16890 flush_events();
16891
16892 flush_sequence();
16893 mouse_event( MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0 );
16894 /* workaround for missing support for clicking on window frame */
16895 data.hwnd = hwnd;
16896 data.wndproc_finished = CreateEventA( NULL, FALSE, FALSE, NULL );
16897 thread = CreateThread( NULL, 0, post_rbuttonup_msg, (void*)&data, 0, NULL );
16898
16899 DefWindowProcA( hwnd, WM_NCRBUTTONDOWN, HTCAPTION, MAKELPARAM(x, y));
16900 ok_sequence(NCRBUTTONDOWNSeq, "WM_NCRBUTTONDOWN on caption", FALSE);
16901
16902 res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, 0, MAKELPARAM(x, y));
16903 ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
16904 ok_sequence(WmEmptySeq, "WM_NCXBUTTONUP without button", FALSE);
16905
16906 res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, MAKEWPARAM(0, XBUTTON1), MAKELPARAM(x, y));
16907 ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
16908 ok_sequence(NCXBUTTONUPSeq1, "WM_NCXBUTTONUP with XBUTTON1", FALSE);
16909
16910 res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, MAKEWPARAM(0, XBUTTON2), MAKELPARAM(x, y));
16911 ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
16912 ok_sequence(NCXBUTTONUPSeq2, "WM_NCXBUTTONUP with XBUTTON2", FALSE);
16913
16914 res = DefWindowProcA(hwnd, WM_NCXBUTTONUP, MAKEWPARAM(0, 3), MAKELPARAM(x, y));
16915 ok(!res, "WM_NCXBUTTONUP returned %Id\n", res);
16916 ok_sequence(WmEmptySeq, "WM_NCXBUTTONUP with invalid button", FALSE);
16917
16918 /* Test WM_MOUSEACTIVATE */
16919 #define TEST_MOUSEACTIVATE(A,B,C) \
16920 res = DefWindowProcA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,0)); \
16921 ok(res == B, "WM_MOUSEACTIVATE for %s returned %Id\n", #A, res); \
16922 res = DefWindowProcA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,WM_LBUTTONDOWN)); \
16923 ok(res == C, "WM_MOUSEACTIVATE for %s returned %Id\n", #A, res);
16924
16925 TEST_MOUSEACTIVATE(HTERROR, MA_ACTIVATE, MA_ACTIVATE);
16926 TEST_MOUSEACTIVATE(HTTRANSPARENT, MA_ACTIVATE, MA_ACTIVATE);
16927 TEST_MOUSEACTIVATE(HTNOWHERE, MA_ACTIVATE, MA_ACTIVATE);
16928 TEST_MOUSEACTIVATE(HTCLIENT, MA_ACTIVATE, MA_ACTIVATE);
16929 TEST_MOUSEACTIVATE(HTCAPTION, MA_ACTIVATE, MA_NOACTIVATE);
16930 TEST_MOUSEACTIVATE(HTSYSMENU, MA_ACTIVATE, MA_ACTIVATE);
16931 TEST_MOUSEACTIVATE(HTSIZE, MA_ACTIVATE, MA_ACTIVATE);
16932 TEST_MOUSEACTIVATE(HTMENU, MA_ACTIVATE, MA_ACTIVATE);
16933 TEST_MOUSEACTIVATE(HTHSCROLL, MA_ACTIVATE, MA_ACTIVATE);
16934 TEST_MOUSEACTIVATE(HTVSCROLL, MA_ACTIVATE, MA_ACTIVATE);
16935 TEST_MOUSEACTIVATE(HTMINBUTTON, MA_ACTIVATE, MA_ACTIVATE);
16936 TEST_MOUSEACTIVATE(HTMAXBUTTON, MA_ACTIVATE, MA_ACTIVATE);
16937 TEST_MOUSEACTIVATE(HTLEFT, MA_ACTIVATE, MA_ACTIVATE);
16938 TEST_MOUSEACTIVATE(HTRIGHT, MA_ACTIVATE, MA_ACTIVATE);
16939 TEST_MOUSEACTIVATE(HTTOP, MA_ACTIVATE, MA_ACTIVATE);
16940 TEST_MOUSEACTIVATE(HTTOPLEFT, MA_ACTIVATE, MA_ACTIVATE);
16941 TEST_MOUSEACTIVATE(HTTOPRIGHT, MA_ACTIVATE, MA_ACTIVATE);
16942 TEST_MOUSEACTIVATE(HTBOTTOM, MA_ACTIVATE, MA_ACTIVATE);
16943 TEST_MOUSEACTIVATE(HTBOTTOMLEFT, MA_ACTIVATE, MA_ACTIVATE);
16944 TEST_MOUSEACTIVATE(HTBOTTOMRIGHT, MA_ACTIVATE, MA_ACTIVATE);
16945 TEST_MOUSEACTIVATE(HTBORDER, MA_ACTIVATE, MA_ACTIVATE);
16946 TEST_MOUSEACTIVATE(HTOBJECT, MA_ACTIVATE, MA_ACTIVATE);
16947 TEST_MOUSEACTIVATE(HTCLOSE, MA_ACTIVATE, MA_ACTIVATE);
16948 TEST_MOUSEACTIVATE(HTHELP, MA_ACTIVATE, MA_ACTIVATE);
16949
16950 SetEvent( data.wndproc_finished );
16951 WaitForSingleObject( thread, 1000 );
16952 CloseHandle( data.wndproc_finished );
16953 CloseHandle( thread );
16954
16955 SetCursorPos(pos.x, pos.y);
16956
16957 DefWindowProcA( hwnd, WM_ENDSESSION, 1, 0);
16958 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) {
16959 if( msg.message == WM_QUIT) gotwmquit = TRUE;
16960 DispatchMessageA( &msg );
16961 }
16962 ok(!gotwmquit, "Unexpected WM_QUIT message!\n");
16963 DestroyWindow( hwnd);
16964 }
16965
16966 static void test_desktop_winproc(void)
16967 {
16968 HINSTANCE instance = GetModuleHandleA(NULL);
16969 RECT rect, default_rect;
16970 WNDPROC desktop_proc;
16971 char buffer[256];
16972 WNDCLASSA cls;
16973 LRESULT res;
16974 HWND hwnd;
16975 BOOL ret;
16976
16977 ret = GetClassInfoA(instance, (const CHAR *)MAKEINTATOM(32769), &cls);
16978 ok(ret, "Failed to get desktop class.\n");
16979 desktop_proc = cls.lpfnWndProc;
16980
16981 memset(&cls, 0, sizeof(cls));
16982 cls.lpfnWndProc = desktop_proc;
16983 cls.hInstance = instance;
16984 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
16985 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
16986 cls.lpszClassName = "TestDesktopClass";
16987 ret = !!RegisterClassA(&cls);
16988 ok(ret, "Failed to register class.\n");
16989
16990 hwnd = CreateWindowExA(0, cls.lpszClassName, "test_desktop_wndproc",
16991 WS_VISIBLE | WS_CAPTION | WS_OVERLAPPEDWINDOW, 0, 0, 500, 100, 0, 0, 0, NULL);
16992 if (!hwnd) /* win2003 */
16993 {
16994 skip("Failed to create window with desktop window procedure.\n");
16995 goto out_unregister;
16996 }
16997
16998 memset(&cls, 0, sizeof(cls));
16999 ret = GetClassInfoA(instance, "TestDesktopClass", &cls);
17000 ok(ret, "Failed to get class info.\n");
17001 ok(cls.lpfnWndProc == desktop_proc, "Got %p, expected %p.\n", cls.lpfnWndProc, desktop_proc);
17002
17003 GetWindowTextA(hwnd, buffer, ARRAY_SIZE(buffer));
17004 todo_wine ok(!strcmp(buffer, "test_desktop_wndproc"), "Got unexpected window text: %s.\n", buffer);
17005
17006 res = CallWindowProcA(desktop_proc, hwnd, WM_SETTEXT, 0, (LPARAM)"test");
17007 ok(res == TRUE, "Failed to set text, %Id.\n", res);
17008 GetWindowTextA(hwnd, buffer, ARRAY_SIZE(buffer));
17009 ok(!strcmp(buffer, "test"), "Got unexpected window text: %s.\n", buffer);
17010
17011 SetRect(&default_rect, 0, 0, 100, 100);
17012 res = DefWindowProcW(hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&default_rect);
17013 ok(!res, "Got unexpected result %Id.\n", res);
17014
17015 SetRect(&rect, 0, 0, 100, 100);
17016 res = CallWindowProcA(desktop_proc, hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rect);
17017 ok(!res, "Got unexpected result %Id.\n", res);
17018 todo_wine ok(EqualRect(&rect, &default_rect), "rect Got %s, expected %s.\n",
17019 wine_dbgstr_rect(&rect), wine_dbgstr_rect(&default_rect));
17020
17021 DestroyWindow(hwnd);
17022
17023 out_unregister:
17024 UnregisterClassA("TestDesktopClass", instance);
17025 }
17026
17027 #define clear_clipboard(hwnd) clear_clipboard_(__LINE__, (hwnd))
17028 static void clear_clipboard_(int line, HWND hWnd)
17029 {
17030 BOOL succ;
17031 succ = OpenClipboard(hWnd);
17032 ok_(__FILE__, line)(succ, "OpenClipboard failed, err=%lu\n", GetLastError());
17033 succ = EmptyClipboard();
17034 ok_(__FILE__, line)(succ, "EmptyClipboard failed, err=%lu\n", GetLastError());
17035 succ = CloseClipboard();
17036 ok_(__FILE__, line)(succ, "CloseClipboard failed, err=%lu\n", GetLastError());
17037 }
17038
17039 #define expect_HWND(expected, got) expect_HWND_(__LINE__, (expected), (got))
17040 static void expect_HWND_(int line, HWND expected, HWND got)
17041 {
17042 ok_(__FILE__, line)(got==expected, "Expected %p, got %p\n", expected, got);
17043 }
17044
17045 static WNDPROC pOldViewerProc;
17046
17047 static LRESULT CALLBACK recursive_viewer_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
17048 {
17049 static BOOL recursion_guard;
17050
17051 if (message == WM_DRAWCLIPBOARD && !recursion_guard)
17052 {
17053 recursion_guard = TRUE;
17054 clear_clipboard(hWnd);
17055 recursion_guard = FALSE;
17056 }
17057 return CallWindowProcA(pOldViewerProc, hWnd, message, wParam, lParam);
17058 }
17059
17060 static void test_clipboard_viewers(void)
17061 {
17062 static struct message wm_change_cb_chain[] =
17063 {
17064 { WM_CHANGECBCHAIN, sent|wparam|lparam, 0, 0 },
17065 { 0 }
17066 };
17067 static const struct message wm_clipboard_destroyed[] =
17068 {
17069 { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
17070 { 0 }
17071 };
17072 static struct message wm_clipboard_changed[] =
17073 {
17074 { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
17075 { 0 }
17076 };
17077 static struct message wm_clipboard_changed_and_owned[] =
17078 {
17079 { WM_DESTROYCLIPBOARD, sent|wparam|lparam, 0, 0 },
17080 { WM_DRAWCLIPBOARD, sent|wparam|lparam, 0, 0 },
17081 { 0 }
17082 };
17083
17084 HINSTANCE hInst = GetModuleHandleA(NULL);
17085 HWND hWnd1, hWnd2, hWnd3;
17086 HWND hOrigViewer;
17087 HWND hRet;
17088
17089 hWnd1 = CreateWindowExA(0, "TestWindowClass", "Clipboard viewer test wnd 1",
17090 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
17091 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
17092 GetDesktopWindow(), NULL, hInst, NULL);
17093 hWnd2 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 2",
17094 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
17095 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
17096 GetDesktopWindow(), NULL, hInst, NULL);
17097 hWnd3 = CreateWindowExA(0, "SimpleWindowClass", "Clipboard viewer test wnd 3",
17098 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
17099 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
17100 GetDesktopWindow(), NULL, hInst, NULL);
17101 if (winetest_debug > 1) trace("clipbd viewers: hWnd1=%p, hWnd2=%p, hWnd3=%p\n", hWnd1, hWnd2, hWnd3);
17102 assert(hWnd1 && hWnd2 && hWnd3);
17103
17104 CountClipboardFormats(); /* Ensure that we do not have an X11 update to the clipboard */
17105 flush_sequence();
17106
17107 /* Test getting the clipboard viewer and setting the viewer to NULL. */
17108 hOrigViewer = GetClipboardViewer();
17109 hRet = SetClipboardViewer(NULL);
17110 ok_sequence(WmEmptySeq, "set viewer to NULL", FALSE);
17111 expect_HWND(hOrigViewer, hRet);
17112 expect_HWND(NULL, GetClipboardViewer());
17113
17114 /* Test registering hWnd1 as a viewer. */
17115 hRet = SetClipboardViewer(hWnd1);
17116 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
17117 ok_sequence(wm_clipboard_changed, "set viewer NULL->1", FALSE);
17118 expect_HWND(NULL, hRet);
17119 expect_HWND(hWnd1, GetClipboardViewer());
17120
17121 /* Test that changing the clipboard actually refreshes the registered viewer. */
17122 clear_clipboard(hWnd1);
17123 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
17124 ok_sequence(wm_clipboard_changed, "clear clipbd (viewer=owner=1)", FALSE);
17125
17126 /* Again, but with different owner. */
17127 clear_clipboard(hWnd2);
17128 wm_clipboard_changed_and_owned[1].wParam = (WPARAM) GetClipboardOwner();
17129 ok_sequence(wm_clipboard_changed_and_owned, "clear clipbd (viewer=1, owner=2)", FALSE);
17130
17131 /* Test re-registering same window. */
17132 hRet = SetClipboardViewer(hWnd1);
17133 wm_clipboard_changed[0].wParam = (WPARAM) GetClipboardOwner();
17134 ok_sequence(wm_clipboard_changed, "set viewer 1->1", FALSE);
17135 expect_HWND(hWnd1, hRet);
17136 expect_HWND(hWnd1, GetClipboardViewer());
17137
17138 /* Test ChangeClipboardChain. */
17139 ChangeClipboardChain(hWnd2, hWnd3);
17140 wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
17141 wm_change_cb_chain[0].lParam = (LPARAM) hWnd3;
17142 ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=3)", FALSE);
17143 expect_HWND(hWnd1, GetClipboardViewer());
17144
17145 ChangeClipboardChain(hWnd2, NULL);
17146 wm_change_cb_chain[0].wParam = (WPARAM) hWnd2;
17147 wm_change_cb_chain[0].lParam = 0;
17148 ok_sequence(wm_change_cb_chain, "change chain (viewer=1, remove=2, next=NULL)", FALSE);
17149 expect_HWND(hWnd1, GetClipboardViewer());
17150
17151 ChangeClipboardChain(NULL, hWnd2);
17152 ok_sequence(WmEmptySeq, "change chain (viewer=1, remove=NULL, next=2)", FALSE);
17153 expect_HWND(hWnd1, GetClipboardViewer());
17154
17155 /* Actually change clipboard viewer with ChangeClipboardChain. */
17156 ChangeClipboardChain(hWnd1, hWnd2);
17157 ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=2)", FALSE);
17158 expect_HWND(hWnd2, GetClipboardViewer());
17159
17160 /* Test that no refresh messages are sent when viewer has unregistered. */
17161 clear_clipboard(hWnd2);
17162 ok_sequence(WmEmptySeq, "clear clipd (viewer=2, owner=1)", FALSE);
17163
17164 /* Register hWnd1 again. */
17165 ChangeClipboardChain(hWnd2, hWnd1);
17166 ok_sequence(WmEmptySeq, "change chain (viewer=remove=2, next=1)", FALSE);
17167 expect_HWND(hWnd1, GetClipboardViewer());
17168
17169 /* Subclass hWnd1 so that when it receives a WM_DRAWCLIPBOARD message, it
17170 * changes the clipboard. When this happens, the system shouldn't send
17171 * another WM_DRAWCLIPBOARD (as this could cause an infinite loop).
17172 */
17173 pOldViewerProc = (WNDPROC) SetWindowLongPtrA(hWnd1, GWLP_WNDPROC, (LONG_PTR) recursive_viewer_proc);
17174 clear_clipboard(hWnd2);
17175 /* The clipboard owner is changed in recursive_viewer_proc: */
17176 wm_clipboard_changed[0].wParam = (WPARAM) hWnd2;
17177 ok_sequence(wm_clipboard_changed, "recursive clear clipbd (viewer=1, owner=2)", TRUE);
17178
17179 /* Test unregistering. */
17180 ChangeClipboardChain(hWnd1, NULL);
17181 ok_sequence(WmEmptySeq, "change chain (viewer=remove=1, next=NULL)", FALSE);
17182 expect_HWND(NULL, GetClipboardViewer());
17183
17184 clear_clipboard(hWnd1);
17185 ok_sequence(wm_clipboard_destroyed, "clear clipbd (no viewer, owner=1)", FALSE);
17186
17187 DestroyWindow(hWnd1);
17188 DestroyWindow(hWnd2);
17189 DestroyWindow(hWnd3);
17190 SetClipboardViewer(hOrigViewer);
17191 }
17192
17193 static void test_PostMessage(void)
17194 {
17195 static const struct
17196 {
17197 HWND hwnd;
17198 BOOL ret;
17199 } data[] =
17200 {
17201 { HWND_TOP /* 0 */, TRUE },
17202 { HWND_BROADCAST, TRUE },
17203 { HWND_BOTTOM, TRUE },
17204 { HWND_TOPMOST, TRUE },
17205 { HWND_NOTOPMOST, FALSE },
17206 { HWND_MESSAGE, FALSE },
17207 { (HWND)0xdeadbeef, FALSE }
17208 };
17209 int i;
17210 HWND hwnd;
17211 BOOL ret;
17212 MSG msg;
17213 static const WCHAR staticW[] = {'s','t','a','t','i','c',0};
17214
17215 SetLastError(0xdeadbeef);
17216 hwnd = CreateWindowExW(0, staticW, NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
17217 if (!hwnd && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
17218 {
17219 win_skip("Skipping some PostMessage tests on Win9x/WinMe\n");
17220 return;
17221 }
17222 assert(hwnd);
17223
17224 flush_events();
17225
17226 PostMessageA(hwnd, WM_USER+1, 0x1234, 0x5678);
17227 PostMessageA(0, WM_USER+2, 0x5678, 0x1234);
17228
17229 for (i = 0; i < ARRAY_SIZE(data); i++)
17230 {
17231 memset(&msg, 0xab, sizeof(msg));
17232 ret = PeekMessageA(&msg, data[i].hwnd, 0, 0, PM_NOREMOVE);
17233 ok(ret == data[i].ret, "%d: hwnd %p expected %d, got %d\n", i, data[i].hwnd, data[i].ret, ret);
17234 if (data[i].ret)
17235 {
17236 if (data[i].hwnd)
17237 ok(ret && msg.hwnd == 0 && msg.message == WM_USER+2 &&
17238 msg.wParam == 0x5678 && msg.lParam == 0x1234,
17239 "%d: got ret %d hwnd %p msg %04x wParam %08Ix lParam %08Ix instead of TRUE/0/WM_USER+2/0x5678/0x1234\n",
17240 i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam);
17241 else
17242 ok(ret && msg.hwnd == hwnd && msg.message == WM_USER+1 &&
17243 msg.wParam == 0x1234 && msg.lParam == 0x5678,
17244 "%d: got ret %d hwnd %p msg %04x wParam %08Ix lParam %08Ix instead of TRUE/%p/WM_USER+1/0x1234/0x5678\n",
17245 i, ret, msg.hwnd, msg.message, msg.wParam, msg.lParam, msg.hwnd);
17246 }
17247 }
17248
17249 DestroyWindow(hwnd);
17250 flush_events();
17251 }
17252
17253 static WPARAM g_broadcast_wparam;
17254 static LRESULT WINAPI broadcast_test_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
17255 {
17256 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
17257
17258 if (wParam == 0xbaadbeef)
17259 g_broadcast_wparam = wParam;
17260 else
17261 g_broadcast_wparam = 0;
17262
17263 return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
17264 }
17265 static WNDPROC *g_oldproc_sub;
17266 static WPARAM *g_broadcast_sub_wparam;
17267 static LRESULT WINAPI broadcast_test_sub_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
17268 {
17269 int sub_index = GetWindowLongPtrA(hwnd, GWLP_USERDATA);
17270
17271 g_broadcast_sub_wparam[sub_index] = (wParam == 0xbaadbeef) ? wParam : 0;
17272
17273 return CallWindowProcA(g_oldproc_sub[sub_index], hwnd, message, wParam, lParam);
17274 }
17275
17276 static void test_broadcast(void)
17277 {
17278 static const UINT messages[] =
17279 {
17280 WM_USER-1,
17281 WM_USER,
17282 WM_USER+1,
17283 0xc000-1,
17284 0xc000, /* lowest possible atom returned by RegisterWindowMessage */
17285 0xffff,
17286 };
17287 static const struct
17288 {
17289 LONG style;
17290 BOOL receive;
17291 } bcast_expect[] =
17292 {
17293 {WS_OVERLAPPED, TRUE},
17294 {WS_OVERLAPPED|WS_DLGFRAME, TRUE},
17295 {WS_OVERLAPPED|WS_BORDER, TRUE},
17296 {WS_OVERLAPPED|WS_CAPTION, TRUE},
17297 {WS_CHILD, FALSE},
17298 {WS_CHILD|WS_DLGFRAME, FALSE},
17299 {WS_CHILD|WS_BORDER, FALSE},
17300 {WS_CHILD|WS_CAPTION, FALSE},
17301 {WS_CHILD|WS_POPUP, TRUE},
17302 {WS_POPUP, TRUE},
17303 {WS_POPUP|WS_DLGFRAME, TRUE},
17304 {WS_POPUP|WS_BORDER, TRUE},
17305 {WS_POPUP|WS_CAPTION, TRUE},
17306 };
17307 WNDPROC oldproc;
17308 unsigned int i, j;
17309 HWND hwnd;
17310 HWND *hwnd_sub;
17311
17312 hwnd_sub = HeapAlloc( GetProcessHeap(), 0, ARRAY_SIZE(bcast_expect) * sizeof(*hwnd_sub) );
17313 g_oldproc_sub = HeapAlloc( GetProcessHeap(), 0, ARRAY_SIZE(bcast_expect) * sizeof(*g_oldproc_sub) );
17314 g_broadcast_sub_wparam = HeapAlloc( GetProcessHeap(), 0, ARRAY_SIZE(bcast_expect) * sizeof(*g_broadcast_sub_wparam) );
17315
17316 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, NULL);
17317 ok(hwnd != NULL, "got %p\n", hwnd);
17318
17319 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)broadcast_test_proc);
17320 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
17321
17322 for (i = 0; i < ARRAY_SIZE(messages); i++)
17323 {
17324 BOOL ret;
17325 BOOL msg_expected = (messages[i] < WM_USER || messages[i] >= 0xc000);
17326 MSG msg;
17327
17328 flush_events();
17329 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
17330 ;
17331
17332 /* post, broadcast */
17333 ret = PostMessageA(HWND_BROADCAST, messages[i], 0, 0);
17334 ok(ret, "%d: got %d, error %ld\n", i, ret, GetLastError());
17335
17336 memset(&msg, 0xab, sizeof(msg));
17337 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
17338 ok(ret == msg_expected, "%d: message %04x, got %d, error %ld\n", i, messages[i], ret, GetLastError());
17339 if (msg_expected)
17340 ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
17341
17342 /* post, topmost */
17343 ret = PostMessageA(HWND_TOPMOST, messages[i], 0, 0);
17344 ok(ret, "%d: got %d, error %ld\n", i, ret, GetLastError());
17345
17346 memset(&msg, 0xab, sizeof(msg));
17347 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
17348 ok(ret == msg_expected, "%d: message %04x, got %d, error %ld\n", i, messages[i], ret, GetLastError());
17349 if (msg_expected)
17350 ok(msg.hwnd == hwnd, "%d: got %p\n", i, msg.hwnd);
17351 }
17352
17353 for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
17354 {
17355 hwnd_sub[j] = CreateWindowA("static", NULL, bcast_expect[j].style, 0, 0, 0, 0, hwnd, 0, 0, NULL);
17356 ok(hwnd_sub[j] != NULL, "got %p\n", hwnd_sub[j]);
17357 /* CreateWindow adds extra style flags, so call SetWindowLong to clear some of those. */
17358 SetWindowLongA(hwnd_sub[j], GWL_STYLE, bcast_expect[j].style);
17359
17360 g_oldproc_sub[j] = (WNDPROC)SetWindowLongPtrA(hwnd_sub[j], GWLP_WNDPROC, (LONG_PTR)broadcast_test_sub_proc);
17361 SetWindowLongPtrA(hwnd_sub[j], GWLP_USERDATA, (LONG_PTR)j);
17362 }
17363
17364 for (i = 0; i < ARRAY_SIZE(messages); i++)
17365 {
17366 BOOL ret;
17367 BOOL msg_expected = (messages[i] < WM_USER || messages[i] >= 0xc000);
17368
17369 /* send, broadcast */
17370 g_broadcast_wparam = 0xdead;
17371 for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
17372 g_broadcast_sub_wparam[j] = 0xdead;
17373 ret = SendMessageTimeoutA(HWND_BROADCAST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
17374 if (!ret && GetLastError() == ERROR_TIMEOUT)
17375 win_skip("broadcasting test %d, timeout\n", i);
17376 else
17377 {
17378 WPARAM wparam_expected = msg_expected ? 0xbaadbeef : 0xdead;
17379 ok(g_broadcast_wparam == wparam_expected, "%d: message %04x, got %#Ix, error %ld\n",
17380 i, messages[i], g_broadcast_wparam, GetLastError());
17381 for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
17382 {
17383 wparam_expected = (msg_expected && bcast_expect[j].receive) ? 0xbaadbeef : 0xdead;
17384 ok(g_broadcast_sub_wparam[j] == wparam_expected,
17385 "%d,%d: message %04x, got %#Ix, error %ld\n", i, j, messages[i],
17386 g_broadcast_sub_wparam[j], GetLastError());
17387 }
17388 }
17389
17390 /* send, topmost */
17391 g_broadcast_wparam = 0xdead;
17392 for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
17393 g_broadcast_sub_wparam[j] = 0xdead;
17394 ret = SendMessageTimeoutA(HWND_TOPMOST, messages[i], 0xbaadbeef, 0, SMTO_NORMAL, 2000, NULL);
17395 if (!ret && GetLastError() == ERROR_TIMEOUT)
17396 win_skip("broadcasting test %d, timeout\n", i);
17397 else
17398 {
17399 WPARAM wparam_expected = msg_expected ? 0xbaadbeef : 0xdead;
17400 ok(g_broadcast_wparam == wparam_expected, "%d: message %04x, got %#Ix, error %ld\n",
17401 i, messages[i], g_broadcast_wparam, GetLastError());
17402 for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
17403 {
17404 wparam_expected = (msg_expected && bcast_expect[j].receive) ? 0xbaadbeef : 0xdead;
17405 ok(g_broadcast_sub_wparam[j] == wparam_expected,
17406 "%d,%d: message %04x, got %#Ix, error %ld\n", i, j, messages[i],
17407 g_broadcast_sub_wparam[j], GetLastError());
17408 }
17409 }
17410 }
17411
17412 for (j = 0; j < ARRAY_SIZE(bcast_expect); j++)
17413 DestroyWindow(hwnd_sub[j]);
17414
17415 HeapFree(GetProcessHeap(), 0, g_broadcast_sub_wparam);
17416 HeapFree(GetProcessHeap(), 0, g_oldproc_sub);
17417 HeapFree(GetProcessHeap(), 0, hwnd_sub);
17418
17419 DestroyWindow(hwnd);
17420 }
17421
17422 static const struct
17423 {
17424 DWORD exp, broken;
17425 BOOL todo;
17426 } wait_idle_expect[] =
17427 {
17428 /* 0 */ { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
17429 { WAIT_TIMEOUT, 0, FALSE },
17430 { WAIT_TIMEOUT, 0, FALSE },
17431 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
17432 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
17433 /* 5 */ { WAIT_TIMEOUT, 0, FALSE },
17434 { WAIT_TIMEOUT, 0, FALSE },
17435 { WAIT_TIMEOUT, WAIT_TIMEOUT, FALSE },
17436 { 0, 0, FALSE },
17437 { 0, 0, FALSE },
17438 /* 10 */ { 0, 0, FALSE },
17439 { 0, 0, FALSE },
17440 { 0, WAIT_TIMEOUT, FALSE },
17441 { 0, 0, FALSE },
17442 { 0, 0, FALSE },
17443 /* 15 */ { 0, 0, FALSE },
17444 { WAIT_TIMEOUT, 0, FALSE },
17445 { WAIT_TIMEOUT, 0, FALSE },
17446 { WAIT_TIMEOUT, 0, FALSE },
17447 { WAIT_TIMEOUT, 0, FALSE },
17448 /* 20 */ { WAIT_TIMEOUT, 0, FALSE },
17449 };
17450
17451 static DWORD CALLBACK do_wait_idle_child_thread( void *arg )
17452 {
17453 MSG msg;
17454
17455 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
17456 Sleep( 200 );
17457 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
17458 return 0;
17459 }
17460
17461 static void do_wait_idle_child( int arg )
17462 {
17463 WNDCLASSA cls;
17464 MSG msg;
17465 HWND hwnd = 0;
17466 HANDLE thread;
17467 DWORD id;
17468 HANDLE start_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_start" );
17469 HANDLE end_event = OpenEventA( EVENT_ALL_ACCESS, FALSE, "test_WaitForInputIdle_end" );
17470
17471 memset( &cls, 0, sizeof(cls) );
17472 cls.lpfnWndProc = DefWindowProcA;
17473 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
17474 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
17475 cls.lpszClassName = "TestClass";
17476 RegisterClassA( &cls );
17477
17478 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ); /* create the msg queue */
17479
17480 ok( start_event != 0, "failed to create start event, error %lu\n", GetLastError() );
17481 ok( end_event != 0, "failed to create end event, error %lu\n", GetLastError() );
17482
17483 switch (arg)
17484 {
17485 case 0:
17486 SetEvent( start_event );
17487 break;
17488 case 1:
17489 SetEvent( start_event );
17490 Sleep( 200 );
17491 PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
17492 break;
17493 case 2:
17494 SetEvent( start_event );
17495 Sleep( 200 );
17496 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
17497 PostThreadMessageA( GetCurrentThreadId(), WM_COMMAND, 0x1234, 0xabcd );
17498 PeekMessageA( &msg, 0, 0, 0, PM_REMOVE );
17499 break;
17500 case 3:
17501 SetEvent( start_event );
17502 Sleep( 200 );
17503 SendMessageA( HWND_BROADCAST, WM_WININICHANGE, 0, 0 );
17504 break;
17505 case 4:
17506 SetEvent( start_event );
17507 Sleep( 200 );
17508 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
17509 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
17510 break;
17511 case 5:
17512 SetEvent( start_event );
17513 Sleep( 200 );
17514 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
17515 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
17516 break;
17517 case 6:
17518 SetEvent( start_event );
17519 Sleep( 200 );
17520 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
17521 while (PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ))
17522 {
17523 GetMessageA( &msg, 0, 0, 0 );
17524 DispatchMessageA( &msg );
17525 }
17526 break;
17527 case 7:
17528 SetEvent( start_event );
17529 Sleep( 200 );
17530 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
17531 SetTimer( hwnd, 3, 1, NULL );
17532 Sleep( 200 );
17533 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE|PM_NOYIELD )) DispatchMessageA( &msg );
17534 break;
17535 case 8:
17536 SetEvent( start_event );
17537 Sleep( 200 );
17538 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
17539 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
17540 break;
17541 case 9:
17542 SetEvent( start_event );
17543 Sleep( 200 );
17544 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
17545 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
17546 for (;;) GetMessageA( &msg, 0, 0, 0 );
17547 break;
17548 case 10:
17549 SetEvent( start_event );
17550 Sleep( 200 );
17551 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP|WS_VISIBLE, 0, 0, 10, 10, 0, 0, 0, NULL);
17552 SetTimer( hwnd, 3, 1, NULL );
17553 Sleep( 200 );
17554 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
17555 break;
17556 case 11:
17557 SetEvent( start_event );
17558 Sleep( 200 );
17559 return; /* exiting the process makes WaitForInputIdle return success too */
17560 case 12:
17561 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
17562 Sleep( 200 );
17563 MsgWaitForMultipleObjects( 0, NULL, FALSE, 100, QS_ALLINPUT );
17564 SetEvent( start_event );
17565 break;
17566 case 13:
17567 SetEvent( start_event );
17568 PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );
17569 Sleep( 200 );
17570 thread = CreateThread( NULL, 0, do_wait_idle_child_thread, NULL, 0, &id );
17571 WaitForSingleObject( thread, 10000 );
17572 CloseHandle( thread );
17573 break;
17574 case 14:
17575 SetEvent( start_event );
17576 Sleep( 200 );
17577 PeekMessageA( &msg, HWND_TOPMOST, 0, 0, PM_NOREMOVE );
17578 break;
17579 case 15:
17580 SetEvent( start_event );
17581 Sleep( 200 );
17582 PeekMessageA( &msg, HWND_BROADCAST, 0, 0, PM_NOREMOVE );
17583 break;
17584 case 16:
17585 SetEvent( start_event );
17586 Sleep( 200 );
17587 PeekMessageA( &msg, HWND_BOTTOM, 0, 0, PM_NOREMOVE );
17588 break;
17589 case 17:
17590 SetEvent( start_event );
17591 Sleep( 200 );
17592 PeekMessageA( &msg, (HWND)0xdeadbeef, 0, 0, PM_NOREMOVE );
17593 break;
17594 case 18:
17595 SetEvent( start_event );
17596 Sleep( 200 );
17597 PeekMessageA( &msg, HWND_NOTOPMOST, 0, 0, PM_NOREMOVE );
17598 break;
17599 case 19:
17600 SetEvent( start_event );
17601 Sleep( 200 );
17602 PeekMessageA( &msg, HWND_MESSAGE, 0, 0, PM_NOREMOVE );
17603 break;
17604 case 20:
17605 SetEvent( start_event );
17606 Sleep( 200 );
17607 PeekMessageA( &msg, GetDesktopWindow(), 0, 0, PM_NOREMOVE );
17608 break;
17609 }
17610 WaitForSingleObject( end_event, 2000 );
17611 CloseHandle( start_event );
17612 CloseHandle( end_event );
17613 if (hwnd) DestroyWindow( hwnd );
17614 }
17615
17616 static LRESULT CALLBACK wait_idle_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
17617 {
17618 if (msg == WM_WININICHANGE) Sleep( 200 ); /* make sure the child waits */
17619 return DefWindowProcA( hwnd, msg, wp, lp );
17620 }
17621
17622 static DWORD CALLBACK wait_idle_thread( void *arg )
17623 {
17624 WNDCLASSA cls;
17625 MSG msg;
17626 HWND hwnd;
17627
17628 memset( &cls, 0, sizeof(cls) );
17629 cls.lpfnWndProc = wait_idle_proc;
17630 cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
17631 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
17632 cls.lpszClassName = "TestClass";
17633 RegisterClassA( &cls );
17634
17635 hwnd = CreateWindowExA(0, "TestClass", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL);
17636 while (GetMessageA( &msg, 0, 0, 0 )) DispatchMessageA( &msg );
17637 DestroyWindow(hwnd);
17638 return 0;
17639 }
17640
17641 static void test_WaitForInputIdle( char *argv0 )
17642 {
17643 char path[MAX_PATH];
17644 PROCESS_INFORMATION pi;
17645 STARTUPINFOA startup;
17646 BOOL ret;
17647 HANDLE start_event, end_event, thread;
17648 unsigned int i;
17649 DWORD id;
17650 const IMAGE_DOS_HEADER *dos = (const IMAGE_DOS_HEADER *)GetModuleHandleA(0);
17651 const IMAGE_NT_HEADERS *nt = (const IMAGE_NT_HEADERS *)((const char *)dos + dos->e_lfanew);
17652 BOOL console_app = (nt->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_GUI);
17653
17654 if (console_app) /* build the test with -mwindows for better coverage */
17655 trace( "not built as a GUI app, WaitForInputIdle may not be fully tested\n" );
17656
17657 start_event = CreateEventA(NULL, 0, 0, "test_WaitForInputIdle_start");
17658 end_event = CreateEventA(NULL, 0, 0, "test_WaitForInputIdle_end");
17659 ok(start_event != 0, "failed to create start event, error %lu\n", GetLastError());
17660 ok(end_event != 0, "failed to create end event, error %lu\n", GetLastError());
17661
17662 memset( &startup, 0, sizeof(startup) );
17663 startup.cb = sizeof(startup);
17664 startup.dwFlags = STARTF_USESHOWWINDOW;
17665 startup.wShowWindow = SW_SHOWNORMAL;
17666
17667 thread = CreateThread( NULL, 0, wait_idle_thread, NULL, 0, &id );
17668
17669 for (i = 0; i < ARRAY_SIZE(wait_idle_expect); i++)
17670 {
17671 ResetEvent( start_event );
17672 ResetEvent( end_event );
17673 sprintf( path, "%s msg %u", argv0, i );
17674 ret = CreateProcessA( NULL, path, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &pi );
17675 ok( ret, "CreateProcess '%s' failed err %lu.\n", path, GetLastError() );
17676 if (ret)
17677 {
17678 ret = WaitForSingleObject( start_event, 5000 );
17679 ok( ret == WAIT_OBJECT_0, "%u: WaitForSingleObject failed\n", i );
17680 if (ret == WAIT_OBJECT_0)
17681 {
17682 ret = WaitForInputIdle( pi.hProcess, 1000 );
17683 if (ret == WAIT_FAILED)
17684 ok( console_app ||
17685 ret == wait_idle_expect[i].exp ||
17686 broken(ret == wait_idle_expect[i].broken),
17687 "%u: WaitForInputIdle error %08x expected %08lx\n",
17688 i, ret, wait_idle_expect[i].exp );
17689 else todo_wine_if (wait_idle_expect[i].todo)
17690 ok( ret == wait_idle_expect[i].exp || broken(ret == wait_idle_expect[i].broken),
17691 "%u: WaitForInputIdle error %08x expected %08lx\n",
17692 i, ret, wait_idle_expect[i].exp );
17693 SetEvent( end_event );
17694 WaitForSingleObject( pi.hProcess, 1000 ); /* give it a chance to exit on its own */
17695 }
17696 TerminateProcess( pi.hProcess, 0 ); /* just in case */
17697 wait_child_process( pi.hProcess );
17698 ret = WaitForInputIdle( pi.hProcess, 100 );
17699 ok( ret == WAIT_FAILED, "%u: WaitForInputIdle after exit error %08x\n", i, ret );
17700 CloseHandle( pi.hProcess );
17701 CloseHandle( pi.hThread );
17702 }
17703 }
17704 CloseHandle( end_event );
17705 CloseHandle( start_event );
17706 PostThreadMessageA( id, WM_QUIT, 0, 0 );
17707 WaitForSingleObject( thread, 10000 );
17708 CloseHandle( thread );
17709 }
17710
17711 static const struct message WmSetParentSeq_1[] = {
17712 { WM_SHOWWINDOW, sent|wparam, 0 },
17713 { EVENT_OBJECT_PARENTCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
17714 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
17715 { WM_CHILDACTIVATE, sent },
17716 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOCLIENTSIZE },
17717 { WM_MOVE, sent|defwinproc|wparam, 0 },
17718 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
17719 { WM_SHOWWINDOW, sent|wparam, 1 },
17720 { 0 }
17721 };
17722
17723 static const struct message WmSetParentSeq_2[] = {
17724 { WM_SHOWWINDOW, sent|wparam, 0 },
17725 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
17726 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
17727 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
17728 { HCBT_SETFOCUS, hook|optional },
17729 { WM_NCACTIVATE, sent|wparam|optional, 0 },
17730 { WM_ACTIVATE, sent|wparam|optional, 0 },
17731 { WM_ACTIVATEAPP, sent|wparam|optional, 0 },
17732 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
17733 { WM_KILLFOCUS, sent|wparam, 0 },
17734 { EVENT_OBJECT_PARENTCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
17735 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
17736 { HCBT_ACTIVATE, hook|optional },
17737 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|optional, 0, 0 },
17738 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
17739 { WM_NCACTIVATE, sent|wparam|optional, 1 },
17740 { WM_ACTIVATE, sent|wparam|optional, 1 },
17741 { HCBT_SETFOCUS, hook|optional },
17742 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
17743 { WM_SETFOCUS, sent|optional|defwinproc },
17744 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOCLIENTSIZE },
17745 { WM_MOVE, sent|defwinproc|wparam, 0 },
17746 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
17747 { WM_SHOWWINDOW, sent|wparam, 1 },
17748 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
17749 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
17750 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
17751 { 0 }
17752 };
17753
17754
17755 static void test_SetParent(void)
17756 {
17757 HWND parent1, parent2, child, popup;
17758 RECT rc, rc_old;
17759
17760 parent1 = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
17761 100, 100, 200, 200, 0, 0, 0, NULL);
17762 ok(parent1 != 0, "Failed to create parent1 window\n");
17763
17764 parent2 = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
17765 400, 100, 200, 200, 0, 0, 0, NULL);
17766 ok(parent2 != 0, "Failed to create parent2 window\n");
17767
17768 /* WS_CHILD window */
17769 child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD | WS_VISIBLE,
17770 10, 10, 150, 150, parent1, 0, 0, NULL);
17771 ok(child != 0, "Failed to create child window\n");
17772
17773 GetWindowRect(parent1, &rc);
17774 if (winetest_debug > 1) trace("parent1 %s\n", wine_dbgstr_rect(&rc));
17775 GetWindowRect(child, &rc_old);
17776 MapWindowPoints(0, parent1, (POINT *)&rc_old, 2);
17777 if (winetest_debug > 1) trace("child %s\n", wine_dbgstr_rect(&rc_old));
17778
17779 flush_sequence();
17780
17781 SetParent(child, parent2);
17782 flush_events();
17783 ok_sequence(WmSetParentSeq_1, "SetParent() visible WS_CHILD", FALSE);
17784
17785 ok(GetWindowLongA(child, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
17786 ok(!IsWindowVisible(child), "IsWindowVisible() should return FALSE\n");
17787
17788 GetWindowRect(parent2, &rc);
17789 if (winetest_debug > 1) trace("parent2 %s\n", wine_dbgstr_rect(&rc));
17790 GetWindowRect(child, &rc);
17791 MapWindowPoints(0, parent2, (POINT *)&rc, 2);
17792 if (winetest_debug > 1) trace("child %s\n", wine_dbgstr_rect(&rc));
17793
17794 ok(EqualRect(&rc_old, &rc), "rects do not match %s / %s\n", wine_dbgstr_rect(&rc_old),
17795 wine_dbgstr_rect(&rc));
17796
17797 /* WS_POPUP window */
17798 popup = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP | WS_VISIBLE,
17799 20, 20, 100, 100, 0, 0, 0, NULL);
17800 ok(popup != 0, "Failed to create popup window\n");
17801
17802 GetWindowRect(popup, &rc_old);
17803 if (winetest_debug > 1) trace("popup %s\n", wine_dbgstr_rect(&rc_old));
17804
17805 flush_sequence();
17806
17807 SetParent(popup, child);
17808 flush_events();
17809 ok_sequence(WmSetParentSeq_2, "SetParent() visible WS_POPUP", TRUE);
17810
17811 ok(GetWindowLongA(popup, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
17812 ok(!IsWindowVisible(popup), "IsWindowVisible() should return FALSE\n");
17813
17814 GetWindowRect(child, &rc);
17815 if (winetest_debug > 1) trace("parent2 %s\n", wine_dbgstr_rect(&rc));
17816 GetWindowRect(popup, &rc);
17817 MapWindowPoints(0, child, (POINT *)&rc, 2);
17818 if (winetest_debug > 1) trace("popup %s\n", wine_dbgstr_rect(&rc));
17819
17820 ok(EqualRect(&rc_old, &rc), "rects do not match %s / %s\n", wine_dbgstr_rect(&rc_old),
17821 wine_dbgstr_rect(&rc));
17822
17823 DestroyWindow(popup);
17824 DestroyWindow(child);
17825 DestroyWindow(parent1);
17826 DestroyWindow(parent2);
17827
17828 flush_sequence();
17829 }
17830
17831 static const struct message WmKeyReleaseOnly[] = {
17832 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x80000001 },
17833 { WM_KEYUP, sent|wparam|lparam, 0x41, 0x80000001 },
17834 { 0 }
17835 };
17836 static const struct message WmKeyPressNormal[] = {
17837 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x1 },
17838 { WM_KEYDOWN, sent|wparam|lparam, 0x41, 0x1 },
17839 { 0 }
17840 };
17841 static const struct message WmKeyPressRepeat[] = {
17842 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0x40000001 },
17843 { WM_KEYDOWN, sent|wparam|lparam, 0x41, 0x40000001 },
17844 { 0 }
17845 };
17846 static const struct message WmKeyReleaseNormal[] = {
17847 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 0x41, 0xc0000001 },
17848 { WM_KEYUP, sent|wparam|lparam, 0x41, 0xc0000001 },
17849 { 0 }
17850 };
17851
17852 static void test_keyflags(void)
17853 {
17854 HWND test_window;
17855 SHORT key_state;
17856 BYTE keyboard_state[256];
17857 MSG msg;
17858
17859 test_window = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
17860 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
17861 0, 0, 0, NULL);
17862
17863 flush_events();
17864 flush_sequence();
17865
17866 /* keyup without a keydown */
17867 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
17868 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
17869 DispatchMessageA(&msg);
17870 ok_sequence(WmKeyReleaseOnly, "key release only", TRUE);
17871
17872 key_state = GetAsyncKeyState(0x41);
17873 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17874
17875 key_state = GetKeyState(0x41);
17876 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17877
17878 /* keydown */
17879 keybd_event(0x41, 0, 0, 0);
17880 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
17881 DispatchMessageA(&msg);
17882 ok_sequence(WmKeyPressNormal, "key press only", FALSE);
17883
17884 key_state = GetAsyncKeyState(0x41);
17885 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17886
17887 key_state = GetKeyState(0x41);
17888 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17889
17890 /* keydown repeat */
17891 keybd_event(0x41, 0, 0, 0);
17892 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
17893 DispatchMessageA(&msg);
17894 ok_sequence(WmKeyPressRepeat, "key press repeat", FALSE);
17895
17896 key_state = GetAsyncKeyState(0x41);
17897 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17898
17899 key_state = GetKeyState(0x41);
17900 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17901
17902 /* keyup */
17903 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
17904 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
17905 DispatchMessageA(&msg);
17906 ok_sequence(WmKeyReleaseNormal, "key release repeat", FALSE);
17907
17908 key_state = GetAsyncKeyState(0x41);
17909 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17910
17911 key_state = GetKeyState(0x41);
17912 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17913
17914 /* set the key state in this thread */
17915 GetKeyboardState(keyboard_state);
17916 keyboard_state[0x41] = 0x80;
17917 SetKeyboardState(keyboard_state);
17918
17919 key_state = GetAsyncKeyState(0x41);
17920 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17921
17922 /* keydown */
17923 keybd_event(0x41, 0, 0, 0);
17924 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
17925 DispatchMessageA(&msg);
17926 ok_sequence(WmKeyPressRepeat, "key press after setkeyboardstate", TRUE);
17927
17928 key_state = GetAsyncKeyState(0x41);
17929 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17930
17931 key_state = GetKeyState(0x41);
17932 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17933
17934 /* clear the key state in this thread */
17935 GetKeyboardState(keyboard_state);
17936 keyboard_state[0x41] = 0;
17937 SetKeyboardState(keyboard_state);
17938
17939 key_state = GetAsyncKeyState(0x41);
17940 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
17941
17942 /* keyup */
17943 keybd_event(0x41, 0, KEYEVENTF_KEYUP, 0);
17944 while (PeekMessageA(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE))
17945 DispatchMessageA(&msg);
17946 ok_sequence(WmKeyReleaseOnly, "key release after setkeyboardstate", TRUE);
17947
17948 key_state = GetAsyncKeyState(0x41);
17949 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17950
17951 key_state = GetKeyState(0x41);
17952 ok((key_state & 0x8000) == 0, "unexpected key state %x\n", key_state);
17953
17954 DestroyWindow(test_window);
17955 flush_sequence();
17956 }
17957
17958 static const struct message WmHotkeyPressLWIN[] = {
17959 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
17960 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
17961 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
17962 { 0 }
17963 };
17964 static const struct message WmHotkeyPress[] = {
17965 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
17966 { WM_HOTKEY, sent|wparam, 5 },
17967 { 0 }
17968 };
17969 static const struct message WmHotkeyRelease[] = {
17970 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
17971 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 0x80000001 },
17972 { WM_KEYUP, sent|lparam, 0, 0x80000001 },
17973 { 0 }
17974 };
17975 static const struct message WmHotkeyReleaseLWIN[] = {
17976 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
17977 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
17978 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
17979 { 0 }
17980 };
17981 static const struct message WmHotkeyCombined[] = {
17982 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
17983 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
17984 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
17985 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
17986 { WM_APP, sent, 0, 0 },
17987 { WM_HOTKEY, sent|wparam, 5 },
17988 { WM_APP+1, sent, 0, 0 },
17989 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
17990 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
17991 { HCBT_KEYSKIPPED, hook|optional, 0, 0x80000001 },
17992 { WM_KEYUP, sent, 0, 0x80000001 }, /* lparam not checked so the sequence isn't a todo */
17993 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
17994 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
17995 { 0 }
17996 };
17997 static const struct message WmHotkeyPrevious[] = {
17998 { WM_KEYDOWN, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED },
17999 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
18000 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
18001 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LWIN, LLKHF_INJECTED|LLKHF_UP },
18002 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 1 },
18003 { WM_KEYDOWN, sent|wparam|lparam, VK_LWIN, 1 },
18004 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 1 },
18005 { WM_KEYDOWN, sent|lparam, 0, 1 },
18006 { HCBT_KEYSKIPPED, hook|optional|lparam, 0, 0xc0000001 },
18007 { WM_KEYUP, sent|lparam, 0, 0xc0000001 },
18008 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_LWIN, 0xc0000001 },
18009 { WM_KEYUP, sent|wparam|lparam, VK_LWIN, 0xc0000001 },
18010 { 0 }
18011 };
18012 static const struct message WmHotkeyNew[] = {
18013 { WM_KEYDOWN, kbd_hook|lparam, 0, LLKHF_INJECTED },
18014 { WM_KEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP },
18015 { WM_HOTKEY, sent|wparam, 5 },
18016 { HCBT_KEYSKIPPED, hook|optional, 0, 0x80000001 },
18017 { WM_KEYUP, sent, 0, 0x80000001 }, /* lparam not checked so the sequence isn't a todo */
18018 { 0 }
18019 };
18020 static const struct message WmHotkeyPressALT[] = {
18021 { WM_SYSKEYDOWN, kbd_hook|wparam|lparam, VK_LMENU, LLKHF_INJECTED|LLKHF_ALTDOWN },
18022 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
18023 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
18024 { 0 }
18025 };
18026 static const struct message WmHotkeyPressWithALT[] = {
18027 { WM_SYSKEYDOWN, kbd_hook, 0, LLKHF_INJECTED|LLKHF_ALTDOWN }, /* lparam not checked */
18028 { WM_HOTKEY, sent|wparam, 6 },
18029 { 0 }
18030 };
18031 static const struct message WmHotkeyReleaseWithALT[] = {
18032 { WM_SYSKEYUP, kbd_hook|lparam, 0, LLKHF_INJECTED|LLKHF_UP|LLKHF_ALTDOWN },
18033 { HCBT_KEYSKIPPED, hook|lparam|optional, 0, 0xa0000001 },
18034 { WM_SYSKEYUP, sent|lparam, 0, 0xa0000001 },
18035 { 0 }
18036 };
18037 static const struct message WmHotkeyReleaseALT[] = {
18038 { WM_KEYUP, kbd_hook|wparam|lparam, VK_LMENU, LLKHF_INJECTED|LLKHF_UP },
18039 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 },
18040 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
18041 { 0 }
18042 };
18043
18044 static int hotkey_letter;
18045
18046 static LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam)
18047 {
18048 struct recvd_message msg;
18049
18050 if (nCode == HC_ACTION)
18051 {
18052 KBDLLHOOKSTRUCT *kdbhookstruct = (KBDLLHOOKSTRUCT*)lParam;
18053
18054 msg.hwnd = 0;
18055 msg.message = wParam;
18056 msg.flags = kbd_hook|wparam|lparam;
18057 msg.wParam = kdbhookstruct->vkCode;
18058 msg.lParam = kdbhookstruct->flags;
18059 msg.descr = "KeyboardHookProc";
18060 add_message(&msg);
18061
18062 if (wParam == WM_KEYUP || wParam == WM_KEYDOWN ||
18063 wParam == WM_SYSKEYUP || wParam == WM_SYSKEYDOWN)
18064 {
18065 ok(kdbhookstruct->vkCode == VK_LWIN ||
18066 kdbhookstruct->vkCode == VK_LMENU ||
18067 kdbhookstruct->vkCode == hotkey_letter,
18068 "unexpected keycode %lx\n", kdbhookstruct->vkCode);
18069 }
18070 }
18071
18072 return CallNextHookEx(hKBD_hook, nCode, wParam, lParam);
18073 }
18074
18075 static void test_hotkey(void)
18076 {
18077 HWND test_window, taskbar_window;
18078 BOOL ret;
18079 MSG msg;
18080 DWORD queue_status;
18081 SHORT key_state;
18082
18083 SetLastError(0xdeadbeef);
18084 ret = UnregisterHotKey(NULL, 0);
18085 if (ret == TRUE)
18086 {
18087 skip("hotkeys not supported\n");
18088 return;
18089 }
18090
18091 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18092 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18093 "unexpected error %ld\n", GetLastError());
18094
18095 test_window = CreateWindowExA(0, "HotkeyWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
18096 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
18097 0, 0, 0, NULL);
18098
18099 SetForegroundWindow(test_window);
18100 flush_events();
18101 flush_sequence();
18102
18103 SetLastError(0xdeadbeef);
18104 ret = UnregisterHotKey(test_window, 0);
18105 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18106 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18107 "unexpected error %ld\n", GetLastError());
18108
18109 /* Search for a Windows Key + letter combination that hasn't been registered */
18110 for (hotkey_letter = 0x41; hotkey_letter <= 0x51; hotkey_letter ++)
18111 {
18112 SetLastError(0xdeadbeef);
18113 ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
18114
18115 if (ret == TRUE)
18116 {
18117 break;
18118 }
18119 else
18120 {
18121 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18122 "unexpected error %ld\n", GetLastError());
18123 }
18124 }
18125
18126 if (hotkey_letter == 0x52)
18127 {
18128 ok(0, "Couldn't find any free Windows Key + letter combination\n");
18129 goto end;
18130 }
18131
18132 hKBD_hook = SetWindowsHookExA(WH_KEYBOARD_LL, KeyboardHookProc, GetModuleHandleA(NULL), 0);
18133 if (!hKBD_hook) win_skip("WH_KEYBOARD_LL is not supported\n");
18134
18135 /* Same key combination, different id */
18136 SetLastError(0xdeadbeef);
18137 ret = RegisterHotKey(test_window, 4, MOD_WIN, hotkey_letter);
18138 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18139 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18140 "unexpected error %ld\n", GetLastError());
18141
18142 /* Same key combination, different window */
18143 SetLastError(0xdeadbeef);
18144 ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
18145 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18146 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18147 "unexpected error %ld\n", GetLastError());
18148
18149 /* Register the same hotkey twice */
18150 SetLastError(0xdeadbeef);
18151 ret = RegisterHotKey(test_window, 5, MOD_WIN, hotkey_letter);
18152 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18153 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18154 "unexpected error %ld\n", GetLastError());
18155
18156 /* Window on another thread */
18157 taskbar_window = FindWindowA("Shell_TrayWnd", NULL);
18158 if (!taskbar_window)
18159 {
18160 skip("no taskbar?\n");
18161 }
18162 else
18163 {
18164 SetLastError(0xdeadbeef);
18165 ret = RegisterHotKey(taskbar_window, 5, 0, hotkey_letter);
18166 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18167 ok(GetLastError() == ERROR_WINDOW_OF_OTHER_THREAD || broken(GetLastError() == 0xdeadbeef),
18168 "unexpected error %ld\n", GetLastError());
18169 }
18170
18171 /* Inject the appropriate key sequence */
18172 keybd_event(VK_LWIN, 0, 0, 0);
18173 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18174 DispatchMessageA(&msg);
18175 ok_sequence(WmHotkeyPressLWIN, "window hotkey press LWIN", FALSE);
18176
18177 keybd_event(hotkey_letter, 0, 0, 0);
18178 queue_status = GetQueueStatus(QS_HOTKEY);
18179 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %lx\n", queue_status);
18180 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18181 {
18182 if (msg.message == WM_HOTKEY)
18183 {
18184 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
18185 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
18186 }
18187 DispatchMessageA(&msg);
18188 }
18189 ok_sequence(WmHotkeyPress, "window hotkey press", FALSE);
18190
18191 queue_status = GetQueueStatus(QS_HOTKEY);
18192 ok((queue_status & (QS_HOTKEY << 16)) == 0, "expected QS_HOTKEY << 16 cleared, got %lx\n", queue_status);
18193
18194 key_state = GetAsyncKeyState(hotkey_letter);
18195 ok((key_state & 0x8000) == 0x8000, "unexpected key state %x\n", key_state);
18196
18197 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
18198 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18199 DispatchMessageA(&msg);
18200 ok_sequence(WmHotkeyRelease, "window hotkey release", TRUE);
18201
18202 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
18203 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18204 DispatchMessageA(&msg);
18205 ok_sequence(WmHotkeyReleaseLWIN, "window hotkey release LWIN", FALSE);
18206
18207 /* normal posted WM_HOTKEY messages set QS_HOTKEY */
18208 PostMessageA(test_window, WM_HOTKEY, 0, 0);
18209 queue_status = GetQueueStatus(QS_HOTKEY);
18210 ok((queue_status & (QS_HOTKEY << 16)) == QS_HOTKEY << 16, "expected QS_HOTKEY << 16 set, got %lx\n", queue_status);
18211 queue_status = GetQueueStatus(QS_POSTMESSAGE);
18212 ok((queue_status & (QS_POSTMESSAGE << 16)) == QS_POSTMESSAGE << 16, "expected QS_POSTMESSAGE << 16 set, got %lx\n", queue_status);
18213 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18214 DispatchMessageA(&msg);
18215 flush_sequence();
18216
18217 /* Send and process all messages at once */
18218 PostMessageA(test_window, WM_APP, 0, 0);
18219 keybd_event(VK_LWIN, 0, 0, 0);
18220 keybd_event(hotkey_letter, 0, 0, 0);
18221 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
18222 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
18223
18224 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18225 {
18226 if (msg.message == WM_HOTKEY)
18227 {
18228 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
18229 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
18230 }
18231 DispatchMessageA(&msg);
18232 }
18233 ok_sequence(WmHotkeyCombined, "window hotkey combined", FALSE);
18234
18235 /* Register same hwnd/id with different key combination */
18236 ret = RegisterHotKey(test_window, 5, 0, hotkey_letter);
18237 ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
18238
18239 /* Previous key combination does not work */
18240 keybd_event(VK_LWIN, 0, 0, 0);
18241 keybd_event(hotkey_letter, 0, 0, 0);
18242 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
18243 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
18244
18245 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18246 DispatchMessageA(&msg);
18247 ok_sequence(WmHotkeyPrevious, "window hotkey previous", FALSE);
18248
18249 /* New key combination works */
18250 keybd_event(hotkey_letter, 0, 0, 0);
18251 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
18252
18253 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18254 {
18255 if (msg.message == WM_HOTKEY)
18256 {
18257 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
18258 ok(msg.lParam == MAKELPARAM(0, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
18259 }
18260 DispatchMessageA(&msg);
18261 }
18262 ok_sequence(WmHotkeyNew, "window hotkey new", FALSE);
18263
18264 /* Unregister hotkey properly */
18265 ret = UnregisterHotKey(test_window, 5);
18266 ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
18267
18268 /* Unregister hotkey again */
18269 SetLastError(0xdeadbeef);
18270 ret = UnregisterHotKey(test_window, 5);
18271 ok(ret == FALSE, "expected FALSE, got %i\n", ret);
18272 ok(GetLastError() == ERROR_HOTKEY_NOT_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18273 "unexpected error %ld\n", GetLastError());
18274
18275 /* Register thread hotkey */
18276 ret = RegisterHotKey(NULL, 5, MOD_WIN, hotkey_letter);
18277 ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
18278
18279 /* Inject the appropriate key sequence */
18280 keybd_event(VK_LWIN, 0, 0, 0);
18281 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18282 {
18283 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
18284 DispatchMessageA(&msg);
18285 }
18286 ok_sequence(WmHotkeyPressLWIN, "thread hotkey press LWIN", FALSE);
18287
18288 keybd_event(hotkey_letter, 0, 0, 0);
18289 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18290 {
18291 if (msg.message == WM_HOTKEY)
18292 {
18293 struct recvd_message message;
18294 ok(msg.hwnd == NULL, "unexpected hwnd %p\n", msg.hwnd);
18295 ok(msg.lParam == MAKELPARAM(MOD_WIN, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
18296 message.message = msg.message;
18297 message.flags = sent|wparam|lparam;
18298 message.wParam = msg.wParam;
18299 message.lParam = msg.lParam;
18300 message.descr = "test_hotkey thread message";
18301 add_message(&message);
18302 }
18303 else
18304 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
18305 DispatchMessageA(&msg);
18306 }
18307 ok_sequence(WmHotkeyPress, "thread hotkey press", FALSE);
18308
18309 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
18310 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18311 {
18312 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
18313 DispatchMessageA(&msg);
18314 }
18315 ok_sequence(WmHotkeyRelease, "thread hotkey release", TRUE);
18316
18317 keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
18318 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18319 {
18320 ok(msg.hwnd != NULL, "unexpected thread message %x\n", msg.message);
18321 DispatchMessageA(&msg);
18322 }
18323 ok_sequence(WmHotkeyReleaseLWIN, "thread hotkey release LWIN", FALSE);
18324
18325 /* Search for an ALT + letter combination that hasn't been registered */
18326 for (hotkey_letter = 0x41; hotkey_letter <= 0x51; hotkey_letter ++)
18327 {
18328 SetLastError(0xdeadbeef);
18329 ret = RegisterHotKey(test_window, 6, MOD_ALT, hotkey_letter);
18330
18331 if (ret == TRUE)
18332 {
18333 break;
18334 }
18335 else
18336 {
18337 ok(GetLastError() == ERROR_HOTKEY_ALREADY_REGISTERED || broken(GetLastError() == 0xdeadbeef),
18338 "unexpected error %ld\n", GetLastError());
18339 }
18340 }
18341
18342 if (hotkey_letter == 0x52)
18343 {
18344 ok(0, "Couldn't find any free ALT + letter combination\n");
18345 goto end;
18346 }
18347
18348 keybd_event(VK_LMENU, 0, 0, 0);
18349 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18350 DispatchMessageA(&msg);
18351 ok_sequence(WmHotkeyPressALT, "window hotkey press ALT", TRUE);
18352
18353 keybd_event(hotkey_letter, 0, 0, 0);
18354 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18355 {
18356 if (msg.message == WM_HOTKEY)
18357 {
18358 ok(msg.hwnd == test_window, "unexpected hwnd %p\n", msg.hwnd);
18359 ok(msg.lParam == MAKELPARAM(MOD_ALT, hotkey_letter), "unexpected WM_HOTKEY lparam %Ix\n", msg.lParam);
18360 }
18361 DispatchMessageA(&msg);
18362 }
18363 ok_sequence(WmHotkeyPressWithALT, "window hotkey press with ALT", FALSE);
18364
18365 keybd_event(hotkey_letter, 0, KEYEVENTF_KEYUP, 0);
18366 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18367 DispatchMessageA(&msg);
18368 ok_sequence(WmHotkeyReleaseWithALT, "window hotkey release with ALT", TRUE);
18369
18370 keybd_event(VK_LMENU, 0, KEYEVENTF_KEYUP, 0);
18371 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
18372 DispatchMessageA(&msg);
18373 ok_sequence(WmHotkeyReleaseALT, "window hotkey release ALT", FALSE);
18374
18375 /* Unregister thread hotkey */
18376 ret = UnregisterHotKey(NULL, 5);
18377 ok(ret == TRUE, "expected TRUE, got %i, err=%ld\n", ret, GetLastError());
18378
18379 if (hKBD_hook) UnhookWindowsHookEx(hKBD_hook);
18380 hKBD_hook = NULL;
18381
18382 end:
18383 UnregisterHotKey(NULL, 5);
18384 UnregisterHotKey(test_window, 5);
18385 UnregisterHotKey(test_window, 6);
18386 DestroyWindow(test_window);
18387 flush_sequence();
18388 }
18389
18390
18391 static const struct message WmSetFocus_1[] = {
18392 { HCBT_SETFOCUS, hook }, /* child */
18393 { HCBT_ACTIVATE, hook }, /* parent */
18394 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
18395 { WM_QUERYNEWPALETTE, sent|wparam|lparam|parent|optional, 0, 0 },
18396 { WM_WINDOWPOSCHANGING, sent|parent, 0, SWP_NOSIZE|SWP_NOMOVE },
18397 { WM_ACTIVATEAPP, sent|wparam|parent, 1 },
18398 { WM_NCACTIVATE, sent|parent },
18399 { WM_GETTEXT, sent|defwinproc|parent|optional },
18400 { WM_GETTEXT, sent|defwinproc|parent|optional },
18401 { WM_ACTIVATE, sent|wparam|parent, 1 },
18402 { HCBT_SETFOCUS, hook }, /* parent */
18403 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
18404 { WM_SETFOCUS, sent|defwinproc|parent },
18405 { WM_KILLFOCUS, sent|parent },
18406 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
18407 { WM_SETFOCUS, sent },
18408 { 0 }
18409 };
18410 static const struct message WmSetFocus_2[] = {
18411 { HCBT_SETFOCUS, hook }, /* parent */
18412 { WM_KILLFOCUS, sent },
18413 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
18414 { WM_SETFOCUS, sent|parent },
18415 { 0 }
18416 };
18417 static const struct message WmSetFocus_3[] = {
18418 { HCBT_SETFOCUS, hook }, /* child */
18419 { 0 }
18420 };
18421
18422 static void test_SetFocus(void)
18423 {
18424 HWND parent, old_parent, child, old_focus, old_active;
18425 MSG msg;
18426 struct wnd_event wnd_event;
18427 HANDLE hthread;
18428 DWORD ret, tid;
18429
18430 wnd_event.start_event = CreateEventW(NULL, 0, 0, NULL);
18431 ok(wnd_event.start_event != 0, "CreateEvent error %ld\n", GetLastError());
18432 hthread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
18433 ok(hthread != 0, "CreateThread error %ld\n", GetLastError());
18434 ret = WaitForSingleObject(wnd_event.start_event, INFINITE);
18435 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
18436 CloseHandle(wnd_event.start_event);
18437
18438 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW,
18439 0, 0, 0, 0, 0, 0, 0, NULL);
18440 ok(parent != 0, "failed to create parent window\n");
18441 child = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
18442 0, 0, 0, 0, parent, 0, 0, NULL);
18443 ok(child != 0, "failed to create child window\n");
18444
18445 if (winetest_debug > 1) trace("parent %p, child %p, thread window %p\n", parent, child, wnd_event.hwnd);
18446
18447 SetFocus(0);
18448 SetActiveWindow(0);
18449
18450 flush_events();
18451 flush_sequence();
18452
18453 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
18454 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
18455
18456 log_all_parent_messages++;
18457
18458 old_focus = SetFocus(child);
18459 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18460 ok_sequence(WmSetFocus_1, "SetFocus on a child window", TRUE);
18461 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
18462 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18463 ok(GetFocus() == child, "expected focus %p, got %p\n", child, GetFocus());
18464
18465 old_focus = SetFocus(parent);
18466 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18467 ok_sequence(WmSetFocus_2, "SetFocus on a parent window", FALSE);
18468 ok(old_focus == child, "expected old focus %p, got %p\n", child, old_focus);
18469 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18470 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18471
18472 SetLastError(0xdeadbeef);
18473 old_focus = SetFocus((HWND)0xdeadbeef);
18474 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
18475 "expected ERROR_INVALID_WINDOW_HANDLE, got %ld\n", GetLastError());
18476 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18477 ok_sequence(WmEmptySeq, "SetFocus on an invalid window", FALSE);
18478 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
18479 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18480 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18481
18482 SetLastError(0xdeadbeef);
18483 old_focus = SetFocus(GetDesktopWindow());
18484 ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
18485 broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
18486 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18487 ok_sequence(WmEmptySeq, "SetFocus on a desktop window", TRUE);
18488 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
18489 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18490 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18491
18492 SetLastError(0xdeadbeef);
18493 old_focus = SetFocus(wnd_event.hwnd);
18494 ok(GetLastError() == ERROR_ACCESS_DENIED /* Vista+ */ ||
18495 broken(GetLastError() == 0xdeadbeef), "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
18496 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18497 ok_sequence(WmEmptySeq, "SetFocus on another thread window", TRUE);
18498 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
18499 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18500 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18501
18502 SetLastError(0xdeadbeef);
18503 old_active = SetActiveWindow((HWND)0xdeadbeef);
18504 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
18505 "expected ERROR_INVALID_WINDOW_HANDLE, got %ld\n", GetLastError());
18506 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18507 ok_sequence(WmEmptySeq, "SetActiveWindow on an invalid window", FALSE);
18508 ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
18509 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18510 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18511
18512 SetLastError(0xdeadbeef);
18513 old_active = SetActiveWindow(GetDesktopWindow());
18514 todo_wine
18515 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
18516 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18517 ok_sequence(WmEmptySeq, "SetActiveWindow on a desktop window", TRUE);
18518 ok(old_active == 0, "expected old focus 0, got %p\n", old_focus);
18519 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18520 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18521
18522 SetLastError(0xdeadbeef);
18523 old_active = SetActiveWindow(wnd_event.hwnd);
18524 todo_wine
18525 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
18526 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18527 ok_sequence(WmEmptySeq, "SetActiveWindow on another thread window", TRUE);
18528 ok(old_active == 0, "expected old focus 0, got %p\n", old_active);
18529 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18530 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18531
18532 SetLastError(0xdeadbeef);
18533 ret = AttachThreadInput(GetCurrentThreadId(), tid, TRUE);
18534 ok(ret, "AttachThreadInput error %ld\n", GetLastError());
18535
18536 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18537 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18538
18539 flush_events();
18540 flush_sequence();
18541
18542 old_focus = SetFocus(wnd_event.hwnd);
18543 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18544 ok(old_focus == wnd_event.hwnd, "expected old focus %p, got %p\n", wnd_event.hwnd, old_focus);
18545 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
18546 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
18547
18548 old_focus = SetFocus(parent);
18549 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18550 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
18551 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18552 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18553
18554 flush_events();
18555 flush_sequence();
18556
18557 old_active = SetActiveWindow(wnd_event.hwnd);
18558 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18559 ok(old_active == parent, "expected old focus %p, got %p\n", parent, old_active);
18560 ok(GetActiveWindow() == wnd_event.hwnd, "expected active %p, got %p\n", wnd_event.hwnd, GetActiveWindow());
18561 ok(GetFocus() == wnd_event.hwnd, "expected focus %p, got %p\n", wnd_event.hwnd, GetFocus());
18562
18563 SetLastError(0xdeadbeef);
18564 ret = AttachThreadInput(GetCurrentThreadId(), tid, FALSE);
18565 ok(ret, "AttachThreadInput error %ld\n", GetLastError());
18566
18567 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
18568 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
18569
18570 old_parent = SetParent(child, GetDesktopWindow());
18571 ok(old_parent == parent, "expected old parent %p, got %p\n", parent, old_parent);
18572
18573 ok(GetActiveWindow() == 0, "expected active 0, got %p\n", GetActiveWindow());
18574 ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
18575
18576 old_focus = SetFocus(parent);
18577 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18578 ok(old_focus == parent, "expected old focus %p, got %p\n", parent, old_focus);
18579 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18580 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18581
18582 flush_events();
18583 flush_sequence();
18584
18585 SetLastError(0xdeadbeef);
18586 old_focus = SetFocus(child);
18587 todo_wine
18588 ok(GetLastError() == ERROR_INVALID_PARAMETER /* Vista+ */ ||
18589 broken(GetLastError() == 0) /* XP */ ||
18590 broken(GetLastError() == 0xdeadbeef), "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
18591 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18592 ok_sequence(WmSetFocus_3, "SetFocus on a child window", TRUE);
18593 ok(old_focus == 0, "expected old focus 0, got %p\n", old_focus);
18594 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18595 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18596
18597 SetLastError(0xdeadbeef);
18598 old_active = SetActiveWindow(child);
18599 ok(GetLastError() == 0xdeadbeef, "expected 0xdeadbeef, got %ld\n", GetLastError());
18600 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
18601 ok_sequence(WmEmptySeq, "SetActiveWindow on a child window", FALSE);
18602 ok(old_active == parent, "expected old active %p, got %p\n", parent, old_active);
18603 ok(GetActiveWindow() == parent, "expected active %p, got %p\n", parent, GetActiveWindow());
18604 ok(GetFocus() == parent, "expected focus %p, got %p\n", parent, GetFocus());
18605
18606 log_all_parent_messages--;
18607
18608 DestroyWindow(child);
18609 DestroyWindow(parent);
18610
18611 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
18612 ok(ret, "PostMessage(WM_QUIT) error %ld\n", GetLastError());
18613 ret = WaitForSingleObject(hthread, INFINITE);
18614 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
18615 CloseHandle(hthread);
18616 }
18617
18618 static const struct message WmSetLayeredStyle[] = {
18619 { WM_STYLECHANGING, sent },
18620 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
18621 { WM_STYLECHANGED, sent },
18622 { WM_GETTEXT, sent|defwinproc|optional },
18623 { 0 }
18624 };
18625
18626 static const struct message WmSetLayeredStyle2[] = {
18627 { WM_STYLECHANGING, sent },
18628 { WM_STYLECHANGED, sent },
18629 { WM_WINDOWPOSCHANGING, sent|optional|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
18630 { WM_NCCALCSIZE, sent|optional|wparam|defwinproc, 1 },
18631 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
18632 { WM_WINDOWPOSCHANGED, sent|optional|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
18633 { WM_MOVE, sent|optional|defwinproc|wparam, 0 },
18634 { WM_SIZE, sent|optional|defwinproc|wparam, SIZE_RESTORED },
18635 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 },
18636 { 0 }
18637 };
18638
18639 static const struct message WmLayeredWinEmptySeq[] = {
18640 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
18641 { 0 }
18642 };
18643
18644 struct layered_window_info
18645 {
18646 HWND hwnd;
18647 HDC hdc;
18648 SIZE size;
18649 HANDLE event;
18650 BOOL ret;
18651 };
18652
18653 static DWORD CALLBACK update_layered_proc( void *param )
18654 {
18655 struct layered_window_info *info = param;
18656 POINT src = { 0, 0 };
18657
18658 info->ret = pUpdateLayeredWindow( info->hwnd, 0, NULL, &info->size,
18659 info->hdc, &src, 0, NULL, ULW_OPAQUE );
18660 ok( info->ret, "failed\n");
18661 SetEvent( info->event );
18662 return 0;
18663 }
18664
18665 static void test_layered_window(void)
18666 {
18667 HWND hwnd;
18668 HDC hdc;
18669 HBITMAP bmp;
18670 BOOL ret;
18671 SIZE size;
18672 POINT pos, src;
18673 RECT rect, client;
18674 HANDLE thread;
18675 DWORD tid;
18676 struct layered_window_info info;
18677
18678 if (!pUpdateLayeredWindow)
18679 {
18680 win_skip( "UpdateLayeredWindow not supported\n" );
18681 return;
18682 }
18683
18684 hdc = CreateCompatibleDC( 0 );
18685 bmp = CreateCompatibleBitmap( hdc, 300, 300 );
18686 SelectObject( hdc, bmp );
18687
18688 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_CAPTION | WS_THICKFRAME | WS_SYSMENU,
18689 100, 100, 300, 300, 0, 0, 0, NULL);
18690 ok( hwnd != 0, "failed to create window\n" );
18691 ShowWindow( hwnd, SW_SHOWNORMAL );
18692 UpdateWindow( hwnd );
18693 flush_events();
18694 flush_sequence();
18695
18696 GetWindowRect( hwnd, &rect );
18697 GetClientRect( hwnd, &client );
18698 ok( client.right < rect.right - rect.left, "wrong client area\n" );
18699 ok( client.bottom < rect.bottom - rect.top, "wrong client area\n" );
18700
18701 src.x = src.y = 0;
18702 pos.x = pos.y = 300;
18703 size.cx = size.cy = 250;
18704 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
18705 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
18706 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
18707 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
18708 ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
18709
18710 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
18711 ok( ret, "UpdateLayeredWindow failed err %lu\n", GetLastError() );
18712 ok_sequence( WmLayeredWinEmptySeq, "UpdateLayeredWindow", FALSE );
18713 GetWindowRect( hwnd, &rect );
18714 ok( rect.left == 300 && rect.top == 300 && rect.right == 550 && rect.bottom == 550,
18715 "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
18716 GetClientRect( hwnd, &rect );
18717 ok( rect.right == client.right - 50 && rect.bottom == client.bottom - 50,
18718 "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
18719
18720 size.cx = 150;
18721 pos.y = 200;
18722 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
18723 ok( ret, "UpdateLayeredWindow failed err %lu\n", GetLastError() );
18724 ok_sequence( WmLayeredWinEmptySeq, "UpdateLayeredWindow", FALSE );
18725 GetWindowRect( hwnd, &rect );
18726 ok( rect.left == 300 && rect.top == 200 && rect.right == 450 && rect.bottom == 450,
18727 "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
18728 GetClientRect( hwnd, &rect );
18729 ok( rect.right == client.right - 150 && rect.bottom == client.bottom - 50,
18730 "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
18731
18732 SetWindowLongA( hwnd, GWL_STYLE,
18733 GetWindowLongA(hwnd, GWL_STYLE) & ~(WS_CAPTION | WS_THICKFRAME | WS_SYSMENU) );
18734 ok_sequence( WmSetLayeredStyle2, "WmSetLayeredStyle2", FALSE );
18735
18736 size.cx = 200;
18737 pos.x = 200;
18738 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
18739 ok( ret, "UpdateLayeredWindow failed err %lu\n", GetLastError() );
18740 ok_sequence( WmLayeredWinEmptySeq, "UpdateLayeredWindow", FALSE );
18741 GetWindowRect( hwnd, &rect );
18742 ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
18743 "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
18744 GetClientRect( hwnd, &rect );
18745 ok( (rect.right == 200 && rect.bottom == 250) ||
18746 broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
18747 "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
18748
18749 size.cx = 0;
18750 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
18751 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
18752 ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == ERROR_MR_MID_NOT_FOUND) ||
18753 broken(GetLastError() == ERROR_GEN_FAILURE) /* win7 */, "wrong error %lu\n", GetLastError() );
18754 size.cx = 1;
18755 size.cy = -1;
18756 ret = pUpdateLayeredWindow( hwnd, 0, &pos, &size, hdc, &src, 0, NULL, ULW_OPAQUE );
18757 ok( !ret, "UpdateLayeredWindow should fail on non-layered window\n" );
18758 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
18759
18760 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) & ~WS_EX_LAYERED );
18761 ok_sequence( WmSetLayeredStyle, "WmSetLayeredStyle", FALSE );
18762 GetWindowRect( hwnd, &rect );
18763 ok( rect.left == 200 && rect.top == 200 && rect.right == 400 && rect.bottom == 450,
18764 "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
18765 GetClientRect( hwnd, &rect );
18766 ok( (rect.right == 200 && rect.bottom == 250) ||
18767 broken(rect.right == client.right - 100 && rect.bottom == client.bottom - 50),
18768 "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
18769
18770 SetWindowLongA( hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED );
18771 info.hwnd = hwnd;
18772 info.hdc = hdc;
18773 info.size.cx = 250;
18774 info.size.cy = 300;
18775 info.event = CreateEventA( NULL, TRUE, FALSE, NULL );
18776 info.ret = FALSE;
18777 thread = CreateThread( NULL, 0, update_layered_proc, &info, 0, &tid );
18778 ok( WaitForSingleObject( info.event, 1000 ) == 0, "wait failed\n" );
18779 ok( info.ret, "UpdateLayeredWindow failed in other thread\n" );
18780 WaitForSingleObject( thread, 1000 );
18781 CloseHandle( thread );
18782 GetWindowRect( hwnd, &rect );
18783 ok( rect.left == 200 && rect.top == 200 && rect.right == 450 && rect.bottom == 500,
18784 "wrong window rect %s\n", wine_dbgstr_rect( &rect ));
18785 GetClientRect( hwnd, &rect );
18786 ok( (rect.right == 250 && rect.bottom == 300) ||
18787 broken(rect.right == client.right - 50 && rect.bottom == client.bottom),
18788 "wrong client rect %s\n", wine_dbgstr_rect( &rect ));
18789
18790 DestroyWindow( hwnd );
18791 DeleteDC( hdc );
18792 DeleteObject( bmp );
18793 }
18794
18795 static HMENU hpopupmenu;
18796
18797 static LRESULT WINAPI minimize_popup_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
18798 {
18799 LRESULT ret;
18800
18801 if (ignore_message( message )) return 0;
18802 ret = MsgCheckProc( FALSE, hwnd, message, wParam, lParam );
18803
18804 switch (message) {
18805 case WM_ENTERIDLE:
18806 ShowWindow(hwnd, SW_MINIMIZE);
18807 break;
18808 case WM_TIMER:
18809 EndMenu();
18810 break;
18811 }
18812
18813 return ret;
18814 }
18815
18816 static LRESULT WINAPI cancel_popup_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
18817 {
18818 if (ignore_message( message )) return 0;
18819
18820 switch (message) {
18821 case WM_ENTERIDLE:
18822 todo_wine ok(GetCapture() == hwnd, "expected %p, got %p\n", hwnd, GetCapture());
18823 EndMenu();
18824 break;
18825 case WM_INITMENU:
18826 case WM_INITMENUPOPUP:
18827 case WM_UNINITMENUPOPUP:
18828 ok((HMENU)wParam == hpopupmenu, "expected %p, got %Ix\n", hpopupmenu, wParam);
18829 break;
18830 case WM_CAPTURECHANGED:
18831 todo_wine ok(!lParam || (HWND)lParam == hwnd, "lost capture to %Ix\n", lParam);
18832 break;
18833 }
18834
18835 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
18836 }
18837
18838 static LRESULT WINAPI cancel_init_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
18839 {
18840 if (ignore_message( message )) return 0;
18841
18842 switch (message) {
18843 case WM_ENTERMENULOOP:
18844 ok(EndMenu() == TRUE, "EndMenu() failed\n");
18845 break;
18846 }
18847
18848 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
18849 }
18850
18851 static void test_TrackPopupMenu(void)
18852 {
18853 MSG msg;
18854 HWND hwnd;
18855 BOOL ret;
18856
18857 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
18858 0, 0, 1, 1, 0,
18859 NULL, NULL, 0);
18860 ok(hwnd != NULL, "CreateWindowEx failed with error %ld\n", GetLastError());
18861
18862 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
18863
18864 hpopupmenu = CreatePopupMenu();
18865 ok(hpopupmenu != NULL, "CreateMenu failed with error %ld\n", GetLastError());
18866
18867 AppendMenuA(hpopupmenu, MF_STRING, 100, "item 1");
18868 AppendMenuA(hpopupmenu, MF_STRING, 100, "item 2");
18869
18870 flush_events();
18871 flush_sequence();
18872 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
18873 ok_sequence(WmTrackPopupMenu, "TrackPopupMenu", TRUE);
18874 ok(ret == 1, "TrackPopupMenu failed with error %li\n", GetLastError());
18875
18876 /* Test popup closing with an ESC-press */
18877 flush_events();
18878 PostMessageW(hwnd, WM_KEYDOWN, VK_ESCAPE, 0);
18879 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
18880 ok(ret == 1, "TrackPopupMenu failed with error %li\n", GetLastError());
18881 PostQuitMessage(0);
18882 flush_sequence();
18883 while ( PeekMessageA(&msg, 0, 0, 0, PM_REMOVE) )
18884 {
18885 TranslateMessage(&msg);
18886 DispatchMessageA(&msg);
18887 }
18888 ok_sequence(WmTrackPopupMenuEsc, "TrackPopupMenuEsc", FALSE); /* Shouldn't get any message */
18889
18890 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_init_proc);
18891
18892 flush_events();
18893 flush_sequence();
18894 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
18895 ok_sequence(WmTrackPopupMenuAbort, "WmTrackPopupMenuAbort", TRUE);
18896 ok(ret == TRUE, "TrackPopupMenu failed\n");
18897
18898 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)minimize_popup_proc);
18899
18900 /* set cursor over the window, otherwise the WM_CANCELMODE message may not always be sent */
18901 SetCursorPos( 0, 0 );
18902 ShowWindow( hwnd, SW_SHOW );
18903
18904 flush_events();
18905 flush_sequence();
18906 SetTimer( hwnd, TIMER_ID, 500, NULL );
18907 ret = TrackPopupMenu( hpopupmenu, 0, 100,100, 0, hwnd, NULL );
18908 ok_sequence( WmTrackPopupMenuMinimizeWindow, "TrackPopupMenuMinimizeWindow", TRUE );
18909 ok( ret == 1, "TrackPopupMenu failed with error %li\n", GetLastError() );
18910 KillTimer( hwnd, TIMER_ID );
18911 ShowWindow( hwnd, SW_RESTORE );
18912
18913 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
18914
18915 SetCapture(hwnd);
18916
18917 flush_events();
18918 flush_sequence();
18919 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
18920 ok_sequence(WmTrackPopupMenuCapture, "TrackPopupMenuCapture", TRUE);
18921 ok(ret == 1, "TrackPopupMenuCapture failed with error %li\n", GetLastError());
18922
18923 DestroyMenu(hpopupmenu);
18924 DestroyWindow(hwnd);
18925 }
18926
18927 static void test_TrackPopupMenuEmpty(void)
18928 {
18929 HWND hwnd;
18930 BOOL ret;
18931
18932 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
18933 0, 0, 1, 1, 0,
18934 NULL, NULL, 0);
18935 ok(hwnd != NULL, "CreateWindowEx failed with error %ld\n", GetLastError());
18936
18937 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)cancel_popup_proc);
18938
18939 hpopupmenu = CreatePopupMenu();
18940 ok(hpopupmenu != NULL, "CreateMenu failed with error %ld\n", GetLastError());
18941
18942 flush_events();
18943 flush_sequence();
18944 ret = TrackPopupMenu(hpopupmenu, 0, 100,100, 0, hwnd, NULL);
18945 ok_sequence(WmTrackPopupMenuEmpty, "TrackPopupMenuEmpty", TRUE);
18946 ok(ret == 0, "TrackPopupMenu succeeded\n");
18947
18948 DestroyMenu(hpopupmenu);
18949 DestroyWindow(hwnd);
18950 }
18951
18952 static const struct message send_message_1[] = {
18953 { WM_USER+2, sent|wparam|lparam, 0, 0 },
18954 { WM_USER, sent|wparam|lparam, 0, 0 },
18955 { 0 }
18956 };
18957 static const struct message send_message_2[] = {
18958 { WM_USER+4, sent|wparam|lparam, 0, 0 },
18959 { 0 }
18960 };
18961 static const struct message send_message_3[] = {
18962 { WM_USER+3, sent|wparam|lparam, 0, 0 },
18963 { WM_USER+1, sent|wparam|lparam, 0, 0 },
18964 { 0 }
18965 };
18966
18967 static DWORD WINAPI SendMessage_thread_1(void *param)
18968 {
18969 struct wnd_event *wnd_event = param;
18970
18971 if (winetest_debug > 1) trace("thread: starting\n");
18972 WaitForSingleObject(wnd_event->start_event, INFINITE);
18973
18974 if (winetest_debug > 1) trace("thread: call PostMessage\n");
18975 PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
18976
18977 if (winetest_debug > 1) trace("thread: call PostMessage\n");
18978 PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
18979
18980 if (winetest_debug > 1) trace("thread: call SendMessage\n");
18981 SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
18982 SetEvent(wnd_event->stop_event);
18983
18984 if (winetest_debug > 1) trace("thread: call SendMessage\n");
18985 SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
18986
18987 return 0;
18988 }
18989
18990 static DWORD WINAPI SendMessage_thread_2(void *param)
18991 {
18992 struct wnd_event *wnd_event = param;
18993
18994 if (winetest_debug > 1) trace("thread: starting\n");
18995 WaitForSingleObject(wnd_event->start_event, INFINITE);
18996
18997 if (winetest_debug > 1) trace("thread: call PostMessage\n");
18998 PostMessageA(wnd_event->hwnd, WM_USER, 0, 0);
18999
19000 if (winetest_debug > 1) trace("thread: call PostMessage\n");
19001 PostMessageA(wnd_event->hwnd, WM_USER+1, 0, 0);
19002
19003 /* this leads to sending an internal message under Wine */
19004 if (winetest_debug > 1) trace("thread: call SetParent\n");
19005 SetParent(wnd_event->hwnd, wnd_event->hwnd);
19006
19007 if (winetest_debug > 1) trace("thread: call SendMessage\n");
19008 SendMessageA(wnd_event->hwnd, WM_USER+2, 0, 0);
19009 SetEvent(wnd_event->stop_event);
19010
19011 if (winetest_debug > 1) trace("thread: call SendMessage\n");
19012 SendMessageA(wnd_event->hwnd, WM_USER+3, 0, 0);
19013
19014 return 0;
19015 }
19016
19017 static void test_SendMessage_other_thread(int thread_n)
19018 {
19019 DWORD qs_all_input = QS_ALLINPUT & ~QS_RAWINPUT;
19020 HANDLE hthread;
19021 struct wnd_event wnd_event;
19022 DWORD tid, ret;
19023 MSG msg;
19024
19025 wnd_event.start_event = CreateEventA(NULL, 0, 0, NULL);
19026 wnd_event.stop_event = CreateEventA(NULL, 0, 0, NULL);
19027
19028 wnd_event.hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
19029 100, 100, 200, 200, 0, 0, 0, NULL);
19030 ok(wnd_event.hwnd != 0, "CreateWindowEx failed\n");
19031
19032 hthread = CreateThread(NULL, 0, thread_n == 1 ? SendMessage_thread_1 : SendMessage_thread_2, &wnd_event, 0, &tid);
19033 ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
19034 CloseHandle(hthread);
19035
19036 flush_events();
19037 flush_sequence();
19038
19039 ret = GetQueueStatus(QS_SENDMESSAGE);
19040 ok(ret == 0, "wrong status %08lx\n", ret);
19041
19042 SetEvent(wnd_event.start_event);
19043
19044 /* wait for other thread's SendMessage */
19045 for (;;)
19046 {
19047 ret = GetQueueStatus(QS_SENDMESSAGE);
19048 if (ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE)) break;
19049 Sleep(50);
19050 }
19051
19052 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
19053 ok(ret == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08lx\n", ret);
19054
19055 if (winetest_debug > 1) trace("main: call GetMessage\n");
19056 GetMessageA(&msg, 0, 0, 0);
19057 ok(msg.message == WM_USER, "expected WM_USER, got %04x\n", msg.message);
19058 DispatchMessageA(&msg);
19059 ok_sequence(send_message_1, "SendMessage from other thread 1", thread_n == 2);
19060
19061 ret = WaitForSingleObject(wnd_event.stop_event, 100);
19062 todo_wine_if (thread_n == 2)
19063 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed, ret:%lx\n", ret);
19064
19065 /* intentionally yield */
19066 MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
19067
19068 if (winetest_debug > 1) trace("main: call SendMessage\n");
19069 SendMessageA(wnd_event.hwnd, WM_USER+4, 0, 0);
19070 ok_sequence(send_message_2, "SendMessage from other thread 2", FALSE);
19071
19072 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
19073 ok(ret == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE), "wrong status %08lx\n", ret);
19074
19075 if (winetest_debug > 1) trace("main: call PeekMessage\n");
19076 ok(PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should not fail\n");
19077 ok(msg.message == WM_USER+1, "expected WM_USER+1, got %04x\n", msg.message);
19078 DispatchMessageA(&msg);
19079 ok_sequence(send_message_3, "SendMessage from other thread 3", thread_n == 2);
19080
19081 /* intentionally yield */
19082 MsgWaitForMultipleObjects(0, NULL, FALSE, 100, qs_all_input);
19083
19084 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
19085 /* FIXME: remove once Wine is fixed */
19086 todo_wine_if (thread_n == 2)
19087 ok(ret == 0, "wrong status %08lx\n", ret);
19088
19089 if (winetest_debug > 1) trace("main: call PeekMessage\n");
19090 ok(!PeekMessageA(&msg, 0, 0, 0, PM_REMOVE), "PeekMessage should fail\n");
19091 ok_sequence(WmEmptySeq, "SendMessage from other thread 5", thread_n == 2);
19092
19093 ret = GetQueueStatus(QS_SENDMESSAGE|QS_POSTMESSAGE);
19094 ok(ret == 0, "wrong status %08lx\n", ret);
19095
19096 if (winetest_debug > 1) trace("main: call DestroyWindow\n");
19097 DestroyWindow(msg.hwnd);
19098
19099 flush_events();
19100 flush_sequence();
19101
19102 CloseHandle(wnd_event.start_event);
19103 CloseHandle(wnd_event.stop_event);
19104 }
19105
19106 static LRESULT CALLBACK insendmessage_wnd_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
19107 {
19108 DWORD flags = InSendMessageEx( NULL );
19109 BOOL ret;
19110
19111 switch (msg)
19112 {
19113 case WM_USER:
19114 ok( flags == ISMEX_SEND, "wrong flags %lx\n", flags );
19115 ok( InSendMessage(), "InSendMessage returned false\n" );
19116 ret = ReplyMessage( msg );
19117 ok( ret, "ReplyMessage failed err %lu\n", GetLastError() );
19118 flags = InSendMessageEx( NULL );
19119 ok( flags == (ISMEX_SEND | ISMEX_REPLIED), "wrong flags %lx\n", flags );
19120 ok( InSendMessage(), "InSendMessage returned false\n" );
19121 break;
19122 case WM_USER + 1:
19123 ok( flags == ISMEX_NOTIFY, "wrong flags %lx\n", flags );
19124 ok( InSendMessage(), "InSendMessage returned false\n" );
19125 ret = ReplyMessage( msg );
19126 ok( ret, "ReplyMessage failed err %lu\n", GetLastError() );
19127 flags = InSendMessageEx( NULL );
19128 ok( flags == ISMEX_NOTIFY, "wrong flags %lx\n", flags );
19129 ok( InSendMessage(), "InSendMessage returned false\n" );
19130 break;
19131 case WM_USER + 2:
19132 ok( flags == ISMEX_CALLBACK, "wrong flags %lx\n", flags );
19133 ok( InSendMessage(), "InSendMessage returned false\n" );
19134 ret = ReplyMessage( msg );
19135 ok( ret, "ReplyMessage failed err %lu\n", GetLastError() );
19136 flags = InSendMessageEx( NULL );
19137 ok( flags == (ISMEX_CALLBACK | ISMEX_REPLIED) || flags == ISMEX_SEND, "wrong flags %lx\n", flags );
19138 ok( InSendMessage(), "InSendMessage returned false\n" );
19139 break;
19140 case WM_USER + 3:
19141 ok( flags == ISMEX_NOSEND, "wrong flags %lx\n", flags );
19142 ok( !InSendMessage(), "InSendMessage returned true\n" );
19143 ret = ReplyMessage( msg );
19144 ok( !ret, "ReplyMessage succeeded\n" );
19145 break;
19146 }
19147
19148 return DefWindowProcA( hwnd, msg, wp, lp );
19149 }
19150
19151 static void CALLBACK msg_callback( HWND hwnd, UINT msg, ULONG_PTR arg, LRESULT result )
19152 {
19153 ok( msg == WM_USER + 2, "wrong msg %x\n", msg );
19154 ok( result == WM_USER + 2, "wrong result %Ix\n", result );
19155 }
19156
19157 static DWORD WINAPI send_message_thread( void *arg )
19158 {
19159 HWND win = arg;
19160
19161 SendMessageA( win, WM_USER, 0, 0 );
19162 SendNotifyMessageA( win, WM_USER + 1, 0, 0 );
19163 SendMessageCallbackA( win, WM_USER + 2, 0, 0, msg_callback, 0 );
19164 PostMessageA( win, WM_USER + 3, 0, 0 );
19165 PostMessageA( win, WM_QUIT, 0, 0 );
19166 return 0;
19167 }
19168
19169 static void test_InSendMessage(void)
19170 {
19171 WNDCLASSA cls;
19172 HWND win;
19173 MSG msg;
19174 HANDLE thread;
19175 DWORD tid;
19176
19177 memset(&cls, 0, sizeof(cls));
19178 cls.lpfnWndProc = insendmessage_wnd_proc;
19179 cls.hInstance = GetModuleHandleA(NULL);
19180 cls.lpszClassName = "InSendMessage_test";
19181 RegisterClassA(&cls);
19182
19183 win = CreateWindowA( "InSendMessage_test", NULL, 0, 0, 0, 0, 0, NULL, 0, NULL, 0 );
19184 ok( win != NULL, "CreateWindow failed: %ld\n", GetLastError() );
19185
19186 thread = CreateThread( NULL, 0, send_message_thread, win, 0, &tid );
19187 ok( thread != NULL, "CreateThread failed: %ld\n", GetLastError() );
19188
19189 while (GetMessageA(&msg, NULL, 0, 0)) DispatchMessageA( &msg );
19190
19191 ok( WaitForSingleObject( thread, 30000 ) == WAIT_OBJECT_0, "WaitForSingleObject failed\n" );
19192 CloseHandle( thread );
19193
19194 DestroyWindow( win );
19195 UnregisterClassA( "InSendMessage_test", GetModuleHandleA(NULL) );
19196 }
19197
19198 static const struct message DoubleSetCaptureSeq[] =
19199 {
19200 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19201 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19202 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19203 { WM_CAPTURECHANGED, sent },
19204 { 0 }
19205 };
19206
19207 static void test_DoubleSetCapture(void)
19208 {
19209 HWND hwnd;
19210
19211 hwnd = CreateWindowExA(0, "TestWindowClass", "Test DoubleSetCapture",
19212 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
19213 100, 100, 200, 200, 0, 0, 0, NULL);
19214 ok (hwnd != 0, "Failed to create overlapped window\n");
19215
19216 ShowWindow( hwnd, SW_SHOW );
19217 UpdateWindow( hwnd );
19218 flush_events();
19219 flush_sequence();
19220
19221 SetCapture( hwnd );
19222 SetCapture( hwnd );
19223 ok_sequence(DoubleSetCaptureSeq, "SetCapture( hwnd ) twice", FALSE);
19224
19225 DestroyWindow(hwnd);
19226 }
19227
19228 static const struct message WmRestoreMinimizedSeq[] =
19229 {
19230 { HCBT_ACTIVATE, hook },
19231 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19232 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
19233 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
19234 { WM_ACTIVATEAPP, sent|wparam, 1 },
19235 { WM_NCACTIVATE, sent|wparam, 0x200001 },
19236 { WM_GETTEXT, sent|defwinproc|optional },
19237 { WM_ACTIVATE, sent|wparam, 0x200001 }, /* Note that activate messages are after WM_WINDOWPOSCHANGED and before WM_SYSCOMMAND */
19238 { HCBT_KEYSKIPPED, hook|optional },
19239 { WM_SYSKEYUP, sent|optional },
19240 { WM_SYSCOMMAND, sent|wparam, SC_RESTORE },
19241 { HCBT_SYSCOMMAND, hook|wparam, SC_RESTORE },
19242 { HCBT_SYSCOMMAND, hook|wparam|optional, SC_RESTORE },
19243 { HCBT_MINMAX, hook },
19244 { HCBT_MINMAX, hook|optional },
19245 { WM_QUERYOPEN, sent|defwinproc },
19246 { WM_QUERYOPEN, sent|optional },
19247 { WM_GETTEXT, sent|defwinproc|optional },
19248 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
19249 { WM_GETMINMAXINFO, sent|defwinproc },
19250 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
19251 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19252 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
19253 { WM_GETTEXT, sent|defwinproc|optional },
19254 { WM_ERASEBKGND, sent|defwinproc },
19255 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
19256 { WM_MOVE, sent|defwinproc },
19257 { WM_SIZE, sent|defwinproc },
19258 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19259 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam|winevent_hook_todo, 0, 0 },
19260 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
19261 { WM_NCPAINT, sent|wparam|defwinproc|optional, 1 },
19262 { WM_ERASEBKGND, sent|defwinproc|optional },
19263 { HCBT_SETFOCUS, hook },
19264 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
19265 { WM_SETFOCUS, sent|defwinproc },
19266 { WM_ACTIVATE, sent|wparam|defwinproc, 1 },
19267 { WM_PAINT, sent| optional },
19268 { WM_SETFOCUS, sent|defwinproc|optional },
19269 { HCBT_KEYSKIPPED, hook|optional },
19270 { WM_KEYUP, sent|optional },
19271 { HCBT_KEYSKIPPED, hook|optional },
19272 { WM_SYSKEYUP, sent|optional },
19273 { HCBT_KEYSKIPPED, hook|optional },
19274 { WM_KEYUP, sent|optional },
19275 { HCBT_KEYSKIPPED, hook|optional },
19276 { WM_SYSKEYUP, sent|optional },
19277 { HCBT_KEYSKIPPED, hook|optional },
19278 { WM_KEYUP, sent|optional },
19279 { WM_PAINT, sent| optional },
19280 { 0 }
19281 };
19282
19283 static void test_restore_messages(void)
19284 {
19285 INPUT ip = {0};
19286 HWND hwnd;
19287 INT i;
19288
19289 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100,
19290 100, 200, 200, 0, 0, 0, NULL);
19291 ok (hwnd != 0, "Failed to create overlapped window\n");
19292 SetForegroundWindow(hwnd);
19293 ShowWindow(hwnd, SW_MINIMIZE);
19294 flush_events();
19295 flush_sequence();
19296
19297 for (i = 0; i < 5; i++)
19298 {
19299 /* Send Alt+Tab to restore test window from minimized state */
19300 ip.type = INPUT_KEYBOARD;
19301 ip.ki.wVk = VK_MENU;
19302 SendInput(1, &ip, sizeof(INPUT));
19303 ip.ki.wVk = VK_TAB;
19304 SendInput(1, &ip, sizeof(INPUT));
19305 ip.ki.wVk = VK_MENU;
19306 ip.ki.dwFlags = KEYEVENTF_KEYUP;
19307 SendInput(1, &ip, sizeof(INPUT));
19308 ip.ki.wVk = VK_TAB;
19309 ip.ki.dwFlags = KEYEVENTF_KEYUP;
19310 SendInput(1, &ip, sizeof(INPUT));
19311 flush_events();
19312 if (!IsIconic(hwnd))
19313 break;
19314 }
19315
19316 if (IsIconic(hwnd))
19317 {
19318 skip("Alt+Tab failed to bring up test window.\n");
19319 goto done;
19320 }
19321 ok_sequence(WmRestoreMinimizedSeq, "Restore minimized window", TRUE);
19322
19323 done:
19324 DestroyWindow(hwnd);
19325 }
19326
19327 static void test_invalid_window(void)
19328 {
19329 MSG msg;
19330 BOOL ret;
19331
19332 SetLastError(0xdeadbeef);
19333 ret = GetMessageA(&msg, (HWND)0xdeadbeef, 0, 0);
19334 ok(ret == -1, "wrong ret %d\n", ret);
19335 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %lu\n", GetLastError());
19336
19337 SetLastError(0xdeadbeef);
19338 ret = PeekMessageA(&msg, (HWND)0xdeadbeef, 0, 0, PM_REMOVE);
19339 ok(!ret, "wrong ret %d\n", ret);
19340 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %lu\n", GetLastError());
19341 }
19342
19343 static void test_button_style(void)
19344 {
19345 DWORD type, expected_type;
19346 HWND button;
19347 LRESULT ret;
19348 DWORD i, j;
19349
19350 for (i = BS_PUSHBUTTON; i <= BS_DEFCOMMANDLINK; ++i)
19351 {
19352 button = CreateWindowA(WC_BUTTONA, "test", i, 0, 0, 50, 50, NULL, 0, 0, NULL);
19353 ok(button != NULL, "Expected button not null.\n");
19354
19355 type = GetWindowLongW(button, GWL_STYLE) & BS_TYPEMASK;
19356 expected_type = (i == BS_USERBUTTON ? BS_PUSHBUTTON : i);
19357 ok(type == expected_type, "Expected type %#lx, got %#lx.\n", expected_type, type);
19358
19359 for (j = BS_PUSHBUTTON; j <= BS_DEFCOMMANDLINK; ++j)
19360 {
19361 ret = SendMessageA(button, BM_SETSTYLE, j, FALSE);
19362 ok(ret == 0, "Expected %#x, got %#Ix.\n", 0, ret);
19363
19364 type = GetWindowLongW(button, GWL_STYLE) & BS_TYPEMASK;
19365 expected_type = j;
19366
19367 ok(type == expected_type, "Original type %#lx, expected new type %#lx, got %#lx.\n", i,
19368 expected_type, type);
19369 }
19370 DestroyWindow(button);
19371 }
19372 }
19373
19374 static LRESULT WINAPI test_create_name_procW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
19375 {
19376 switch (msg)
19377 {
19378 case WM_NCCREATE:
19379 case WM_CREATE:
19380 {
19381 CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
19382 memcpy( cs->lpCreateParams, cs->lpszName, 3 * sizeof(WCHAR) );
19383 break;
19384 }
19385 case WM_SETTEXT:
19386 if (winetest_debug > 1) trace("%s\n", debugstr_w((const WCHAR *)lparam));
19387 break;
19388 }
19389
19390 return DefWindowProcW( hwnd, msg, wparam, lparam );
19391 }
19392
19393 static void test_create_name(void)
19394 {
19395 WNDCLASSW clsW = { 0 };
19396 WCHAR name_buf[3];
19397 HWND hwnd;
19398
19399 clsW.lpfnWndProc = test_create_name_procW;
19400 clsW.lpszClassName = L"TestCreateNameClassW";
19401 RegisterClassW( &clsW );
19402
19403 hwnd = CreateWindowExW( 0, L"TestCreateNameClassW", L"\xffff\x6162",
19404 WS_POPUP, 0,0,0,0,0,0,0, name_buf );
19405 ok( hwnd != NULL, "CreateWindowEx failed: %lu\n", GetLastError() );
19406 ok(!memcmp(name_buf, L"\xffff\x6162", 2 * sizeof(WCHAR)),
19407 "name param = %s\n", debugstr_wn(name_buf, 2));
19408 DestroyWindow( hwnd );
19409
19410 hwnd = CreateWindowExA( 0, "TestCreateNameClassW", "\xff\0\x61\x60",
19411 WS_POPUP, 0,0,0,0,0,0,0, name_buf );
19412 ok( hwnd != NULL, "CreateWindowEx failed: %lu\n", GetLastError() );
19413 ok(!memcmp(name_buf, L"\xffff\x6100", 2 * sizeof(WCHAR)),
19414 "name param = %s\n", debugstr_wn(name_buf, 2));
19415 DestroyWindow( hwnd );
19416
19417 UnregisterClassW( L"TestCreateNameClassW", NULL );
19418 }
19419
19420 START_TEST(msg)
19421 {
19422 char **test_argv;
19423 BOOL ret;
19424 BOOL (WINAPI *pIsWinEventHookInstalled)(DWORD)= 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
19425 int argc;
19426
19427 argc = winetest_get_mainargs( &test_argv );
19428 if (argc >= 3)
19429 {
19430 unsigned int arg;
19431 /* Child process. */
19432 sscanf (test_argv[2], "%d", (unsigned int *) &arg);
19433 do_wait_idle_child( arg );
19434 return;
19435 }
19436
19437 InitializeCriticalSection( &sequence_cs );
19438 init_procs();
19439 ImmDisableIME(0);
19440
19441 if (!RegisterWindowClasses()) assert(0);
19442
19443 if (pSetWinEventHook)
19444 {
19445 hEvent_hook = pSetWinEventHook(EVENT_MIN, EVENT_MAX,
19446 GetModuleHandleA(0), win_event_proc,
19447 0, GetCurrentThreadId(),
19448 WINEVENT_INCONTEXT);
19449 if (pIsWinEventHookInstalled && hEvent_hook)
19450 {
19451 UINT event;
19452 for (event = EVENT_MIN; event <= EVENT_MAX; event++)
19453 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
19454 }
19455 }
19456 if (!hEvent_hook) win_skip( "no win event hook support\n" );
19457
19458 cbt_hook_thread_id = winevent_hook_thread_id = GetCurrentThreadId();
19459 hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
19460 if (!hCBT_hook) win_skip( "cannot set global hook, will skip hook tests\n" );
19461
19462 test_winevents();
19463 test_SendMessage_other_thread(1);
19464 test_SendMessage_other_thread(2);
19465 test_InSendMessage();
19466 test_SetFocus();
19467 test_SetParent();
19468 test_PostMessage();
19469 test_broadcast();
19470 test_ShowWindow();
19471 test_PeekMessage();
19472 test_PeekMessage2();
19473 test_PeekMessage3();
19474 test_WaitForInputIdle( test_argv[0] );
19475 test_scrollwindowex();
19476 test_messages();
19477 test_setwindowpos();
19478 test_showwindow();
19479 invisible_parent_tests();
19480 test_mdi_messages();
19481 test_button_messages();
19482 test_button_bm_get_set_image();
19483 test_button_style();
19484 test_autoradio_BM_CLICK();
19485 test_autoradio_kbd_move();
19486 test_static_messages();
19487 test_listbox_messages();
19488 test_combobox_messages();
19489 test_wmime_keydown_message();
19490 test_paint_messages();
19491 test_swp_paint_regions();
19492 test_interthread_messages();
19493 test_message_conversion();
19494 test_accelerators();
19495 test_timers();
19496 test_timers_no_wnd();
19497 test_timers_exceptions();
19498 if (hCBT_hook)
19499 {
19500 test_set_hook();
19501 test_recursive_hook();
19502 }
19503 test_DestroyWindow();
19504 test_DispatchMessage();
19505 test_SendMessageTimeout();
19506 test_edit_messages();
19507 test_quit_message();
19508 test_notify_message();
19509 test_SetActiveWindow();
19510 test_restore_messages();
19511 test_invalid_window();
19512 test_menu_messages();
19513 test_paintingloop();
19514
19515 if (!pTrackMouseEvent)
19516 win_skip("TrackMouseEvent is not available\n");
19517 else
19518 test_TrackMouseEvent();
19519
19520 test_SetWindowRgn();
19521 test_sys_menu();
19522 test_dialog_messages();
19523 test_EndDialog();
19524 test_nullCallback();
19525 test_dbcs_wm_char();
19526 test_unicode_wm_char();
19527 test_defwinproc();
19528 test_desktop_winproc();
19529 test_clipboard_viewers();
19530 test_keyflags();
19531 test_hotkey();
19532 test_layered_window();
19533 test_TrackPopupMenu();
19534 test_TrackPopupMenuEmpty();
19535 test_DoubleSetCapture();
19536 test_create_name();
19537 /* keep it the last test, under Windows it tends to break the tests
19538 * which rely on active/foreground windows being correct.
19539 */
19540 test_SetForegroundWindow();
19541
19542 UnhookWindowsHookEx(hCBT_hook);
19543 if (pUnhookWinEvent && hEvent_hook)
19544 {
19545 ret = pUnhookWinEvent(hEvent_hook);
19546 ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
19547 SetLastError(0xdeadbeef);
19548 ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
19549 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
19550 GetLastError() == 0xdeadbeef, /* Win9x */
19551 "unexpected error %ld\n", GetLastError());
19552 }
19553 DeleteCriticalSection( &sequence_cs );
19554 }
Windows API implementation