?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- WM_MDISETMENU handler should update new frame menu only if an active
[wine/multimedia.git] / dlls / user / tests / msg.c
blobf8972f8617419551a6b5bff31c488d4b65bccd51
1 /*
2 * Unit tests for window message handling
3 *
4 * Copyright 1999 Ove Kaaven
5 * Copyright 2003 Dimitrie O. Paun
6 * Copyright 2004 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26
27 #define _WIN32_WINNT 0x0500 /* For WM_CHANGEUISTATE */
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33
34 #include "wine/test.h"
35
36 #define MDI_FIRST_CHILD_ID 2004
37
38 /* undocumented SWP flags - from SDK 3.1 */
39 #define SWP_NOCLIENTSIZE 0x0800
40 #define SWP_NOCLIENTMOVE 0x1000
41
42 /*
43 FIXME: add tests for these
44 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
45 WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
46 WS_THICKFRAME: thick border
47 WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
48 WS_BORDER (default for overlapped windows): single black border
49 none (default for child (and popup?) windows): no border
50 */
51
52 typedef enum {
53 sent=0x1,
54 posted=0x2,
55 parent=0x4,
56 wparam=0x8,
57 lparam=0x10,
58 defwinproc=0x20,
59 beginpaint=0x40,
60 optional=0x80,
61 hook=0x100
62 } msg_flags_t;
63
64 struct message {
65 UINT message; /* the WM_* code */
66 msg_flags_t flags; /* message props */
67 WPARAM wParam; /* expected value of wParam */
68 LPARAM lParam; /* expected value of lParam */
69 };
70
71 /* Empty message sequence */
72 static const struct message WmEmptySeq[] =
73 {
74 { 0 }
75 };
76 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
77 static const struct message WmCreateOverlappedSeq[] = {
78 { HCBT_CREATEWND, hook },
79 { WM_GETMINMAXINFO, sent },
80 { WM_NCCREATE, sent },
81 { WM_NCCALCSIZE, sent|wparam, 0 },
82 { WM_CREATE, sent },
83 { 0 }
84 };
85 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
86 * for a not visible overlapped window.
87 */
88 static const struct message WmSWP_ShowOverlappedSeq[] = {
89 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
90 { WM_NCPAINT, sent|wparam|optional, 1 },
91 { WM_GETTEXT, sent|defwinproc|optional },
92 { WM_ERASEBKGND, sent|optional },
93 { HCBT_ACTIVATE, hook },
94 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
95 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
96 { WM_ACTIVATEAPP, sent|wparam, 1 },
97 { WM_NCACTIVATE, sent|wparam, 1 },
98 { WM_GETTEXT, sent|defwinproc|optional },
99 { WM_ACTIVATE, sent|wparam, 1 },
100 { HCBT_SETFOCUS, hook },
101 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
102 { WM_IME_NOTIFY, sent|defwinproc|optional },
103 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
104 { WM_NCPAINT, sent|wparam|optional, 1 },
105 { WM_GETTEXT, sent|defwinproc|optional },
106 { WM_ERASEBKGND, sent|optional },
107 /* Win9x adds SWP_NOZORDER below */
108 { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
109 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
110 { WM_NCPAINT, sent|wparam|optional, 1 },
111 { WM_ERASEBKGND, sent|optional },
112 { 0 }
113 };
114 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
115 * for a visible overlapped window.
116 */
117 static const struct message WmSWP_HideOverlappedSeq[] = {
118 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
119 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
120 { 0 }
121 };
122 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
123 static const struct message WmShowOverlappedSeq[] = {
124 { WM_SHOWWINDOW, sent|wparam, 1 },
125 { WM_NCPAINT, sent|wparam|optional, 1 },
126 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
127 { WM_NCPAINT, sent|wparam|optional, 1 },
128 { WM_GETTEXT, sent|defwinproc|optional },
129 { WM_ERASEBKGND, sent|optional },
130 { HCBT_ACTIVATE, hook },
131 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
132 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
133 { WM_ACTIVATEAPP, sent|wparam, 1 },
134 { WM_NCACTIVATE, sent|wparam, 1 },
135 { WM_GETTEXT, sent|defwinproc|optional },
136 { WM_ACTIVATE, sent|wparam, 1 },
137 { HCBT_SETFOCUS, hook },
138 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
139 { WM_IME_NOTIFY, sent|defwinproc|optional },
140 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
141 { WM_NCPAINT, sent|wparam|optional, 1 },
142 { WM_GETTEXT, sent|defwinproc|optional },
143 { WM_ERASEBKGND, sent|optional },
144 /* Win9x adds SWP_NOZORDER below */
145 { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
146 { WM_NCCALCSIZE, sent|optional },
147 { WM_NCPAINT, sent|optional },
148 { WM_ERASEBKGND, sent|optional },
149 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
150 * messages. Does that mean that CreateWindow doesn't set initial
151 * window dimensions for overlapped windows?
152 */
153 { WM_SIZE, sent },
154 { WM_MOVE, sent },
155 #endif
156 { 0 }
157 };
158 /* ShowWindow(SW_HIDE) for a visible overlapped window */
159 static const struct message WmHideOverlappedSeq[] = {
160 { WM_SHOWWINDOW, sent|wparam, 0 },
161 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
162 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
163 { WM_SIZE, sent },
164 { WM_MOVE, sent },
165 { WM_NCACTIVATE, sent|wparam, 0 },
166 { WM_ACTIVATE, sent|wparam, 0 },
167 { WM_ACTIVATEAPP, sent|wparam, 0 },
168 { WM_KILLFOCUS, sent|wparam, 0 },
169 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
170 { WM_IME_NOTIFY, sent|optional|defwinproc },
171 { 0 }
172 };
173 /* ShowWindow(SW_HIDE) for an invisible overlapped window */
174 static const struct message WmHideInvisibleOverlappedSeq[] = {
175 { 0 }
176 };
177 /* DestroyWindow for a visible overlapped window */
178 static const struct message WmDestroyOverlappedSeq[] = {
179 { HCBT_DESTROYWND, hook },
180 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
181 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
182 { WM_NCACTIVATE, sent|wparam, 0 },
183 { WM_ACTIVATE, sent|wparam, 0 },
184 { WM_ACTIVATEAPP, sent|wparam, 0 },
185 { WM_KILLFOCUS, sent|wparam, 0 },
186 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
187 { WM_IME_NOTIFY, sent|optional|defwinproc },
188 { WM_DESTROY, sent },
189 { WM_NCDESTROY, sent },
190 { 0 }
191 };
192 /* CreateWindow (for a child popup window, not initially visible) */
193 static const struct message WmCreateChildPopupSeq[] = {
194 { HCBT_CREATEWND, hook },
195 { WM_NCCREATE, sent },
196 { WM_NCCALCSIZE, sent|wparam, 0 },
197 { WM_CREATE, sent },
198 { WM_SIZE, sent },
199 { WM_MOVE, sent },
200 { 0 }
201 };
202 /* CreateWindow (for a popup window, not initially visible,
203 * which sets WS_VISIBLE in WM_CREATE handler)
204 */
205 static const struct message WmCreateInvisiblePopupSeq[] = {
206 { HCBT_CREATEWND, hook },
207 { WM_NCCREATE, sent },
208 { WM_NCCALCSIZE, sent|wparam, 0 },
209 { WM_CREATE, sent },
210 { WM_STYLECHANGING, sent },
211 { WM_STYLECHANGED, sent },
212 { WM_SIZE, sent },
213 { WM_MOVE, sent },
214 { 0 }
215 };
216 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
217 * for a popup window with WS_VISIBLE style set
218 */
219 static const struct message WmShowVisiblePopupSeq_2[] = {
220 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
221 { 0 }
222 };
223 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
224 * for a popup window with WS_VISIBLE style set
225 */
226 static const struct message WmShowVisiblePopupSeq_3[] = {
227 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
228 { HCBT_ACTIVATE, hook },
229 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
230 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
231 { WM_NCACTIVATE, sent|wparam, 1 },
232 { WM_ACTIVATE, sent|wparam, 1 },
233 { HCBT_SETFOCUS, hook },
234 { WM_KILLFOCUS, sent|parent },
235 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
236 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
237 { WM_IME_NOTIFY, sent|defwinproc|optional },
238 { WM_SETFOCUS, sent|defwinproc },
239 { 0 }
240 };
241 /* CreateWindow (for child window, not initially visible) */
242 static const struct message WmCreateChildSeq[] = {
243 { HCBT_CREATEWND, hook },
244 { WM_NCCREATE, sent },
245 /* child is inserted into parent's child list after WM_NCCREATE returns */
246 { WM_NCCALCSIZE, sent|wparam, 0 },
247 { WM_CREATE, sent },
248 { WM_SIZE, sent },
249 { WM_MOVE, sent },
250 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
251 { 0 }
252 };
253 /* CreateWindow (for maximized child window, not initially visible) */
254 static const struct message WmCreateMaximizedChildSeq[] = {
255 { HCBT_CREATEWND, hook },
256 { WM_NCCREATE, sent },
257 { WM_NCCALCSIZE, sent|wparam, 0 },
258 { WM_CREATE, sent },
259 { WM_SIZE, sent },
260 { WM_MOVE, sent },
261 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
262 { WM_GETMINMAXINFO, sent },
263 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
264 { WM_NCCALCSIZE, sent|wparam, 1 },
265 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE|0x8000 },
266 { WM_SIZE, sent|defwinproc },
267 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
268 { 0 }
269 };
270 /* CreateWindow (for a child window, initially visible) */
271 static const struct message WmCreateVisibleChildSeq[] = {
272 { HCBT_CREATEWND, hook },
273 { WM_NCCREATE, sent },
274 /* child is inserted into parent's child list after WM_NCCREATE returns */
275 { WM_NCCALCSIZE, sent|wparam, 0 },
276 { WM_CREATE, sent },
277 { WM_SIZE, sent },
278 { WM_MOVE, sent },
279 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
280 { WM_SHOWWINDOW, sent|wparam, 1 },
281 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
282 { WM_ERASEBKGND, sent|parent|optional },
283 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
284 { 0 }
285 };
286 /* ShowWindow(SW_SHOW) for a not visible child window */
287 static const struct message WmShowChildSeq[] = {
288 { WM_SHOWWINDOW, sent|wparam, 1 },
289 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
290 { WM_ERASEBKGND, sent|parent|optional },
291 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
292 { 0 }
293 };
294 /* ShowWindow(SW_HIDE) for a visible child window */
295 static const struct message WmHideChildSeq[] = {
296 { WM_SHOWWINDOW, sent|wparam, 0 },
297 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
298 { WM_ERASEBKGND, sent|parent|optional },
299 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
300 { 0 }
301 };
302 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
303 * for a not visible child window
304 */
305 static const struct message WmShowChildSeq_2[] = {
306 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
307 { WM_CHILDACTIVATE, sent },
308 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
309 { 0 }
310 };
311 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
312 * for a not visible child window
313 */
314 static const struct message WmShowChildSeq_3[] = {
315 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
316 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
317 { 0 }
318 };
319 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
320 * for a visible child window with a caption
321 */
322 static const struct message WmShowChildSeq_4[] = {
323 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
324 { WM_CHILDACTIVATE, sent },
325 { 0 }
326 };
327 /* ShowWindow(SW_SHOW) for child with invisible parent */
328 static const struct message WmShowChildInvisibleParentSeq[] = {
329 { WM_SHOWWINDOW, sent|wparam, 1 },
330 { 0 }
331 };
332 /* ShowWindow(SW_HIDE) for child with invisible parent */
333 static const struct message WmHideChildInvisibleParentSeq[] = {
334 { WM_SHOWWINDOW, sent|wparam, 0 },
335 { 0 }
336 };
337 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
338 static const struct message WmShowChildInvisibleParentSeq_2[] = {
339 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
340 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
341 { 0 }
342 };
343 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
344 static const struct message WmHideChildInvisibleParentSeq_2[] = {
345 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
346 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
347 { 0 }
348 };
349 /* DestroyWindow for a visible child window */
350 static const struct message WmDestroyChildSeq[] = {
351 { HCBT_DESTROYWND, hook },
352 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
353 { WM_SHOWWINDOW, sent|wparam, 0 },
354 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
355 { WM_ERASEBKGND, sent|parent|optional },
356 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
357 { HCBT_SETFOCUS, hook }, /* set focus to a parent */
358 { WM_KILLFOCUS, sent },
359 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
360 { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
361 { WM_SETFOCUS, sent|parent },
362 { WM_DESTROY, sent },
363 { WM_DESTROY, sent|optional }, /* a bug in win2k sp4 ? */
364 { WM_NCDESTROY, sent },
365 { WM_NCDESTROY, sent|optional }, /* a bug in win2k sp4 ? */
366 { 0 }
367 };
368 /* Moving the mouse in nonclient area */
369 static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
370 { WM_NCHITTEST, sent },
371 { WM_SETCURSOR, sent },
372 { WM_NCMOUSEMOVE, posted },
373 { 0 }
374 };
375 /* Moving the mouse in client area */
376 static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
377 { WM_NCHITTEST, sent },
378 { WM_SETCURSOR, sent },
379 { WM_MOUSEMOVE, posted },
380 { 0 }
381 };
382 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
383 static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
384 { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
385 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
386 { WM_GETMINMAXINFO, sent|defwinproc },
387 { WM_ENTERSIZEMOVE, sent|defwinproc },
388 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
389 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
390 { WM_MOVE, sent|defwinproc },
391 { WM_EXITSIZEMOVE, sent|defwinproc },
392 { 0 }
393 };
394 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
395 static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
396 { WM_NCLBUTTONDOWN, sent|wparam, 0xd },
397 { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 },
398 { WM_GETMINMAXINFO, sent|defwinproc },
399 { WM_ENTERSIZEMOVE, sent|defwinproc },
400 { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */
401 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
402 { WM_GETMINMAXINFO, sent|defwinproc },
403 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
404 { WM_NCPAINT, sent|defwinproc|wparam, 1 },
405 { WM_GETTEXT, sent|defwinproc },
406 { WM_ERASEBKGND, sent|defwinproc },
407 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
408 { WM_MOVE, sent|defwinproc },
409 { WM_SIZE, sent|defwinproc },
410 { WM_EXITSIZEMOVE, sent|defwinproc },
411 { 0 }
412 };
413 /* Resizing child window with MoveWindow (32) */
414 static const struct message WmResizingChildWithMoveWindowSeq[] = {
415 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
416 { WM_NCCALCSIZE, sent|wparam, 1 },
417 { WM_ERASEBKGND, sent|optional },
418 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
419 { WM_MOVE, sent|defwinproc },
420 { WM_SIZE, sent|defwinproc },
421 { 0 }
422 };
423 /* Clicking on inactive button */
424 static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
425 { WM_NCHITTEST, sent },
426 { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN },
427 { WM_MOUSEACTIVATE, sent },
428 { WM_MOUSEACTIVATE, sent|parent|defwinproc },
429 { WM_SETCURSOR, sent },
430 { WM_SETCURSOR, sent|parent|defwinproc },
431 { WM_LBUTTONDOWN, posted },
432 { WM_KILLFOCUS, posted|parent },
433 { WM_SETFOCUS, posted },
434 { WM_CTLCOLORBTN, posted|parent },
435 { BM_SETSTATE, posted },
436 { WM_CTLCOLORBTN, posted|parent },
437 { WM_LBUTTONUP, posted },
438 { BM_SETSTATE, posted },
439 { WM_CTLCOLORBTN, posted|parent },
440 { WM_COMMAND, posted|parent },
441 { 0 }
442 };
443 /* Reparenting a button (16/32) */
444 /* The last child (button) reparented gets topmost for its new parent. */
445 static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
446 { WM_SHOWWINDOW, sent|wparam, 0 },
447 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
448 { WM_ERASEBKGND, sent|parent },
449 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
450 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOZORDER },
451 { WM_CHILDACTIVATE, sent },
452 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOZORDER },
453 { WM_MOVE, sent|defwinproc },
454 { WM_SHOWWINDOW, sent|wparam, 1 },
455 { 0 }
456 };
457 /* Creation of a custom dialog (32) */
458 static const struct message WmCreateCustomDialogSeq[] = {
459 { HCBT_CREATEWND, hook },
460 { WM_GETMINMAXINFO, sent },
461 { WM_NCCREATE, sent },
462 { WM_NCCALCSIZE, sent|wparam, 0 },
463 { WM_CREATE, sent },
464 { WM_SHOWWINDOW, sent|wparam, 1 },
465 { HCBT_ACTIVATE, hook },
466 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
467 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
468 { WM_NCACTIVATE, sent|wparam, 1 },
469 { WM_GETTEXT, sent|optional|defwinproc },
470 { WM_GETICON, sent|optional|defwinproc },
471 { WM_GETICON, sent|optional|defwinproc },
472 { WM_GETICON, sent|optional|defwinproc },
473 { WM_GETTEXT, sent|optional|defwinproc },
474 { WM_ACTIVATE, sent|wparam, 1 },
475 { WM_KILLFOCUS, sent|parent },
476 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
477 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
478 { WM_IME_NOTIFY, sent|optional|defwinproc },
479 { WM_SETFOCUS, sent },
480 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
481 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
482 { WM_NCPAINT, sent|wparam, 1 },
483 { WM_GETTEXT, sent|optional|defwinproc },
484 { WM_GETICON, sent|optional|defwinproc },
485 { WM_GETICON, sent|optional|defwinproc },
486 { WM_GETICON, sent|optional|defwinproc },
487 { WM_GETTEXT, sent|optional|defwinproc },
488 { WM_ERASEBKGND, sent },
489 { WM_CTLCOLORDLG, sent|defwinproc },
490 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
491 { WM_GETTEXT, sent|optional },
492 { WM_GETICON, sent|optional },
493 { WM_GETICON, sent|optional },
494 { WM_GETICON, sent|optional },
495 { WM_GETTEXT, sent|optional },
496 { WM_NCCALCSIZE, sent|optional },
497 { WM_NCPAINT, sent|optional },
498 { WM_GETTEXT, sent|optional|defwinproc },
499 { WM_GETICON, sent|optional|defwinproc },
500 { WM_GETICON, sent|optional|defwinproc },
501 { WM_GETICON, sent|optional|defwinproc },
502 { WM_GETTEXT, sent|optional|defwinproc },
503 { WM_ERASEBKGND, sent|optional },
504 { WM_CTLCOLORDLG, sent|optional|defwinproc },
505 { WM_SIZE, sent },
506 { WM_MOVE, sent },
507 { 0 }
508 };
509 /* Calling EndDialog for a custom dialog (32) */
510 static const struct message WmEndCustomDialogSeq[] = {
511 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
512 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
513 { WM_GETTEXT, sent|optional },
514 { WM_GETICON, sent|optional },
515 { WM_GETICON, sent|optional },
516 { WM_GETICON, sent|optional },
517 { HCBT_ACTIVATE, hook },
518 { WM_NCACTIVATE, sent|wparam, 0 },
519 { WM_GETTEXT, sent|optional|defwinproc },
520 { WM_GETICON, sent|optional|defwinproc },
521 { WM_GETICON, sent|optional|defwinproc },
522 { WM_GETICON, sent|optional|defwinproc },
523 { WM_GETTEXT, sent|optional|defwinproc },
524 { WM_ACTIVATE, sent|wparam, 0 },
525 { WM_WINDOWPOSCHANGING, sent|wparam|optional, 0 },
526 { HCBT_SETFOCUS, hook },
527 { WM_KILLFOCUS, sent },
528 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
529 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
530 { WM_IME_NOTIFY, sent|optional },
531 { WM_SETFOCUS, sent|parent|defwinproc },
532 { 0 }
533 };
534 /* Creation and destruction of a modal dialog (32) */
535 static const struct message WmModalDialogSeq[] = {
536 { WM_CANCELMODE, sent|parent },
537 { HCBT_SETFOCUS, hook },
538 { WM_KILLFOCUS, sent|parent },
539 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
540 { WM_ENABLE, sent|parent|wparam, 0 },
541 { HCBT_CREATEWND, hook },
542 { WM_SETFONT, sent },
543 { WM_INITDIALOG, sent },
544 { WM_CHANGEUISTATE, sent|optional },
545 { WM_SHOWWINDOW, sent },
546 { HCBT_ACTIVATE, hook },
547 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
548 { WM_NCACTIVATE, sent|wparam, 1 },
549 { WM_GETICON, sent|optional },
550 { WM_GETICON, sent|optional },
551 { WM_GETICON, sent|optional },
552 { WM_GETTEXT, sent|optional },
553 { WM_ACTIVATE, sent|wparam, 1 },
554 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
555 { WM_NCPAINT, sent },
556 { WM_GETICON, sent|optional },
557 { WM_GETICON, sent|optional },
558 { WM_GETICON, sent|optional },
559 { WM_GETTEXT, sent|optional },
560 { WM_ERASEBKGND, sent },
561 { WM_CTLCOLORDLG, sent },
562 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
563 { WM_GETICON, sent|optional },
564 { WM_GETICON, sent|optional },
565 { WM_GETICON, sent|optional },
566 { WM_GETTEXT, sent|optional },
567 { WM_NCCALCSIZE, sent|optional },
568 { WM_NCPAINT, sent|optional },
569 { WM_GETICON, sent|optional },
570 { WM_GETICON, sent|optional },
571 { WM_GETICON, sent|optional },
572 { WM_GETTEXT, sent|optional },
573 { WM_ERASEBKGND, sent|optional },
574 { WM_CTLCOLORDLG, sent|optional },
575 { WM_PAINT, sent|optional },
576 { WM_CTLCOLORBTN, sent },
577 { WM_ENTERIDLE, sent|parent|optional },
578 { WM_TIMER, sent },
579 { WM_ENABLE, sent|parent|wparam, 1 },
580 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
581 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
582 { WM_GETICON, sent|optional },
583 { WM_GETICON, sent|optional },
584 { WM_GETICON, sent|optional },
585 { WM_GETTEXT, sent|optional },
586 { HCBT_ACTIVATE, hook },
587 { WM_NCACTIVATE, sent|wparam, 0 },
588 { WM_GETICON, sent|optional },
589 { WM_GETICON, sent|optional },
590 { WM_GETICON, sent|optional },
591 { WM_GETTEXT, sent|optional },
592 { WM_ACTIVATE, sent|wparam, 0 },
593 { WM_WINDOWPOSCHANGING, sent|optional },
594 { HCBT_SETFOCUS, hook },
595 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
596 { WM_SETFOCUS, sent|parent|defwinproc },
597 { HCBT_DESTROYWND, hook },
598 { WM_DESTROY, sent },
599 { WM_NCDESTROY, sent },
600 { 0 }
601 };
602 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
603 static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
604 /* (inside dialog proc, handling WM_INITDIALOG) */
605 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
606 { WM_NCCALCSIZE, sent },
607 { WM_NCACTIVATE, sent|parent|wparam, 0 },
608 { WM_GETTEXT, sent|defwinproc },
609 { WM_ACTIVATE, sent|parent|wparam, 0 },
610 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
611 { WM_WINDOWPOSCHANGING, sent|parent },
612 { WM_NCACTIVATE, sent|wparam, 1 },
613 { WM_ACTIVATE, sent|wparam, 1 },
614 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
615 { WM_SIZE, sent|defwinproc },
616 /* (setting focus) */
617 { WM_SHOWWINDOW, sent|wparam, 1 },
618 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
619 { WM_NCPAINT, sent },
620 { WM_GETTEXT, sent|defwinproc },
621 { WM_ERASEBKGND, sent },
622 { WM_CTLCOLORDLG, sent|defwinproc },
623 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
624 { WM_PAINT, sent },
625 /* (bunch of WM_CTLCOLOR* for each control) */
626 { WM_PAINT, sent|parent },
627 { WM_ENTERIDLE, sent|parent|wparam, 0 },
628 { WM_SETCURSOR, sent|parent },
629 { 0 }
630 };
631 /* SetMenu for NonVisible windows with size change*/
632 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
633 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
634 { WM_NCCALCSIZE, sent|wparam, 1 },
635 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW },
636 { WM_MOVE, sent|defwinproc },
637 { WM_SIZE, sent|defwinproc },
638 { WM_GETICON, sent|optional },
639 { WM_GETICON, sent|optional },
640 { WM_GETICON, sent|optional },
641 { WM_GETTEXT, sent|optional },
642 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
643 { 0 }
644 };
645 /* SetMenu for NonVisible windows with no size change */
646 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
647 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
648 { WM_NCCALCSIZE, sent|wparam, 1 },
649 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
650 { 0 }
651 };
652 /* SetMenu for Visible windows with size change */
653 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
654 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
655 { WM_NCCALCSIZE, sent|wparam, 1 },
656 { WM_NCPAINT, sent|wparam, 1 },
657 { WM_GETTEXT, sent|defwinproc|optional },
658 { WM_ERASEBKGND, sent|optional },
659 { WM_ACTIVATE, sent|optional },
660 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
661 { WM_MOVE, sent|defwinproc },
662 { WM_SIZE, sent|defwinproc },
663 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
664 { WM_NCPAINT, sent|wparam|optional, 1 },
665 { WM_ERASEBKGND, sent|optional },
666 { 0 }
667 };
668 /* SetMenu for Visible windows with no size change */
669 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
670 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
671 { WM_NCCALCSIZE, sent|wparam, 1 },
672 { WM_NCPAINT, sent|wparam, 1 },
673 { WM_GETTEXT, sent|defwinproc|optional },
674 { WM_ERASEBKGND, sent|optional },
675 { WM_ACTIVATE, sent|optional },
676 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
677 { 0 }
678 };
679 /* DrawMenuBar for a visible window */
680 static const struct message WmDrawMenuBarSeq[] =
681 {
682 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
683 { WM_NCCALCSIZE, sent|wparam, 1 },
684 { WM_NCPAINT, sent|wparam, 1 },
685 { WM_GETTEXT, sent|defwinproc|optional },
686 { WM_ERASEBKGND, sent|optional },
687 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
688 { 0 }
689 };
690
691 static const struct message WmSetRedrawFalseSeq[] =
692 {
693 { WM_SETREDRAW, sent|wparam, 0 },
694 { 0 }
695 };
696
697 static const struct message WmSetRedrawTrueSeq[] =
698 {
699 { WM_SETREDRAW, sent|wparam, 1 },
700 { 0 }
701 };
702
703 static const struct message WmEnableWindowSeq[] =
704 {
705 { WM_CANCELMODE, sent },
706 { WM_ENABLE, sent },
707 { 0 }
708 };
709
710 static const struct message WmGetScrollRangeSeq[] =
711 {
712 { SBM_GETRANGE, sent },
713 { 0 }
714 };
715 static const struct message WmGetScrollInfoSeq[] =
716 {
717 { SBM_GETSCROLLINFO, sent },
718 { 0 }
719 };
720 static const struct message WmSetScrollRangeSeq[] =
721 {
722 /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
723 sends SBM_SETSCROLLINFO.
724 */
725 { SBM_SETSCROLLINFO, sent },
726 { 0 }
727 };
728 /* SetScrollRange for a window without a non-client area */
729 static const struct message WmSetScrollRangeHVSeq[] =
730 {
731 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
732 { WM_NCCALCSIZE, sent|wparam, 1 },
733 { WM_GETTEXT, sent|defwinproc|optional },
734 { WM_ERASEBKGND, sent|optional },
735 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
736 { 0 }
737 };
738 /* SetScrollRange for a window with a non-client area */
739 static const struct message WmSetScrollRangeHV_NC_Seq[] =
740 {
741 { WM_WINDOWPOSCHANGING, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER*/ },
742 { WM_NCCALCSIZE, sent|wparam, 1 },
743 { WM_NCPAINT, sent|optional },
744 { WM_GETTEXT, sent|defwinproc|optional },
745 { WM_GETICON, sent|optional|defwinproc },
746 { WM_GETICON, sent|optional|defwinproc },
747 { WM_GETICON, sent|optional|defwinproc },
748 { WM_GETTEXT, sent|defwinproc|optional },
749 { WM_ERASEBKGND, sent|optional },
750 { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
751 { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|0x1000*/ },
752 { WM_SIZE, sent|defwinproc },
753 { WM_GETTEXT, sent|optional },
754 { WM_GETICON, sent|optional },
755 { WM_GETICON, sent|optional },
756 { WM_GETICON, sent|optional },
757 { WM_GETTEXT, sent|optional },
758 { WM_GETICON, sent|optional },
759 { WM_GETICON, sent|optional },
760 { WM_GETICON, sent|optional },
761 { WM_GETTEXT, sent|optional },
762 { WM_GETICON, sent|optional },
763 { WM_GETICON, sent|optional },
764 { WM_GETICON, sent|optional },
765 { WM_GETTEXT, sent|optional },
766 { 0 }
767 };
768
769 static int after_end_dialog;
770 static int sequence_cnt, sequence_size;
771 static struct message* sequence;
772
773 static void add_message(const struct message *msg)
774 {
775 if (!sequence)
776 {
777 sequence_size = 10;
778 sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) );
779 }
780 if (sequence_cnt == sequence_size)
781 {
782 sequence_size *= 2;
783 sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) );
784 }
785 assert(sequence);
786
787 sequence[sequence_cnt].message = msg->message;
788 sequence[sequence_cnt].flags = msg->flags;
789 sequence[sequence_cnt].wParam = msg->wParam;
790 sequence[sequence_cnt].lParam = msg->lParam;
791
792 sequence_cnt++;
793 }
794
795 static void flush_sequence()
796 {
797 HeapFree(GetProcessHeap(), 0, sequence);
798 sequence = 0;
799 sequence_cnt = sequence_size = 0;
800 }
801
802 static void ok_sequence(const struct message *expected, const char *context, int todo)
803 {
804 static const struct message end_of_sequence = { 0, 0, 0, 0 };
805 const struct message *actual;
806
807 add_message(&end_of_sequence);
808
809 actual = sequence;
810
811 while (expected->message && actual->message)
812 {
813 trace("expected %04x - actual %04x\n", expected->message, actual->message);
814
815 if (expected->message == actual->message)
816 {
817 if (expected->flags & wparam)
818 {
819 if (expected->wParam != actual->wParam && todo)
820 {
821 todo_wine {
822 ok (FALSE,
823 "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
824 context, expected->message, expected->wParam, actual->wParam);
825 }
826 }
827 else
828 ok (expected->wParam == actual->wParam,
829 "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
830 context, expected->message, expected->wParam, actual->wParam);
831 }
832 if (expected->flags & lparam)
833 ok (expected->lParam == actual->lParam,
834 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
835 context, expected->message, expected->lParam, actual->lParam);
836 ok ((expected->flags & defwinproc) == (actual->flags & defwinproc),
837 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
838 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
839 ok ((expected->flags & beginpaint) == (actual->flags & beginpaint),
840 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
841 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
842 ok ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
843 "%s: the msg 0x%04x should have been %s\n",
844 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
845 ok ((expected->flags & parent) == (actual->flags & parent),
846 "%s: the msg 0x%04x was expected in %s\n",
847 context, expected->message, (expected->flags & parent) ? "parent" : "child");
848 ok ((expected->flags & hook) == (actual->flags & hook),
849 "%s: the msg 0x%04x should have been sent by a hook\n",
850 context, expected->message);
851 expected++;
852 actual++;
853 }
854 else if (expected->flags & optional)
855 expected++;
856 else if (todo)
857 {
858 todo_wine {
859 ok (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
860 context, expected->message, actual->message);
861 }
862 flush_sequence();
863 return;
864 }
865 else
866 {
867 ok (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
868 context, expected->message, actual->message);
869 expected++;
870 actual++;
871 }
872 }
873
874 /* skip all optional trailing messages */
875 while (expected->message && (expected->flags & optional))
876 expected++;
877
878 if (todo)
879 {
880 todo_wine {
881 if (expected->message || actual->message)
882 ok (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
883 context, expected->message, actual->message);
884 }
885 }
886 else
887 {
888 if (expected->message || actual->message)
889 ok (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
890 context, expected->message, actual->message);
891 }
892
893 flush_sequence();
894 }
895
896 /******************************** MDI test **********************************/
897
898 /* CreateWindow for MDI frame window, initially visible */
899 static const struct message WmCreateMDIframeSeq[] = {
900 { HCBT_CREATEWND, hook },
901 { WM_GETMINMAXINFO, sent },
902 { WM_NCCREATE, sent },
903 { WM_NCCALCSIZE, sent|wparam, 0 },
904 { WM_CREATE, sent },
905 { WM_SHOWWINDOW, sent|wparam, 1 },
906 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
907 { HCBT_ACTIVATE, hook },
908 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
909 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
910 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* Win9x */
911 { WM_ACTIVATEAPP, sent|wparam, 1 },
912 { WM_NCACTIVATE, sent|wparam, 1 },
913 { WM_ACTIVATE, sent|wparam, 1 },
914 { HCBT_SETFOCUS, hook },
915 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
916 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
917 /* Win9x adds SWP_NOZORDER below */
918 { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
919 { WM_SIZE, sent },
920 { WM_MOVE, sent },
921 { 0 }
922 };
923 /* DestroyWindow for MDI frame window, initially visible */
924 static const struct message WmDestroyMDIframeSeq[] = {
925 { HCBT_DESTROYWND, hook },
926 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
927 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
928 { WM_NCACTIVATE, sent|wparam, 0 },
929 { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
930 { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
931 { WM_DESTROY, sent },
932 { WM_NCDESTROY, sent },
933 { 0 }
934 };
935 /* CreateWindow for MDI client window, initially visible */
936 static const struct message WmCreateMDIclientSeq[] = {
937 { HCBT_CREATEWND, hook },
938 { WM_NCCREATE, sent },
939 { WM_NCCALCSIZE, sent|wparam, 0 },
940 { WM_CREATE, sent },
941 { WM_SIZE, sent },
942 { WM_MOVE, sent },
943 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
944 { WM_SHOWWINDOW, sent|wparam, 1 },
945 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE },
946 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
947 { 0 }
948 };
949 /* DestroyWindow for MDI client window, initially visible */
950 static const struct message WmDestroyMDIclientSeq[] = {
951 { HCBT_DESTROYWND, hook },
952 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
953 { WM_SHOWWINDOW, sent|wparam, 0 },
954 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
955 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
956 { WM_DESTROY, sent },
957 { WM_NCDESTROY, sent },
958 { 0 }
959 };
960 /* CreateWindow for MDI child window, initially visible */
961 static const struct message WmCreateMDIchildVisibleSeq[] = {
962 { HCBT_CREATEWND, hook },
963 { WM_NCCREATE, sent },
964 { WM_NCCALCSIZE, sent|wparam, 0 },
965 { WM_CREATE, sent },
966 { WM_SIZE, sent },
967 { WM_MOVE, sent },
968 /* Win2k sends wparam set to
969 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
970 * while Win9x doesn't bother to set child window id according to
971 * CLIENTCREATESTRUCT.idFirstChild
972 */
973 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
974 { WM_SHOWWINDOW, sent|wparam, 1 },
975 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
976 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
977 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
978 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
979 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
980 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
981
982 /* Win9x: message sequence terminates here. */
983
984 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
985 { HCBT_SETFOCUS, hook }, /* in MDI client */
986 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
987 { WM_SETFOCUS, sent }, /* in MDI client */
988 { HCBT_SETFOCUS, hook },
989 { WM_KILLFOCUS, sent }, /* in MDI client */
990 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
991 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
992 { WM_SETFOCUS, sent|defwinproc },
993 { WM_MDIACTIVATE, sent|defwinproc },
994 { 0 }
995 };
996 /* DestroyWindow for MDI child window, initially visible */
997 static const struct message WmDestroyMDIchildVisibleSeq[] = {
998 { HCBT_DESTROYWND, hook },
999 /* Win2k sends wparam set to
1000 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1001 * while Win9x doesn't bother to set child window id according to
1002 * CLIENTCREATESTRUCT.idFirstChild
1003 */
1004 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1005 { WM_SHOWWINDOW, sent|wparam, 0 },
1006 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1007 { WM_ERASEBKGND, sent|parent|optional },
1008 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1009
1010 /* { WM_DESTROY, sent }
1011 * Win9x: message sequence terminates here.
1012 */
1013
1014 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1015 { WM_KILLFOCUS, sent },
1016 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1017 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1018 { WM_SETFOCUS, sent }, /* in MDI client */
1019
1020 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1021 { WM_KILLFOCUS, sent }, /* in MDI client */
1022 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1023 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1024 { WM_SETFOCUS, sent }, /* in MDI client */
1025
1026 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1027 { WM_KILLFOCUS, sent },
1028 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1029 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1030 { WM_SETFOCUS, sent }, /* in MDI client */
1031
1032 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1033 { WM_KILLFOCUS, sent }, /* in MDI client */
1034 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1035 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1036 { WM_SETFOCUS, sent }, /* in MDI client */
1037
1038 { WM_DESTROY, sent },
1039
1040 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1041 { WM_KILLFOCUS, sent },
1042 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1043 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1044 { WM_SETFOCUS, sent }, /* in MDI client */
1045
1046 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1047 { WM_KILLFOCUS, sent }, /* in MDI client */
1048 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1049 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1050 { WM_SETFOCUS, sent }, /* in MDI client */
1051
1052 { WM_NCDESTROY, sent },
1053 { 0 }
1054 };
1055 /* CreateWindow for MDI child window, initially invisible */
1056 static const struct message WmCreateMDIchildInvisibleSeq[] = {
1057 { HCBT_CREATEWND, hook },
1058 { WM_NCCREATE, sent },
1059 { WM_NCCALCSIZE, sent|wparam, 0 },
1060 { WM_CREATE, sent },
1061 { WM_SIZE, sent },
1062 { WM_MOVE, sent },
1063 /* Win2k sends wparam set to
1064 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1065 * while Win9x doesn't bother to set child window id according to
1066 * CLIENTCREATESTRUCT.idFirstChild
1067 */
1068 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1069 { 0 }
1070 };
1071 /* DestroyWindow for MDI child window, initially invisible */
1072 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
1073 { HCBT_DESTROYWND, hook },
1074 /* Win2k sends wparam set to
1075 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1076 * while Win9x doesn't bother to set child window id according to
1077 * CLIENTCREATESTRUCT.idFirstChild
1078 */
1079 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1080 { WM_DESTROY, sent },
1081 { WM_NCDESTROY, sent },
1082 { 0 }
1083 };
1084 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
1085 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
1086 { HCBT_CREATEWND, hook },
1087 { WM_NCCREATE, sent },
1088 { WM_NCCALCSIZE, sent|wparam, 0 },
1089 { WM_CREATE, sent },
1090 { WM_SIZE, sent },
1091 { WM_MOVE, sent },
1092 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1093 { WM_GETMINMAXINFO, sent },
1094 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1095 { WM_NCCALCSIZE, sent|wparam, 1 },
1096 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1097 { WM_SIZE, sent|defwinproc },
1098 /* in MDI frame */
1099 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1100 { WM_NCCALCSIZE, sent|wparam, 1 },
1101 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1102 /* Win2k sends wparam set to
1103 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1104 * while Win9x doesn't bother to set child window id according to
1105 * CLIENTCREATESTRUCT.idFirstChild
1106 */
1107 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1108 { WM_SHOWWINDOW, sent|wparam, 1 },
1109 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1110 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1111 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1112 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1113 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1114 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1115
1116 /* Win9x: message sequence terminates here. */
1117
1118 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1119 { HCBT_SETFOCUS, hook }, /* in MDI client */
1120 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1121 { WM_SETFOCUS, sent }, /* in MDI client */
1122 { HCBT_SETFOCUS, hook },
1123 { WM_KILLFOCUS, sent }, /* in MDI client */
1124 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1125 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1126 { WM_SETFOCUS, sent|defwinproc },
1127 { WM_MDIACTIVATE, sent|defwinproc },
1128 /* in MDI frame */
1129 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1130 { WM_NCCALCSIZE, sent|wparam, 1 },
1131 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1132 { 0 }
1133 };
1134 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
1135 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
1136 /* restore the 1st MDI child */
1137 { WM_SETREDRAW, sent|wparam, 0 },
1138 { HCBT_MINMAX, hook },
1139 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1140 { WM_NCCALCSIZE, sent|wparam, 1 },
1141 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1142 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1143 { WM_SIZE, sent|defwinproc },
1144 /* in MDI frame */
1145 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1146 { WM_NCCALCSIZE, sent|wparam, 1 },
1147 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1148 { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
1149 /* create the 2nd MDI child */
1150 { HCBT_CREATEWND, hook },
1151 { WM_NCCREATE, sent },
1152 { WM_NCCALCSIZE, sent|wparam, 0 },
1153 { WM_CREATE, sent },
1154 { WM_SIZE, sent },
1155 { WM_MOVE, sent },
1156 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1157 { WM_GETMINMAXINFO, sent },
1158 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1159 { WM_NCCALCSIZE, sent|wparam, 1 },
1160 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1161 { WM_SIZE, sent|defwinproc },
1162 /* in MDI frame */
1163 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1164 { WM_NCCALCSIZE, sent|wparam, 1 },
1165 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1166 /* Win2k sends wparam set to
1167 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1168 * while Win9x doesn't bother to set child window id according to
1169 * CLIENTCREATESTRUCT.idFirstChild
1170 */
1171 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1172 { WM_SHOWWINDOW, sent|wparam, 1 },
1173 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1174 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1175 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1176 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1177 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1178
1179 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
1180 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
1181
1182 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1183
1184 /* Win9x: message sequence terminates here. */
1185
1186 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1187 { HCBT_SETFOCUS, hook },
1188 { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
1189 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
1190 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1191 { WM_SETFOCUS, sent }, /* in MDI client */
1192 { HCBT_SETFOCUS, hook },
1193 { WM_KILLFOCUS, sent }, /* in MDI client */
1194 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1195 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1196 { WM_SETFOCUS, sent|defwinproc },
1197
1198 { WM_MDIACTIVATE, sent|defwinproc },
1199 /* in MDI frame */
1200 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1201 { WM_NCCALCSIZE, sent|wparam, 1 },
1202 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1203 { 0 }
1204 };
1205 /* WM_MDICREATE MDI child window, initially visible and maximized */
1206 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
1207 { WM_MDICREATE, sent },
1208 { HCBT_CREATEWND, hook },
1209 { WM_NCCREATE, sent },
1210 { WM_NCCALCSIZE, sent|wparam, 0 },
1211 { WM_CREATE, sent },
1212 { WM_SIZE, sent },
1213 { WM_MOVE, sent },
1214 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1215 { WM_GETMINMAXINFO, sent },
1216 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1217 { WM_NCCALCSIZE, sent|wparam, 1 },
1218 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1219 { WM_SIZE, sent|defwinproc },
1220 /* in MDI frame */
1221 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1222 { WM_NCCALCSIZE, sent|wparam, 1 },
1223 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1224 /* Win2k sends wparam set to
1225 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1226 * while Win9x doesn't bother to set child window id according to
1227 * CLIENTCREATESTRUCT.idFirstChild
1228 */
1229 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1230 { WM_SHOWWINDOW, sent|wparam, 1 },
1231 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1232 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1233 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1234 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1235 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1236 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1237
1238 /* Win9x: message sequence terminates here. */
1239
1240 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1241 { HCBT_SETFOCUS, hook }, /* in MDI client */
1242 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1243 { WM_SETFOCUS, sent }, /* in MDI client */
1244 { HCBT_SETFOCUS, hook },
1245 { WM_KILLFOCUS, sent }, /* in MDI client */
1246 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1247 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1248 { WM_SETFOCUS, sent|defwinproc },
1249
1250 { WM_MDIACTIVATE, sent|defwinproc },
1251
1252 /* in MDI child */
1253 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1254 { WM_NCCALCSIZE, sent|wparam, 1 },
1255 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1256
1257 /* in MDI frame */
1258 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1259 { WM_NCCALCSIZE, sent|wparam, 1 },
1260 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1261 { WM_MOVE, sent|defwinproc },
1262 { WM_SIZE, sent|defwinproc },
1263
1264 /* in MDI client */
1265 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1266 { WM_NCCALCSIZE, sent|wparam, 1 },
1267 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1268 { WM_SIZE, sent },
1269
1270 /* in MDI child */
1271 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1272 { WM_NCCALCSIZE, sent|wparam, 1 },
1273 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1274 { WM_SIZE, sent|defwinproc },
1275
1276 { 0 }
1277 };
1278 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
1279 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
1280 { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
1281 { HCBT_SYSCOMMAND, hook },
1282 { WM_CLOSE, sent|defwinproc },
1283 { WM_MDIDESTROY, sent }, /* in MDI client */
1284
1285 /* bring the 1st MDI child to top */
1286 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
1287 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
1288 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
1289 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
1290 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
1291
1292 /* maximize the 1st MDI child */
1293 { HCBT_MINMAX, hook },
1294 { WM_GETMINMAXINFO, sent|defwinproc },
1295 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|0x8000 },
1296 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1297 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
1298 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1299 { WM_SIZE, sent|defwinproc },
1300
1301 /* restore the 2nd MDI child */
1302 { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
1303 { HCBT_MINMAX, hook },
1304 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOZORDER|0x8000 },
1305 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1306 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1307 { WM_SIZE, sent|defwinproc },
1308 { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
1309 /* in MDI frame */
1310 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1311 { WM_NCCALCSIZE, sent|wparam, 1 },
1312 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1313
1314 /* bring the 1st MDI child to top */
1315 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1316 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1317 { HCBT_SETFOCUS, hook },
1318 { WM_KILLFOCUS, sent|defwinproc },
1319 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
1320 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1321 { WM_SETFOCUS, sent }, /* in MDI client */
1322 { HCBT_SETFOCUS, hook },
1323 { WM_KILLFOCUS, sent }, /* in MDI client */
1324 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1325 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1326 { WM_SETFOCUS, sent|defwinproc },
1327 { WM_MDIACTIVATE, sent|defwinproc },
1328 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1329
1330 /* apparently ShowWindow(SW_SHOW) on an MDI client */
1331 { WM_SHOWWINDOW, sent|wparam, 1 },
1332 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1333 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1334 { WM_MDIREFRESHMENU, sent },
1335
1336 { HCBT_DESTROYWND, hook },
1337 /* Win2k sends wparam set to
1338 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1339 * while Win9x doesn't bother to set child window id according to
1340 * CLIENTCREATESTRUCT.idFirstChild
1341 */
1342 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1343 { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
1344 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1345 { WM_ERASEBKGND, sent|parent|optional },
1346 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1347
1348 { WM_DESTROY, sent|defwinproc },
1349 { WM_NCDESTROY, sent|defwinproc },
1350 { 0 }
1351 };
1352 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
1353 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
1354 { WM_MDIDESTROY, sent }, /* in MDI client */
1355 { WM_SHOWWINDOW, sent|wparam, 0 },
1356 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1357 { WM_ERASEBKGND, sent|parent|optional },
1358 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1359
1360 { HCBT_SETFOCUS, hook },
1361 { WM_KILLFOCUS, sent },
1362 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1363 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1364 { WM_SETFOCUS, sent }, /* in MDI client */
1365 { HCBT_SETFOCUS, hook },
1366 { WM_KILLFOCUS, sent }, /* in MDI client */
1367 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1368 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1369 { WM_SETFOCUS, sent },
1370
1371 /* in MDI child */
1372 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1373 { WM_NCCALCSIZE, sent|wparam, 1 },
1374 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1375
1376 /* in MDI frame */
1377 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1378 { WM_NCCALCSIZE, sent|wparam, 1 },
1379 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1380 { WM_MOVE, sent|defwinproc },
1381 { WM_SIZE, sent|defwinproc },
1382
1383 /* in MDI client */
1384 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1385 { WM_NCCALCSIZE, sent|wparam, 1 },
1386 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1387 { WM_SIZE, sent },
1388
1389 /* in MDI child */
1390 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1391 { WM_NCCALCSIZE, sent|wparam, 1 },
1392 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
1393 { WM_SIZE, sent|defwinproc },
1394
1395 /* in MDI child */
1396 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1397 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1398 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1399
1400 /* in MDI frame */
1401 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1402 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1403 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1404 { WM_MOVE, sent|defwinproc },
1405 { WM_SIZE, sent|defwinproc },
1406
1407 /* in MDI client */
1408 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1409 { WM_NCCALCSIZE, sent|wparam, 1 },
1410 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1411 { WM_SIZE, sent },
1412
1413 /* in MDI child */
1414 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOZORDER },
1415 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1416 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
1417 { WM_SIZE, sent|defwinproc },
1418
1419 /* in MDI frame */
1420 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1421 { WM_NCCALCSIZE, sent|wparam, 1 },
1422 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1423
1424 { WM_NCACTIVATE, sent|wparam, 0 },
1425 { WM_MDIACTIVATE, sent },
1426
1427 { HCBT_MINMAX, hook },
1428 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|0x8000 },
1429 { WM_NCCALCSIZE, sent|wparam, 1 },
1430 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1431 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE|0x8000 },
1432 { WM_SIZE, sent|defwinproc },
1433
1434 /* in MDI child */
1435 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1436 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
1437 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1438
1439 /* in MDI frame */
1440 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1441 { WM_NCCALCSIZE, sent|wparam, 1 },
1442 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1443 { WM_MOVE, sent|defwinproc },
1444 { WM_SIZE, sent|defwinproc },
1445
1446 /* in MDI client */
1447 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1448 { WM_NCCALCSIZE, sent|wparam, 1 },
1449 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1450 { WM_SIZE, sent },
1451
1452 { HCBT_SETFOCUS, hook },
1453 { WM_KILLFOCUS, sent },
1454 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1455 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1456 { WM_SETFOCUS, sent }, /* in MDI client */
1457
1458 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
1459
1460 { HCBT_DESTROYWND, hook },
1461 /* Win2k sends wparam set to
1462 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1463 * while Win9x doesn't bother to set child window id according to
1464 * CLIENTCREATESTRUCT.idFirstChild
1465 */
1466 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1467
1468 { WM_SHOWWINDOW, sent|wparam, 0 },
1469 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1470 { WM_ERASEBKGND, sent|parent|optional },
1471 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1472
1473 { WM_DESTROY, sent },
1474 { WM_NCDESTROY, sent },
1475 { 0 }
1476 };
1477 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
1478 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
1479 { HCBT_MINMAX, hook },
1480 { WM_GETMINMAXINFO, sent },
1481 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
1482 { WM_NCCALCSIZE, sent|wparam, 1 },
1483 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1484
1485 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1486 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1487 { HCBT_SETFOCUS, hook },
1488 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1489 { WM_SETFOCUS, sent }, /* in MDI client */
1490 { HCBT_SETFOCUS, hook },
1491 { WM_KILLFOCUS, sent }, /* in MDI client */
1492 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1493 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1494 { WM_SETFOCUS, sent|defwinproc },
1495 { WM_MDIACTIVATE, sent|defwinproc },
1496 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1497 { WM_SIZE, sent|defwinproc },
1498 /* in MDI frame */
1499 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1500 { WM_NCCALCSIZE, sent|wparam, 1 },
1501 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1502 { 0 }
1503 };
1504 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
1505 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
1506 { HCBT_MINMAX, hook },
1507 { WM_GETMINMAXINFO, sent },
1508 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1509 { WM_NCCALCSIZE, sent|wparam, 1 },
1510 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1511 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1512 { WM_SIZE, sent|defwinproc },
1513 /* in MDI frame */
1514 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1515 { WM_NCCALCSIZE, sent|wparam, 1 },
1516 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1517 { 0 }
1518 };
1519 /* ShowWindow(SW_RESTORE) for a visible MDI child window */
1520 static const struct message WmRestoreMDIchildVisibleSeq[] = {
1521 { HCBT_MINMAX, hook },
1522 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1523 { WM_NCCALCSIZE, sent|wparam, 1 },
1524 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1525 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1526 { WM_SIZE, sent|defwinproc },
1527 /* in MDI frame */
1528 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1529 { WM_NCCALCSIZE, sent|wparam, 1 },
1530 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1531 { 0 }
1532 };
1533 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
1534 static const struct message WmRestoreMDIchildInisibleSeq[] = {
1535 { HCBT_MINMAX, hook },
1536 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
1537 { WM_NCCALCSIZE, sent|wparam, 1 },
1538 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1539 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1540 { WM_SIZE, sent|defwinproc },
1541 /* in MDI frame */
1542 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1543 { WM_NCCALCSIZE, sent|wparam, 1 },
1544 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1545 { 0 }
1546 };
1547
1548 static HWND mdi_client;
1549 static WNDPROC old_mdi_client_proc;
1550
1551 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1552 {
1553 struct message msg;
1554
1555 /* do not log painting messages */
1556 if (message != WM_PAINT &&
1557 message != WM_ERASEBKGND &&
1558 message != WM_NCPAINT &&
1559 message != WM_GETTEXT &&
1560 message != WM_MDIGETACTIVE)
1561 {
1562 trace("mdi client: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
1563
1564 switch (message)
1565 {
1566 case WM_WINDOWPOSCHANGING:
1567 case WM_WINDOWPOSCHANGED:
1568 {
1569 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
1570
1571 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1572 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1573 winpos->hwnd, winpos->hwndInsertAfter,
1574 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1575
1576 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1577 * in the high word for internal purposes
1578 */
1579 wParam = winpos->flags & 0xffff;
1580 break;
1581 }
1582 }
1583
1584 msg.message = message;
1585 msg.flags = sent|wparam|lparam;
1586 msg.wParam = wParam;
1587 msg.lParam = lParam;
1588 add_message(&msg);
1589 }
1590
1591 return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
1592 }
1593
1594 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1595 {
1596 static long defwndproc_counter = 0;
1597 LRESULT ret;
1598 struct message msg;
1599
1600 /* do not log painting messages */
1601 if (message != WM_PAINT &&
1602 message != WM_ERASEBKGND &&
1603 message != WM_NCPAINT &&
1604 message != WM_GETTEXT)
1605 {
1606 trace("mdi child: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
1607
1608 switch (message)
1609 {
1610 case WM_WINDOWPOSCHANGING:
1611 case WM_WINDOWPOSCHANGED:
1612 {
1613 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
1614
1615 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1616 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1617 winpos->hwnd, winpos->hwndInsertAfter,
1618 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1619
1620 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1621 * in the high word for internal purposes
1622 */
1623 wParam = winpos->flags & 0xffff;
1624 break;
1625 }
1626
1627 case WM_MDIACTIVATE:
1628 {
1629 HWND active, client = GetParent(hwnd);
1630
1631 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
1632
1633 if (hwnd == (HWND)lParam) /* if we are being activated */
1634 ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
1635 else
1636 ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
1637 break;
1638 }
1639 }
1640
1641 msg.message = message;
1642 msg.flags = sent|wparam|lparam;
1643 if (defwndproc_counter) msg.flags |= defwinproc;
1644 msg.wParam = wParam;
1645 msg.lParam = lParam;
1646 add_message(&msg);
1647 }
1648
1649 defwndproc_counter++;
1650 ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
1651 defwndproc_counter--;
1652
1653 return ret;
1654 }
1655
1656 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1657 {
1658 static long defwndproc_counter = 0;
1659 LRESULT ret;
1660 struct message msg;
1661
1662 /* do not log painting messages */
1663 if (message != WM_PAINT &&
1664 message != WM_ERASEBKGND &&
1665 message != WM_NCPAINT &&
1666 message != WM_GETTEXT)
1667 {
1668 trace("mdi frame: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
1669
1670 switch (message)
1671 {
1672 case WM_WINDOWPOSCHANGING:
1673 case WM_WINDOWPOSCHANGED:
1674 {
1675 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
1676
1677 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
1678 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
1679 winpos->hwnd, winpos->hwndInsertAfter,
1680 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
1681
1682 /* Log only documented flags, win2k uses 0x1000 and 0x2000
1683 * in the high word for internal purposes
1684 */
1685 wParam = winpos->flags & 0xffff;
1686 break;
1687 }
1688 }
1689
1690 msg.message = message;
1691 msg.flags = sent|wparam|lparam;
1692 if (defwndproc_counter) msg.flags |= defwinproc;
1693 msg.wParam = wParam;
1694 msg.lParam = lParam;
1695 add_message(&msg);
1696 }
1697
1698 defwndproc_counter++;
1699 ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
1700 defwndproc_counter--;
1701
1702 return ret;
1703 }
1704
1705 static BOOL mdi_RegisterWindowClasses(void)
1706 {
1707 WNDCLASSA cls;
1708
1709 cls.style = 0;
1710 cls.lpfnWndProc = mdi_frame_wnd_proc;
1711 cls.cbClsExtra = 0;
1712 cls.cbWndExtra = 0;
1713 cls.hInstance = GetModuleHandleA(0);
1714 cls.hIcon = 0;
1715 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
1716 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
1717 cls.lpszMenuName = NULL;
1718 cls.lpszClassName = "MDI_frame_class";
1719 if (!RegisterClassA(&cls)) return FALSE;
1720
1721 cls.lpfnWndProc = mdi_child_wnd_proc;
1722 cls.lpszClassName = "MDI_child_class";
1723 if (!RegisterClassA(&cls)) return FALSE;
1724
1725 if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
1726 old_mdi_client_proc = cls.lpfnWndProc;
1727 cls.hInstance = GetModuleHandleA(0);
1728 cls.lpfnWndProc = mdi_client_hook_proc;
1729 cls.lpszClassName = "MDI_client_class";
1730 if (!RegisterClassA(&cls)) assert(0);
1731
1732 return TRUE;
1733 }
1734
1735 static void test_mdi_messages(void)
1736 {
1737 MDICREATESTRUCTA mdi_cs;
1738 CLIENTCREATESTRUCT client_cs;
1739 HWND mdi_frame, mdi_child, mdi_child2, active_child;
1740 BOOL zoomed;
1741 HMENU hMenu = CreateMenu();
1742
1743 assert(mdi_RegisterWindowClasses());
1744
1745 flush_sequence();
1746
1747 trace("creating MDI frame window\n");
1748 mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
1749 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
1750 WS_MAXIMIZEBOX | WS_VISIBLE,
1751 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
1752 GetDesktopWindow(), hMenu,
1753 GetModuleHandleA(0), NULL);
1754 assert(mdi_frame);
1755 ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", TRUE);
1756
1757 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1758 ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
1759
1760 trace("creating MDI client window\n");
1761 client_cs.hWindowMenu = 0;
1762 client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
1763 mdi_client = CreateWindowExA(0, "MDI_client_class",
1764 NULL,
1765 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
1766 0, 0, 0, 0,
1767 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
1768 assert(mdi_client);
1769 ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
1770
1771 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1772 ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
1773
1774 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1775 ok(!active_child, "wrong active MDI child %p\n", active_child);
1776 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
1777
1778 SetFocus(0);
1779 flush_sequence();
1780
1781 trace("creating visible MDI child window\n");
1782 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
1783 WS_CHILD | WS_VISIBLE,
1784 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
1785 mdi_client, 0, GetModuleHandleA(0), NULL);
1786 assert(mdi_child);
1787 ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", TRUE);
1788
1789 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
1790 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
1791
1792 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1793 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
1794
1795 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1796 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
1797 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
1798 flush_sequence();
1799
1800 DestroyWindow(mdi_child);
1801 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
1802
1803 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1804 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1805
1806 /* Win2k: MDI client still returns a just destroyed child as active
1807 * Win9x: MDI client returns 0
1808 */
1809 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1810 ok(active_child == mdi_child || /* win2k */
1811 !active_child, /* win9x */
1812 "wrong active MDI child %p\n", active_child);
1813 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
1814
1815 flush_sequence();
1816
1817 trace("creating invisible MDI child window\n");
1818 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
1819 WS_CHILD,
1820 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
1821 mdi_client, 0, GetModuleHandleA(0), NULL);
1822 assert(mdi_child2);
1823 ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
1824
1825 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
1826 ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
1827
1828 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1829 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1830
1831 /* Win2k: MDI client still returns a just destroyed child as active
1832 * Win9x: MDI client returns mdi_child2
1833 */
1834 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1835 ok(active_child == mdi_child || /* win2k */
1836 active_child == mdi_child2, /* win9x */
1837 "wrong active MDI child %p\n", active_child);
1838 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
1839 flush_sequence();
1840
1841 ShowWindow(mdi_child2, SW_MAXIMIZE);
1842 ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", TRUE);
1843
1844 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
1845 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
1846
1847 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1848 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
1849 ok(zoomed, "wrong zoomed state %d\n", zoomed);
1850 flush_sequence();
1851
1852 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1853 ok(GetFocus() == mdi_child2 || /* win2k */
1854 GetFocus() == 0, /* win9x */
1855 "wrong focus window %p\n", GetFocus());
1856
1857 SetFocus(0);
1858 flush_sequence();
1859
1860 ShowWindow(mdi_child2, SW_HIDE);
1861 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
1862
1863 ShowWindow(mdi_child2, SW_RESTORE);
1864 ok_sequence(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", TRUE);
1865 flush_sequence();
1866
1867 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
1868 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
1869
1870 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1871 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
1872 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
1873 flush_sequence();
1874
1875 SetFocus(0);
1876 flush_sequence();
1877
1878 ShowWindow(mdi_child2, SW_HIDE);
1879 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
1880
1881 ShowWindow(mdi_child2, SW_SHOW);
1882 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", TRUE);
1883
1884 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1885 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1886
1887 ShowWindow(mdi_child2, SW_MAXIMIZE);
1888 ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", TRUE);
1889
1890 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1891 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1892
1893 ShowWindow(mdi_child2, SW_RESTORE);
1894 ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):MDI child", TRUE);
1895
1896 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1897 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1898
1899 SetFocus(0);
1900 flush_sequence();
1901
1902 ShowWindow(mdi_child2, SW_HIDE);
1903 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
1904
1905 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1906 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1907
1908 DestroyWindow(mdi_child2);
1909 ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", TRUE);
1910
1911 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1912 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1913
1914 /* test for maximized MDI children */
1915 trace("creating maximized visible MDI child window 1\n");
1916 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
1917 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
1918 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
1919 mdi_client, 0, GetModuleHandleA(0), NULL);
1920 assert(mdi_child);
1921 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
1922 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
1923
1924 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1925 ok(GetFocus() == mdi_child || /* win2k */
1926 GetFocus() == 0, /* win9x */
1927 "wrong focus window %p\n", GetFocus());
1928
1929 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1930 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
1931 ok(zoomed, "wrong zoomed state %d\n", zoomed);
1932 flush_sequence();
1933
1934 trace("creating maximized visible MDI child window 2\n");
1935 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
1936 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
1937 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
1938 mdi_client, 0, GetModuleHandleA(0), NULL);
1939 assert(mdi_child2);
1940 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
1941 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
1942 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
1943
1944 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1945 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
1946
1947 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1948 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
1949 ok(zoomed, "wrong zoomed state %d\n", zoomed);
1950 flush_sequence();
1951
1952 trace("destroying maximized visible MDI child window 2\n");
1953 DestroyWindow(mdi_child2);
1954 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
1955
1956 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
1957
1958 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1959 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
1960
1961 /* Win2k: MDI client still returns a just destroyed child as active
1962 * Win9x: MDI client returns 0
1963 */
1964 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1965 ok(active_child == mdi_child2 || /* win2k */
1966 !active_child, /* win9x */
1967 "wrong active MDI child %p\n", active_child);
1968 flush_sequence();
1969
1970 ShowWindow(mdi_child, SW_MAXIMIZE);
1971 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
1972 flush_sequence();
1973
1974 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1975 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
1976
1977 trace("re-creating maximized visible MDI child window 2\n");
1978 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
1979 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
1980 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
1981 mdi_client, 0, GetModuleHandleA(0), NULL);
1982 assert(mdi_child2);
1983 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
1984 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
1985 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
1986
1987 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
1988 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
1989
1990 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
1991 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
1992 ok(zoomed, "wrong zoomed state %d\n", zoomed);
1993 flush_sequence();
1994
1995 SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
1996 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
1997 ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
1998
1999 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2000 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2001 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2002
2003 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2004 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2005 ok(zoomed, "wrong zoomed state %d\n", zoomed);
2006 flush_sequence();
2007
2008 DestroyWindow(mdi_child);
2009 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2010
2011 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2012 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2013
2014 /* Win2k: MDI client still returns a just destroyed child as active
2015 * Win9x: MDI client returns 0
2016 */
2017 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2018 ok(active_child == mdi_child || /* win2k */
2019 !active_child, /* win9x */
2020 "wrong active MDI child %p\n", active_child);
2021 flush_sequence();
2022 /* end of test for maximized MDI children */
2023
2024 mdi_cs.szClass = "MDI_child_Class";
2025 mdi_cs.szTitle = "MDI child";
2026 mdi_cs.hOwner = GetModuleHandleA(0);
2027 mdi_cs.x = 0;
2028 mdi_cs.y = 0;
2029 mdi_cs.cx = CW_USEDEFAULT;
2030 mdi_cs.cy = CW_USEDEFAULT;
2031 mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
2032 mdi_cs.lParam = 0;
2033 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
2034 ok(mdi_child != 0, "MDI child creation failed\n");
2035 ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
2036
2037 ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
2038
2039 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2040 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2041
2042 ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
2043 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2044 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2045
2046 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2047 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2048 ok(zoomed, "wrong zoomed state %d\n", zoomed);
2049 flush_sequence();
2050
2051 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
2052 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
2053
2054 ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
2055 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2056 ok(!active_child, "wrong active MDI child %p\n", active_child);
2057
2058 SetFocus(0);
2059 flush_sequence();
2060
2061 DestroyWindow(mdi_client);
2062 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
2063
2064 DestroyWindow(mdi_frame);
2065 ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
2066 }
2067 /************************* End of MDI test **********************************/
2068
2069 static void test_WM_SETREDRAW(HWND hwnd)
2070 {
2071 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
2072
2073 flush_sequence();
2074
2075 SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
2076 ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
2077
2078 ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
2079 ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
2080
2081 flush_sequence();
2082 SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
2083 ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
2084
2085 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2086 ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
2087
2088 /* restore original WS_VISIBLE state */
2089 SetWindowLongA(hwnd, GWL_STYLE, style);
2090
2091 flush_sequence();
2092 }
2093
2094 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2095 {
2096 struct message msg;
2097
2098 trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2099
2100 msg.message = message;
2101 msg.flags = sent|wparam|lparam;
2102 msg.wParam = wParam;
2103 msg.lParam = lParam;
2104 add_message(&msg);
2105
2106 if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
2107 if (message == WM_TIMER) EndDialog( hwnd, 0 );
2108 return 0;
2109 }
2110
2111 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
2112 {
2113 DWORD style, exstyle;
2114 INT xmin, xmax;
2115
2116 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
2117 style = GetWindowLongA(hwnd, GWL_STYLE);
2118 /* do not be confused by WS_DLGFRAME set */
2119 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
2120
2121 if (clear) ok(style & clear, "style %08lx should be set\n", clear);
2122 if (set) ok(!(style & set), "style %08lx should not be set\n", set);
2123
2124 ok(SetScrollRange(hwnd, ctl, min, max, FALSE), "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
2125 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
2126 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
2127 else
2128 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", TRUE);
2129
2130 style = GetWindowLongA(hwnd, GWL_STYLE);
2131 if (set) ok(style & set, "style %08lx should be set\n", set);
2132 if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
2133
2134 /* a subsequent call should do nothing */
2135 ok(SetScrollRange(hwnd, ctl, min, max, FALSE), "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
2136 ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
2137
2138 xmin = 0xdeadbeef;
2139 xmax = 0xdeadbeef;
2140 trace("Ignore GetScrollRange error below if you are on Win9x\n");
2141 ok(GetScrollRange(hwnd, ctl, &xmin, &xmax), "GetScrollRange(%d) error %ld\n", ctl, GetLastError());
2142 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT)", FALSE);
2143 ok(xmin == min, "unexpected min scroll value %d\n", xmin);
2144 ok(xmax == max, "unexpected max scroll value %d\n", xmax);
2145 }
2146
2147 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
2148 {
2149 DWORD style, exstyle;
2150 SCROLLINFO si;
2151
2152 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
2153 style = GetWindowLongA(hwnd, GWL_STYLE);
2154 /* do not be confused by WS_DLGFRAME set */
2155 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
2156
2157 if (clear) ok(style & clear, "style %08lx should be set\n", clear);
2158 if (set) ok(!(style & set), "style %08lx should not be set\n", set);
2159
2160 si.cbSize = sizeof(si);
2161 si.fMask = SIF_RANGE;
2162 si.nMin = min;
2163 si.nMax = max;
2164 SetScrollInfo(hwnd, ctl, &si, TRUE);
2165 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
2166 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
2167 else
2168 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", TRUE);
2169
2170 style = GetWindowLongA(hwnd, GWL_STYLE);
2171 if (set) ok(style & set, "style %08lx should be set\n", set);
2172 if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
2173
2174 /* a subsequent call should do nothing */
2175 SetScrollInfo(hwnd, ctl, &si, TRUE);
2176 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
2177
2178 si.fMask = SIF_PAGE;
2179 si.nPage = 5;
2180 SetScrollInfo(hwnd, ctl, &si, FALSE);
2181 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
2182
2183 si.fMask = SIF_POS;
2184 si.nPos = max - 1;
2185 SetScrollInfo(hwnd, ctl, &si, FALSE);
2186 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
2187
2188 si.fMask = SIF_RANGE;
2189 si.nMin = 0xdeadbeef;
2190 si.nMax = 0xdeadbeef;
2191 ok(GetScrollInfo(hwnd, ctl, &si), "GetScrollInfo error %ld\n", GetLastError());
2192 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT)", FALSE);
2193 ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
2194 ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
2195 }
2196
2197 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
2198 static void test_scroll_messages(HWND hwnd)
2199 {
2200 SCROLLINFO si;
2201 INT min, max;
2202
2203 min = 0xdeadbeef;
2204 max = 0xdeadbeef;
2205 ok(GetScrollRange(hwnd, SB_CTL, &min, &max), "GetScrollRange error %ld\n", GetLastError());
2206 if (sequence->message != WmGetScrollRangeSeq[0].message)
2207 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2208 /* values of min and max are undefined */
2209 flush_sequence();
2210
2211 ok(SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE), "SetScrollRange error %ld\n", GetLastError());
2212 if (sequence->message != WmSetScrollRangeSeq[0].message)
2213 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2214 flush_sequence();
2215
2216 min = 0xdeadbeef;
2217 max = 0xdeadbeef;
2218 ok(GetScrollRange(hwnd, SB_CTL, &min, &max), "GetScrollRange error %ld\n", GetLastError());
2219 if (sequence->message != WmGetScrollRangeSeq[0].message)
2220 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2221 /* values of min and max are undefined */
2222 flush_sequence();
2223
2224 si.cbSize = sizeof(si);
2225 si.fMask = SIF_RANGE;
2226 si.nMin = 20;
2227 si.nMax = 160;
2228 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2229 if (sequence->message != WmSetScrollRangeSeq[0].message)
2230 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2231 flush_sequence();
2232
2233 si.fMask = SIF_PAGE;
2234 si.nPage = 10;
2235 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2236 if (sequence->message != WmSetScrollRangeSeq[0].message)
2237 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2238 flush_sequence();
2239
2240 si.fMask = SIF_POS;
2241 si.nPos = 20;
2242 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2243 if (sequence->message != WmSetScrollRangeSeq[0].message)
2244 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2245 flush_sequence();
2246
2247 si.fMask = SIF_RANGE;
2248 si.nMin = 0xdeadbeef;
2249 si.nMax = 0xdeadbeef;
2250 ok(GetScrollInfo(hwnd, SB_CTL, &si), "GetScrollInfo error %ld\n", GetLastError());
2251 if (sequence->message != WmGetScrollInfoSeq[0].message)
2252 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2253 /* values of min and max are undefined */
2254 flush_sequence();
2255
2256 /* set WS_HSCROLL */
2257 test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
2258 /* clear WS_HSCROLL */
2259 test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
2260
2261 /* set WS_HSCROLL */
2262 test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
2263 /* clear WS_HSCROLL */
2264 test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
2265
2266 /* set WS_VSCROLL */
2267 test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
2268 /* clear WS_VSCROLL */
2269 test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
2270
2271 /* set WS_VSCROLL */
2272 test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
2273 /* clear WS_VSCROLL */
2274 test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
2275 }
2276
2277 /* test if we receive the right sequence of messages */
2278 static void test_messages(void)
2279 {
2280 HWND hwnd, hparent, hchild;
2281 HWND hchild2, hbutton;
2282 HMENU hmenu;
2283
2284 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
2285 100, 100, 200, 200, 0, 0, 0, NULL);
2286 ok (hwnd != 0, "Failed to create overlapped window\n");
2287 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
2288
2289 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
2290 ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
2291 ok_sequence(WmHideInvisibleOverlappedSeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
2292
2293 /* test WM_SETREDRAW on a not visible top level window */
2294 test_WM_SETREDRAW(hwnd);
2295
2296 SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2297 ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
2298 ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
2299
2300 ok(GetActiveWindow() == hwnd, "window should be active\n");
2301 ok(GetFocus() == hwnd, "window should have input focus\n");
2302 ShowWindow(hwnd, SW_HIDE);
2303 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", TRUE);
2304
2305 ShowWindow(hwnd, SW_SHOW);
2306 ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
2307
2308 ok(GetActiveWindow() == hwnd, "window should be active\n");
2309 ok(GetFocus() == hwnd, "window should have input focus\n");
2310 SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2311 ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", TRUE);
2312 ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
2313
2314 /* test WM_SETREDRAW on a visible top level window */
2315 ShowWindow(hwnd, SW_SHOW);
2316 test_WM_SETREDRAW(hwnd);
2317
2318 trace("testing scroll APIs on a visible top level window %p\n", hwnd);
2319 test_scroll_messages(hwnd);
2320
2321 DestroyWindow(hwnd);
2322 ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
2323
2324 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
2325 100, 100, 200, 200, 0, 0, 0, NULL);
2326 ok (hparent != 0, "Failed to create parent window\n");
2327 flush_sequence();
2328
2329 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
2330 0, 0, 10, 10, hparent, 0, 0, NULL);
2331 ok (hchild != 0, "Failed to create child window\n");
2332 ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", TRUE);
2333 DestroyWindow(hchild);
2334 flush_sequence();
2335
2336 /* visible child window with a caption */
2337 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
2338 WS_CHILD | WS_VISIBLE | WS_CAPTION,
2339 0, 0, 10, 10, hparent, 0, 0, NULL);
2340 ok (hchild != 0, "Failed to create child window\n");
2341 ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
2342
2343 trace("testing scroll APIs on a visible child window %p\n", hchild);
2344 test_scroll_messages(hchild);
2345
2346 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2347 ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
2348
2349 DestroyWindow(hchild);
2350 flush_sequence();
2351
2352 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
2353 0, 0, 10, 10, hparent, 0, 0, NULL);
2354 ok (hchild != 0, "Failed to create child window\n");
2355 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
2356
2357 hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
2358 100, 100, 50, 50, hparent, 0, 0, NULL);
2359 ok (hchild2 != 0, "Failed to create child2 window\n");
2360 flush_sequence();
2361
2362 hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
2363 0, 100, 50, 50, hchild, 0, 0, NULL);
2364 ok (hbutton != 0, "Failed to create button window\n");
2365
2366 /* test WM_SETREDRAW on a not visible child window */
2367 test_WM_SETREDRAW(hchild);
2368
2369 ShowWindow(hchild, SW_SHOW);
2370 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
2371
2372 ShowWindow(hchild, SW_HIDE);
2373 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
2374
2375 ShowWindow(hchild, SW_SHOW);
2376 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
2377
2378 /* test WM_SETREDRAW on a visible child window */
2379 test_WM_SETREDRAW(hchild);
2380
2381 MoveWindow(hchild, 10, 10, 20, 20, TRUE);
2382 ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
2383
2384 ShowWindow(hchild, SW_HIDE);
2385 flush_sequence();
2386 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2387 ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
2388
2389 ShowWindow(hchild, SW_HIDE);
2390 flush_sequence();
2391 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
2392 ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
2393
2394 /* DestroyWindow sequence below expects that a child has focus */
2395 SetFocus(hchild);
2396 flush_sequence();
2397
2398 DestroyWindow(hchild);
2399 ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
2400 DestroyWindow(hchild2);
2401 DestroyWindow(hbutton);
2402
2403 flush_sequence();
2404 hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
2405 0, 0, 100, 100, hparent, 0, 0, NULL);
2406 ok (hchild != 0, "Failed to create child popup window\n");
2407 ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
2408 DestroyWindow(hchild);
2409
2410 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
2411 flush_sequence();
2412 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
2413 0, 0, 100, 100, hparent, 0, 0, NULL);
2414 ok (hchild != 0, "Failed to create popup window\n");
2415 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
2416 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2417 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
2418 flush_sequence();
2419 ShowWindow(hchild, SW_SHOW);
2420 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
2421 flush_sequence();
2422 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2423 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
2424 flush_sequence();
2425 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
2426 ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
2427 DestroyWindow(hchild);
2428
2429 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
2430 * changes nothing in message sequences.
2431 */
2432 flush_sequence();
2433 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
2434 0, 0, 100, 100, hparent, 0, 0, NULL);
2435 ok (hchild != 0, "Failed to create popup window\n");
2436 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
2437 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2438 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
2439 flush_sequence();
2440 ShowWindow(hchild, SW_SHOW);
2441 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
2442 flush_sequence();
2443 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2444 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
2445 DestroyWindow(hchild);
2446
2447 flush_sequence();
2448 hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
2449 0, 0, 100, 100, hparent, 0, 0, NULL);
2450 ok(hwnd != 0, "Failed to create custom dialog window\n");
2451 ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
2452
2453 trace("testing scroll APIs on a visible dialog %p\n", hwnd);
2454 test_scroll_messages(hwnd);
2455
2456 flush_sequence();
2457 after_end_dialog = 1;
2458 EndDialog( hwnd, 0 );
2459 ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
2460
2461 DestroyWindow(hwnd);
2462 after_end_dialog = 0;
2463
2464 flush_sequence();
2465 DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
2466 ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
2467
2468 /* test showing child with hidden parent */
2469 ShowWindow( hparent, SW_HIDE );
2470 flush_sequence();
2471
2472 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
2473 0, 0, 10, 10, hparent, 0, 0, NULL);
2474 ok (hchild != 0, "Failed to create child window\n");
2475 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
2476
2477 ShowWindow( hchild, SW_SHOW );
2478 ok_sequence(WmShowChildInvisibleParentSeq, "ShowWindow:show child with invisible parent", TRUE);
2479 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2480 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2481
2482 ShowWindow( hchild, SW_HIDE );
2483 ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", TRUE);
2484 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
2485 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2486
2487 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2488 ok_sequence(WmShowChildInvisibleParentSeq_2, "SetWindowPos:show child with invisible parent", TRUE);
2489 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2490 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2491
2492 SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
2493 ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", TRUE);
2494 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
2495 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
2496
2497 DestroyWindow(hchild);
2498 DestroyWindow(hparent);
2499 flush_sequence();
2500
2501 /* Message sequence for SetMenu */
2502 ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
2503 ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
2504
2505 hmenu = CreateMenu();
2506 ok (hmenu != 0, "Failed to create menu\n");
2507 ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
2508 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
2509 100, 100, 200, 200, 0, hmenu, 0, NULL);
2510 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
2511 ok (SetMenu(hwnd, 0), "SetMenu\n");
2512 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
2513 ok (SetMenu(hwnd, 0), "SetMenu\n");
2514 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
2515 ShowWindow(hwnd, SW_SHOW);
2516 flush_sequence();
2517 ok (SetMenu(hwnd, 0), "SetMenu\n");
2518 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", TRUE);
2519 ok (SetMenu(hwnd, hmenu), "SetMenu\n");
2520 ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", TRUE);
2521
2522 ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
2523 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", TRUE);
2524
2525 DestroyWindow(hwnd);
2526 flush_sequence();
2527
2528 /* Message sequence for EnableWindow */
2529 hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
2530 100, 100, 200, 200, 0, 0, 0, NULL);
2531 ok (hparent != 0, "Failed to create parent window\n");
2532 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
2533 0, 0, 10, 10, hparent, 0, 0, NULL);
2534 ok (hchild != 0, "Failed to create child window\n");
2535
2536 SetFocus(hchild);
2537 flush_sequence();
2538
2539 EnableWindow(hparent, FALSE);
2540 ok_sequence(WmEnableWindowSeq, "EnableWindow", FALSE);
2541
2542 DestroyWindow(hchild);
2543 DestroyWindow(hparent);
2544 flush_sequence();
2545 }
2546
2547 /****************** button message test *************************/
2548 static const struct message WmSetFocusButtonSeq[] =
2549 {
2550 { HCBT_SETFOCUS, hook },
2551 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2552 { WM_SETFOCUS, sent|wparam, 0 },
2553 { WM_CTLCOLORBTN, sent|defwinproc },
2554 { 0 }
2555 };
2556 static const struct message WmKillFocusButtonSeq[] =
2557 {
2558 { HCBT_SETFOCUS, hook },
2559 { WM_KILLFOCUS, sent|wparam, 0 },
2560 { WM_CTLCOLORBTN, sent|defwinproc },
2561 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2562 { 0 }
2563 };
2564 static const struct message WmSetFocusStaticSeq[] =
2565 {
2566 { HCBT_SETFOCUS, hook },
2567 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2568 { WM_SETFOCUS, sent|wparam, 0 },
2569 { WM_CTLCOLORSTATIC, sent|defwinproc },
2570 { 0 }
2571 };
2572 static const struct message WmKillFocusStaticSeq[] =
2573 {
2574 { HCBT_SETFOCUS, hook },
2575 { WM_KILLFOCUS, sent|wparam, 0 },
2576 { WM_CTLCOLORSTATIC, sent|defwinproc },
2577 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2578 { 0 }
2579 };
2580 static const struct message WmLButtonDownSeq[] =
2581 {
2582 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
2583 { HCBT_SETFOCUS, hook },
2584 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2585 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
2586 { WM_CTLCOLORBTN, sent|defwinproc },
2587 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
2588 { WM_CTLCOLORBTN, sent|defwinproc },
2589 { 0 }
2590 };
2591 static const struct message WmLButtonUpSeq[] =
2592 {
2593 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
2594 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
2595 { WM_CTLCOLORBTN, sent|defwinproc },
2596 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
2597 { 0 }
2598 };
2599
2600 static WNDPROC old_button_proc;
2601
2602 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2603 {
2604 static long defwndproc_counter = 0;
2605 LRESULT ret;
2606 struct message msg;
2607
2608 trace("button: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2609
2610 msg.message = message;
2611 msg.flags = sent|wparam|lparam;
2612 if (defwndproc_counter) msg.flags |= defwinproc;
2613 msg.wParam = wParam;
2614 msg.lParam = lParam;
2615 add_message(&msg);
2616
2617 if (message == BM_SETSTATE)
2618 ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
2619
2620 defwndproc_counter++;
2621 ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
2622 defwndproc_counter--;
2623
2624 return ret;
2625 }
2626
2627 static void subclass_button(void)
2628 {
2629 WNDCLASSA cls;
2630
2631 if (!GetClassInfoA(0, "button", &cls)) assert(0);
2632
2633 old_button_proc = cls.lpfnWndProc;
2634
2635 cls.hInstance = GetModuleHandle(0);
2636 cls.lpfnWndProc = button_hook_proc;
2637 cls.lpszClassName = "my_button_class";
2638 if (!RegisterClassA(&cls)) assert(0);
2639 }
2640
2641 static void test_button_messages(void)
2642 {
2643 static const struct
2644 {
2645 DWORD style;
2646 const struct message *setfocus;
2647 const struct message *killfocus;
2648 } button[] = {
2649 { BS_PUSHBUTTON, WmSetFocusButtonSeq, WmKillFocusButtonSeq },
2650 { BS_DEFPUSHBUTTON, WmSetFocusButtonSeq, WmKillFocusButtonSeq },
2651 { BS_CHECKBOX, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2652 { BS_AUTOCHECKBOX, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2653 { BS_RADIOBUTTON, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2654 { BS_3STATE, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2655 { BS_AUTO3STATE, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2656 { BS_GROUPBOX, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2657 { BS_USERBUTTON, WmSetFocusButtonSeq, WmKillFocusButtonSeq },
2658 { BS_AUTORADIOBUTTON, WmSetFocusStaticSeq, WmKillFocusStaticSeq },
2659 { BS_OWNERDRAW, WmSetFocusButtonSeq, WmKillFocusButtonSeq }
2660 };
2661 unsigned int i;
2662 HWND hwnd;
2663
2664 subclass_button();
2665
2666 for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
2667 {
2668 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
2669 0, 0, 50, 14, 0, 0, 0, NULL);
2670 ok(hwnd != 0, "Failed to create button window\n");
2671
2672 ShowWindow(hwnd, SW_SHOW);
2673 UpdateWindow(hwnd);
2674 SetFocus(0);
2675 flush_sequence();
2676
2677 trace("button style %08lx\n", button[i].style);
2678 SetFocus(hwnd);
2679 ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
2680
2681 SetFocus(0);
2682 ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
2683
2684 DestroyWindow(hwnd);
2685 }
2686
2687 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP | WS_VISIBLE,
2688 0, 0, 50, 14, 0, 0, 0, NULL);
2689 ok(hwnd != 0, "Failed to create button window\n");
2690
2691 SetFocus(0);
2692 flush_sequence();
2693
2694 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
2695 ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
2696
2697 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
2698 ok_sequence(WmLButtonUpSeq, "WM_LBUTTONDOWN on a button", FALSE);
2699 DestroyWindow(hwnd);
2700 }
2701
2702 /************* painting message test ********************/
2703
2704 static void dump_region(HRGN hrgn)
2705 {
2706 DWORD i, size;
2707 RGNDATA *data = NULL;
2708 RECT *rect;
2709
2710 if (!hrgn)
2711 {
2712 printf( "null region\n" );
2713 return;
2714 }
2715 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
2716 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
2717 GetRegionData( hrgn, size, data );
2718 printf("%ld rects:", data->rdh.nCount );
2719 for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
2720 printf( " (%ld,%ld)-(%ld,%ld)", rect->left, rect->top, rect->right, rect->bottom );
2721 printf("\n");
2722 HeapFree( GetProcessHeap(), 0, data );
2723 }
2724
2725 static void check_update_rgn( HWND hwnd, HRGN hrgn )
2726 {
2727 INT ret;
2728 RECT r1, r2;
2729 HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
2730 HRGN update = CreateRectRgn( 0, 0, 0, 0 );
2731
2732 ret = GetUpdateRgn( hwnd, update, FALSE );
2733 ok( ret != ERROR, "GetUpdateRgn failed\n" );
2734 if (ret == NULLREGION)
2735 {
2736 ok( !hrgn, "Update region shouldn't be empty\n" );
2737 }
2738 else
2739 {
2740 if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
2741 {
2742 ok( 0, "Regions are different\n" );
2743 if (winetest_debug > 0)
2744 {
2745 printf( "Update region: " );
2746 dump_region( update );
2747 printf( "Wanted region: " );
2748 dump_region( hrgn );
2749 }
2750 }
2751 }
2752 GetRgnBox( update, &r1 );
2753 GetUpdateRect( hwnd, &r2, FALSE );
2754 ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
2755 "Rectangles are different: %ld,%ld-%ld,%ld / %ld,%ld-%ld,%ld\n",
2756 r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
2757
2758 DeleteObject( tmp );
2759 DeleteObject( update );
2760 }
2761
2762 static const struct message WmInvalidateRgn[] = {
2763 { WM_NCPAINT, sent },
2764 { WM_GETTEXT, sent|defwinproc|optional },
2765 { 0 }
2766 };
2767
2768 static const struct message WmInvalidateFull[] = {
2769 { WM_NCPAINT, sent|wparam, 1 },
2770 { WM_GETTEXT, sent|defwinproc|optional },
2771 { 0 }
2772 };
2773
2774 static const struct message WmInvalidateErase[] = {
2775 { WM_NCPAINT, sent|wparam, 1 },
2776 { WM_GETTEXT, sent|defwinproc|optional },
2777 { WM_ERASEBKGND, sent },
2778 { 0 }
2779 };
2780
2781 static const struct message WmInvalidatePaint[] = {
2782 { WM_PAINT, sent },
2783 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
2784 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
2785 { 0 }
2786 };
2787
2788 static const struct message WmInvalidateErasePaint[] = {
2789 { WM_PAINT, sent },
2790 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
2791 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
2792 { WM_ERASEBKGND, sent|beginpaint },
2793 { 0 }
2794 };
2795
2796 static const struct message WmErase[] = {
2797 { WM_ERASEBKGND, sent },
2798 { 0 }
2799 };
2800
2801 static const struct message WmPaint[] = {
2802 { WM_PAINT, sent },
2803 { 0 }
2804 };
2805
2806 static void test_paint_messages(void)
2807 {
2808 RECT rect;
2809 MSG msg;
2810 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
2811 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
2812 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
2813 100, 100, 200, 200, 0, 0, 0, NULL);
2814 ok (hwnd != 0, "Failed to create overlapped window\n");
2815
2816 ShowWindow( hwnd, SW_SHOW );
2817 UpdateWindow( hwnd );
2818 check_update_rgn( hwnd, 0 );
2819 SetRectRgn( hrgn, 10, 10, 20, 20 );
2820 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
2821 check_update_rgn( hwnd, hrgn );
2822 SetRectRgn( hrgn2, 20, 20, 30, 30 );
2823 RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
2824 CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
2825 check_update_rgn( hwnd, hrgn );
2826 /* validate everything */
2827 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
2828 check_update_rgn( hwnd, 0 );
2829 /* now with frame */
2830 SetRectRgn( hrgn, -5, -5, 20, 20 );
2831
2832 flush_sequence();
2833 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
2834 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
2835
2836 SetRectRgn( hrgn, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
2837 check_update_rgn( hwnd, hrgn );
2838
2839 flush_sequence();
2840 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
2841 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
2842
2843 flush_sequence();
2844 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
2845 ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
2846
2847 GetClientRect( hwnd, &rect );
2848 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
2849 check_update_rgn( hwnd, hrgn );
2850
2851 flush_sequence();
2852 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
2853 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
2854
2855 flush_sequence();
2856 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
2857 ok_sequence( WmInvalidatePaint, "InvalidatePaint", TRUE );
2858 check_update_rgn( hwnd, 0 );
2859
2860 flush_sequence();
2861 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
2862 ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
2863 check_update_rgn( hwnd, 0 );
2864
2865 flush_sequence();
2866 SetRectRgn( hrgn, 0, 0, 100, 100 );
2867 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
2868 SetRectRgn( hrgn, 0, 0, 50, 100 );
2869 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
2870 SetRectRgn( hrgn, 50, 0, 100, 100 );
2871 check_update_rgn( hwnd, hrgn );
2872 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
2873 ok_sequence( WmEmptySeq, "EmptySeq", FALSE ); /* must not generate messages, everything is valid */
2874 check_update_rgn( hwnd, 0 );
2875
2876 flush_sequence();
2877 SetRectRgn( hrgn, 0, 0, 100, 100 );
2878 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
2879 SetRectRgn( hrgn, 0, 0, 100, 50 );
2880 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
2881 ok_sequence( WmErase, "Erase", FALSE );
2882 SetRectRgn( hrgn, 0, 50, 100, 100 );
2883 check_update_rgn( hwnd, hrgn );
2884
2885 flush_sequence();
2886 SetRectRgn( hrgn, 0, 0, 100, 100 );
2887 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
2888 SetRectRgn( hrgn, 0, 0, 50, 50 );
2889 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
2890 ok_sequence( WmPaint, "Paint", FALSE );
2891
2892 flush_sequence();
2893 SetRectRgn( hrgn, -4, -4, -2, -2 );
2894 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
2895 SetRectRgn( hrgn, -4, -4, -3, -3 );
2896 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
2897 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
2898
2899 flush_sequence();
2900 SetRectRgn( hrgn, -4, -4, -2, -2 );
2901 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
2902 SetRectRgn( hrgn, -4, -4, -3, -3 );
2903 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
2904 SetRectRgn( hrgn, 0, 0, 1, 1 );
2905 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
2906 ok_sequence( WmPaint, "Paint", TRUE );
2907
2908 flush_sequence();
2909 SetRectRgn( hrgn, -4, -4, -1, -1 );
2910 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
2911 RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
2912 /* make sure no WM_PAINT was generated */
2913 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
2914 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
2915
2916 flush_sequence();
2917 SetRectRgn( hrgn, -4, -4, -1, -1 );
2918 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
2919 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
2920 {
2921 if (msg.hwnd == hwnd && msg.message == WM_PAINT)
2922 {
2923 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
2924 INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
2925 ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
2926 ret = GetUpdateRect( hwnd, &rect, FALSE );
2927 ok( ret, "Invalid GetUpdateRect result %d\n", ret );
2928 /* this will send WM_NCPAINT and validate the non client area */
2929 ret = GetUpdateRect( hwnd, &rect, TRUE );
2930 ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
2931 }
2932 else DispatchMessage( &msg );
2933 }
2934 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
2935
2936 DeleteObject( hrgn );
2937 DeleteObject( hrgn2 );
2938 DestroyWindow( hwnd );
2939 }
2940
2941 struct wnd_event
2942 {
2943 HWND hwnd;
2944 HANDLE event;
2945 };
2946
2947 static DWORD WINAPI thread_proc(void *param)
2948 {
2949 MSG msg;
2950 struct wnd_event *wnd_event = (struct wnd_event *)param;
2951
2952 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
2953 100, 100, 200, 200, 0, 0, 0, NULL);
2954 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
2955
2956 SetEvent(wnd_event->event);
2957
2958 while (GetMessage(&msg, 0, 0, 0))
2959 {
2960 TranslateMessage(&msg);
2961 DispatchMessage(&msg);
2962 }
2963
2964 return 0;
2965 }
2966
2967 static void test_interthread_messages(void)
2968 {
2969 HANDLE hThread;
2970 DWORD tid;
2971 WNDPROC proc;
2972 MSG msg;
2973 char buf[256];
2974 int len, expected_len;
2975 struct wnd_event wnd_event;
2976
2977 wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
2978 if (!wnd_event.event)
2979 {
2980 trace("skipping interthread message test under win9x\n");
2981 return;
2982 }
2983
2984 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
2985 ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
2986
2987 ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
2988
2989 CloseHandle(wnd_event.event);
2990
2991 SetLastError(0xdeadbeef);
2992 ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
2993 ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error code %ld\n", GetLastError());
2994
2995 proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
2996 ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %ld\n", GetLastError());
2997
2998 expected_len = lstrlenA("window caption text");
2999 memset(buf, 0, sizeof(buf));
3000 SetLastError(0xdeadbeef);
3001 len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
3002 ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %ld, len %d, expected len %d\n", GetLastError(), len, expected_len);
3003 ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
3004
3005 msg.hwnd = wnd_event.hwnd;
3006 msg.message = WM_GETTEXT;
3007 msg.wParam = sizeof(buf);
3008 msg.lParam = (LPARAM)buf;
3009 memset(buf, 0, sizeof(buf));
3010 SetLastError(0xdeadbeef);
3011 len = DispatchMessageA(&msg);
3012 ok(!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3013 "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %ld\n", len, GetLastError());
3014
3015 /* the following test causes an exception in user.exe under win9x */
3016 msg.hwnd = wnd_event.hwnd;
3017 msg.message = WM_TIMER;
3018 msg.wParam = 0;
3019 msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
3020 SetLastError(0xdeadbeef);
3021 len = DispatchMessageA(&msg);
3022 ok(!len && GetLastError() == 0xdeadbeef,
3023 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %ld\n", len, GetLastError());
3024
3025 ok(PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0), "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
3026
3027 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
3028 CloseHandle(hThread);
3029 }
3030
3031
3032 static const struct message WmVkN[] = {
3033 { WM_KEYDOWN, wparam|lparam, VK_N, 1 },
3034 { WM_KEYDOWN, sent|wparam|lparam, VK_N, 1 },
3035 { WM_CHAR, wparam|lparam, 'n', 1 },
3036 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
3037 { WM_KEYUP, wparam|lparam, VK_N, 0xc0000001 },
3038 { WM_KEYUP, sent|wparam|lparam, VK_N, 0xc0000001 },
3039 { 0 }
3040 };
3041 static const struct message WmShiftVkN[] = {
3042 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
3043 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
3044 { WM_KEYDOWN, wparam|lparam, VK_N, 1 },
3045 { WM_KEYDOWN, sent|wparam|lparam, VK_N, 1 },
3046 { WM_CHAR, wparam|lparam, 'N', 1 },
3047 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
3048 { WM_KEYUP, wparam|lparam, VK_N, 0xc0000001 },
3049 { WM_KEYUP, sent|wparam|lparam, VK_N, 0xc0000001 },
3050 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
3051 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
3052 { 0 }
3053 };
3054 static const struct message WmCtrlVkN[] = {
3055 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
3056 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
3057 { WM_KEYDOWN, wparam|lparam, VK_N, 1 },
3058 { WM_KEYDOWN, sent|wparam|lparam, VK_N, 1 },
3059 { WM_CHAR, wparam|lparam, 0x000e, 1 },
3060 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
3061 { WM_KEYUP, wparam|lparam, VK_N, 0xc0000001 },
3062 { WM_KEYUP, sent|wparam|lparam, VK_N, 0xc0000001 },
3063 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
3064 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
3065 { 0 }
3066 };
3067 static const struct message WmCtrlVkN_2[] = {
3068 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
3069 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
3070 { WM_KEYDOWN, wparam|lparam, VK_N, 1 },
3071 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
3072 { WM_KEYUP, wparam|lparam, VK_N, 0xc0000001 },
3073 { WM_KEYUP, sent|wparam|lparam, VK_N, 0xc0000001 },
3074 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
3075 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
3076 { 0 }
3077 };
3078 static const struct message WmAltVkN[] = {
3079 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3080 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3081 { WM_SYSKEYDOWN, wparam|lparam, VK_N, 0x20000001 },
3082 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_N, 0x20000001 },
3083 { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
3084 { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
3085 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
3086 { HCBT_SYSCOMMAND, hook },
3087 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
3088 { WM_SETCURSOR, sent|defwinproc },
3089 { WM_INITMENU, sent|defwinproc },
3090 { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
3091 { WM_CAPTURECHANGED, sent|defwinproc },
3092 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
3093 { WM_EXITMENULOOP, sent|defwinproc },
3094 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
3095 { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
3096 { WM_SYSKEYUP, wparam|lparam, VK_N, 0xe0000001 },
3097 { WM_SYSKEYUP, sent|wparam|lparam, VK_N, 0xe0000001 },
3098 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3099 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3100 { 0 }
3101 };
3102 static const struct message WmAltVkN_2[] = {
3103 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3104 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3105 { WM_SYSKEYDOWN, wparam|lparam, VK_N, 0x20000001 },
3106 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
3107 { WM_SYSKEYUP, wparam|lparam, VK_N, 0xe0000001 },
3108 { WM_SYSKEYUP, sent|wparam|lparam, VK_N, 0xe0000001 },
3109 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3110 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3111 { 0 }
3112 };
3113 static const struct message WmCtrlAltVkN[] = {
3114 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
3115 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
3116 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
3117 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
3118 { WM_KEYDOWN, wparam|lparam, VK_N, 0x20000001 },
3119 { WM_KEYDOWN, sent|wparam|lparam, VK_N, 0x20000001 },
3120 { WM_KEYUP, wparam|lparam, VK_N, 0xe0000001 },
3121 { WM_KEYUP, sent|wparam|lparam, VK_N, 0xe0000001 },
3122 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
3123 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
3124 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
3125 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
3126 { 0 }
3127 };
3128
3129 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
3130 {
3131 MSG msg;
3132
3133 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
3134 {
3135 struct message log_msg;
3136
3137 trace("accel: %p, %04x, %08x, %08lx\n", msg.hwnd, msg.message, msg.wParam, msg.lParam);
3138
3139 log_msg.message = msg.message;
3140 log_msg.flags = wparam|lparam;
3141 log_msg.wParam = msg.wParam;
3142 log_msg.lParam = msg.lParam;
3143 add_message(&log_msg);
3144
3145 if (!TranslateAccelerator(hwnd, hAccel, &msg))
3146 {
3147 TranslateMessage(&msg);
3148 DispatchMessage(&msg);
3149 }
3150 }
3151 }
3152
3153 static void test_accelerators(void)
3154 {
3155 SHORT state;
3156 HACCEL hAccel;
3157 HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
3158 100, 100, 200, 200, 0, 0, 0, NULL);
3159 assert(hwnd != 0);
3160
3161 SetFocus(hwnd);
3162 ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
3163
3164 state = GetKeyState(VK_SHIFT);
3165 ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
3166 state = GetKeyState(VK_CAPITAL);
3167 ok(state == 0, "wrong CapsLock state %04x\n", state);
3168
3169 hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
3170 assert(hAccel != 0);
3171
3172 trace("testing VK_N press/release\n");
3173 flush_sequence();
3174 keybd_event(VK_N, 0, 0, 0);
3175 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3176 pump_msg_loop(hwnd, hAccel);
3177 ok_sequence(WmVkN, "VK_N press/release", FALSE);
3178
3179 trace("testing Shift+VK_N press/release\n");
3180 flush_sequence();
3181 keybd_event(VK_SHIFT, 0, 0, 0);
3182 keybd_event(VK_N, 0, 0, 0);
3183 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3184 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
3185 pump_msg_loop(hwnd, hAccel);
3186 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
3187
3188 trace("testing Ctrl+VK_N press/release\n");
3189 flush_sequence();
3190 keybd_event(VK_CONTROL, 0, 0, 0);
3191 keybd_event(VK_N, 0, 0, 0);
3192 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3193 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
3194 pump_msg_loop(hwnd, hAccel);
3195 ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
3196
3197 trace("testing Alt+VK_N press/release\n");
3198 flush_sequence();
3199 keybd_event(VK_MENU, 0, 0, 0);
3200 keybd_event(VK_N, 0, 0, 0);
3201 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3202 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
3203 pump_msg_loop(hwnd, hAccel);
3204 ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
3205
3206 trace("testing Ctrl+Alt+VK_N press/release\n");
3207 flush_sequence();
3208 keybd_event(VK_CONTROL, 0, 0, 0);
3209 keybd_event(VK_MENU, 0, 0, 0);
3210 keybd_event(VK_N, 0, 0, 0);
3211 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3212 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
3213 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
3214 pump_msg_loop(hwnd, hAccel);
3215 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
3216
3217 ok(DestroyAcceleratorTable(hAccel), "DestroyAcceleratorTable error %ld\n", GetLastError());
3218
3219 hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
3220 assert(hAccel != 0);
3221
3222 trace("testing VK_N press/release\n");
3223 flush_sequence();
3224 keybd_event(VK_N, 0, 0, 0);
3225 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3226 pump_msg_loop(hwnd, hAccel);
3227 ok_sequence(WmVkN, "VK_N press/release", FALSE);
3228
3229 trace("testing Shift+VK_N press/release\n");
3230 flush_sequence();
3231 keybd_event(VK_SHIFT, 0, 0, 0);
3232 keybd_event(VK_N, 0, 0, 0);
3233 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3234 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
3235 pump_msg_loop(hwnd, hAccel);
3236 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
3237
3238 trace("testing Ctrl+VK_N press/release 2\n");
3239 flush_sequence();
3240 keybd_event(VK_CONTROL, 0, 0, 0);
3241 keybd_event(VK_N, 0, 0, 0);
3242 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3243 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
3244 pump_msg_loop(hwnd, hAccel);
3245 ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
3246
3247 trace("testing Alt+VK_N press/release 2\n");
3248 flush_sequence();
3249 keybd_event(VK_MENU, 0, 0, 0);
3250 keybd_event(VK_N, 0, 0, 0);
3251 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3252 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
3253 pump_msg_loop(hwnd, hAccel);
3254 ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
3255
3256 trace("testing Ctrl+Alt+VK_N press/release\n");
3257 flush_sequence();
3258 keybd_event(VK_CONTROL, 0, 0, 0);
3259 keybd_event(VK_MENU, 0, 0, 0);
3260 keybd_event(VK_N, 0, 0, 0);
3261 keybd_event(VK_N, 0, KEYEVENTF_KEYUP, 0);
3262 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
3263 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
3264 pump_msg_loop(hwnd, hAccel);
3265 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
3266
3267 ok(DestroyAcceleratorTable(hAccel), "DestroyAcceleratorTable error %ld\n", GetLastError());
3268
3269 DestroyWindow(hwnd);
3270 }
3271
3272 /************* window procedures ********************/
3273
3274 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3275 {
3276 static long defwndproc_counter = 0;
3277 static long beginpaint_counter = 0;
3278 LRESULT ret;
3279 struct message msg;
3280
3281 trace("%p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
3282
3283 switch (message)
3284 {
3285 case WM_WINDOWPOSCHANGING:
3286 case WM_WINDOWPOSCHANGED:
3287 {
3288 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
3289
3290 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
3291 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
3292 winpos->hwnd, winpos->hwndInsertAfter,
3293 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
3294
3295 /* Log only documented flags, win2k uses 0x1000 and 0x2000
3296 * in the high word for internal purposes
3297 */
3298 wParam = winpos->flags & 0xffff;
3299 break;
3300 }
3301 }
3302
3303 msg.message = message;
3304 msg.flags = sent|wparam|lparam;
3305 if (defwndproc_counter) msg.flags |= defwinproc;
3306 if (beginpaint_counter) msg.flags |= beginpaint;
3307 msg.wParam = wParam;
3308 msg.lParam = lParam;
3309 add_message(&msg);
3310
3311 if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
3312 {
3313 HWND parent = GetParent(hwnd);
3314 RECT rc;
3315 MINMAXINFO *minmax = (MINMAXINFO *)lParam;
3316
3317 GetClientRect(parent, &rc);
3318 trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
3319
3320 trace("ptReserved = (%ld,%ld)\n"
3321 "ptMaxSize = (%ld,%ld)\n"
3322 "ptMaxPosition = (%ld,%ld)\n"
3323 "ptMinTrackSize = (%ld,%ld)\n"
3324 "ptMaxTrackSize = (%ld,%ld)\n",
3325 minmax->ptReserved.x, minmax->ptReserved.y,
3326 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
3327 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
3328 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
3329 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
3330
3331 ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %ld != %ld\n",
3332 minmax->ptMaxSize.x, rc.right);
3333 ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %ld != %ld\n",
3334 minmax->ptMaxSize.y, rc.bottom);
3335 }
3336
3337 if (message == WM_PAINT)
3338 {
3339 PAINTSTRUCT ps;
3340 beginpaint_counter++;
3341 BeginPaint( hwnd, &ps );
3342 beginpaint_counter--;
3343 EndPaint( hwnd, &ps );
3344 return 0;
3345 }
3346
3347 defwndproc_counter++;
3348 ret = DefWindowProcA(hwnd, message, wParam, lParam);
3349 defwndproc_counter--;
3350
3351 return ret;
3352 }
3353
3354 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3355 {
3356 static long defwndproc_counter = 0;
3357 LRESULT ret;
3358 struct message msg;
3359
3360 trace("popup: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
3361
3362 msg.message = message;
3363 msg.flags = sent|wparam|lparam;
3364 if (defwndproc_counter) msg.flags |= defwinproc;
3365 msg.wParam = wParam;
3366 msg.lParam = lParam;
3367 add_message(&msg);
3368
3369 if (message == WM_CREATE)
3370 {
3371 DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
3372 SetWindowLongA(hwnd, GWL_STYLE, style);
3373 }
3374
3375 defwndproc_counter++;
3376 ret = DefWindowProcA(hwnd, message, wParam, lParam);
3377 defwndproc_counter--;
3378
3379 return ret;
3380 }
3381
3382 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3383 {
3384 static long defwndproc_counter = 0;
3385 LRESULT ret;
3386 struct message msg;
3387
3388 trace("parent: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
3389
3390 if (message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
3391 message == WM_SETFOCUS || message == WM_KILLFOCUS ||
3392 message == WM_ENABLE || message == WM_ENTERIDLE ||
3393 message == WM_IME_SETCONTEXT)
3394 {
3395 msg.message = message;
3396 msg.flags = sent|parent|wparam|lparam;
3397 if (defwndproc_counter) msg.flags |= defwinproc;
3398 msg.wParam = wParam;
3399 msg.lParam = lParam;
3400 add_message(&msg);
3401 }
3402
3403 defwndproc_counter++;
3404 ret = DefWindowProcA(hwnd, message, wParam, lParam);
3405 defwndproc_counter--;
3406
3407 return ret;
3408 }
3409
3410 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3411 {
3412 static long defwndproc_counter = 0;
3413 LRESULT ret;
3414 struct message msg;
3415
3416 trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
3417
3418 DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
3419 ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
3420 if (after_end_dialog)
3421 ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
3422 else
3423 ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
3424
3425 msg.message = message;
3426 msg.flags = sent|wparam|lparam;
3427 if (defwndproc_counter) msg.flags |= defwinproc;
3428 msg.wParam = wParam;
3429 msg.lParam = lParam;
3430 add_message(&msg);
3431
3432 defwndproc_counter++;
3433 ret = DefDlgProcA(hwnd, message, wParam, lParam);
3434 defwndproc_counter--;
3435
3436 return ret;
3437 }
3438
3439 static BOOL RegisterWindowClasses(void)
3440 {
3441 WNDCLASSA cls;
3442
3443 cls.style = 0;
3444 cls.lpfnWndProc = MsgCheckProcA;
3445 cls.cbClsExtra = 0;
3446 cls.cbWndExtra = 0;
3447 cls.hInstance = GetModuleHandleA(0);
3448 cls.hIcon = 0;
3449 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
3450 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
3451 cls.lpszMenuName = NULL;
3452 cls.lpszClassName = "TestWindowClass";
3453 if(!RegisterClassA(&cls)) return FALSE;
3454
3455 cls.lpfnWndProc = PopupMsgCheckProcA;
3456 cls.lpszClassName = "TestPopupClass";
3457 if(!RegisterClassA(&cls)) return FALSE;
3458
3459 cls.lpfnWndProc = ParentMsgCheckProcA;
3460 cls.lpszClassName = "TestParentClass";
3461 if(!RegisterClassA(&cls)) return FALSE;
3462
3463 cls.lpfnWndProc = DefWindowProcA;
3464 cls.lpszClassName = "SimpleWindowClass";
3465 if(!RegisterClassA(&cls)) return FALSE;
3466
3467 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
3468 cls.lpfnWndProc = TestDlgProcA;
3469 cls.lpszClassName = "TestDialogClass";
3470 if(!RegisterClassA(&cls)) return FALSE;
3471
3472 return TRUE;
3473 }
3474
3475 static HHOOK hCBT_hook;
3476
3477 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
3478 {
3479 char buf[256];
3480
3481 trace("CBT: %d, %08x, %08lx\n", nCode, wParam, lParam);
3482
3483 if (nCode == HCBT_SYSCOMMAND)
3484 {
3485 struct message msg;
3486
3487 msg.message = nCode;
3488 msg.flags = hook;
3489 msg.wParam = wParam;
3490 msg.lParam = lParam;
3491 add_message(&msg);
3492
3493 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
3494 }
3495
3496 /* Log also SetFocus(0) calls */
3497 if (!wParam) wParam = lParam;
3498
3499 if (GetClassNameA((HWND)wParam, buf, sizeof(buf)))
3500 {
3501 if (!strcmp(buf, "TestWindowClass") ||
3502 !strcmp(buf, "TestParentClass") ||
3503 !strcmp(buf, "TestPopupClass") ||
3504 !strcmp(buf, "SimpleWindowClass") ||
3505 !strcmp(buf, "TestDialogClass") ||
3506 !strcmp(buf, "MDI_frame_class") ||
3507 !strcmp(buf, "MDI_client_class") ||
3508 !strcmp(buf, "MDI_child_class") ||
3509 !strcmp(buf, "my_button_class") ||
3510 !strcmp(buf, "#32770"))
3511 {
3512 struct message msg;
3513
3514 msg.message = nCode;
3515 msg.flags = hook;
3516 msg.wParam = wParam;
3517 msg.lParam = lParam;
3518 add_message(&msg);
3519 }
3520 }
3521 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
3522 }
3523
3524 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
3525 static const WCHAR wszAnsi[] = {'U',0};
3526
3527 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3528 {
3529 switch (uMsg)
3530 {
3531 case CB_FINDSTRINGEXACT:
3532 trace("String: %p\n", (LPCWSTR)lParam);
3533 if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
3534 return 1;
3535 if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
3536 return 0;
3537 return -1;
3538 }
3539 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
3540 }
3541
3542 static void test_message_conversion(void)
3543 {
3544 static const WCHAR wszMsgConversionClass[] =
3545 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
3546 WNDCLASSW cls;
3547 LRESULT lRes;
3548 HWND hwnd;
3549 WNDPROC wndproc;
3550
3551 cls.style = 0;
3552 cls.lpfnWndProc = MsgConversionProcW;
3553 cls.cbClsExtra = 0;
3554 cls.cbWndExtra = 0;
3555 cls.hInstance = GetModuleHandleW(NULL);
3556 cls.hIcon = NULL;
3557 cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
3558 cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
3559 cls.lpszMenuName = NULL;
3560 cls.lpszClassName = wszMsgConversionClass;
3561 /* this call will fail on Win9x, but that doesn't matter as this test is
3562 * meaningless on those platforms */
3563 if(!RegisterClassW(&cls)) return;
3564
3565 hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
3566 100, 100, 200, 200, 0, 0, 0, NULL);
3567 ok(hwnd != NULL, "Window creation failed\n");
3568
3569 /* {W, A} -> A */
3570
3571 wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
3572 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3573 ok(lRes == 0, "String should have been converted\n");
3574 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3575 ok(lRes == 1, "String shouldn't have been converted\n");
3576
3577 /* {W, A} -> W */
3578
3579 wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
3580 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3581 ok(lRes == 1, "String shouldn't have been converted\n");
3582 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3583 ok(lRes == 1, "String shouldn't have been converted\n");
3584
3585 /* Synchronous messages */
3586
3587 lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3588 ok(lRes == 0, "String should have been converted\n");
3589 lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3590 ok(lRes == 1, "String shouldn't have been converted\n");
3591
3592 /* Asynchronous messages */
3593
3594 SetLastError(0);
3595 lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3596 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3597 "PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3598 SetLastError(0);
3599 lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3600 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3601 "PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3602 SetLastError(0);
3603 lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3604 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3605 "PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3606 SetLastError(0);
3607 lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3608 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3609 "PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3610 SetLastError(0);
3611 lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3612 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3613 "SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3614 SetLastError(0);
3615 lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
3616 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3617 "SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3618 SetLastError(0);
3619 lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
3620 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3621 "SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3622 SetLastError(0);
3623 lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
3624 ok(lRes == 0 && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
3625 "SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
3626 }
3627
3628 START_TEST(msg)
3629 {
3630 if (!RegisterWindowClasses()) assert(0);
3631
3632 hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
3633 assert(hCBT_hook);
3634
3635 test_messages();
3636 test_mdi_messages();
3637 test_button_messages();
3638 test_paint_messages();
3639 test_interthread_messages();
3640 test_message_conversion();
3641 test_accelerators();
3642
3643 UnhookWindowsHookEx(hCBT_hook);
3644 }
Maarten's multimedia branch