projects / wine / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
secur32: Update ntlm_auth version detection to detect new samba4 version numbers.
[wine] / dlls / user / tests / msg.c
1 /*
2  * Unit tests for window message handling
3  *
4  * Copyright 1999 Ove Kaaven
5  * Copyright 2003 Dimitrie O. Paun
6  * Copyright 2004, 2005 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 0x0501 /* For WM_CHANGEUISTATE,QS_RAWINPUT */
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winuser.h"
33 #include "winnls.h"
34
35 #include "wine/test.h"
36
37 #define MDI_FIRST_CHILD_ID 2004
38
39 /* undocumented SWP flags - from SDK 3.1 */
40 #define SWP_NOCLIENTSIZE        0x0800
41 #define SWP_NOCLIENTMOVE        0x1000
42
43 #define WND_PARENT_ID           1
44 #define WND_POPUP_ID            2
45 #define WND_CHILD_ID            3
46
47 static BOOL test_DestroyWindow_flag;
48 static HWINEVENTHOOK hEvent_hook;
49
50 static HWND (WINAPI *pGetAncestor)(HWND,UINT);
51
52 /*
53 FIXME: add tests for these
54 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
55  WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
56  WS_THICKFRAME: thick border
57  WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
58  WS_BORDER (default for overlapped windows): single black border
59  none (default for child (and popup?) windows): no border
60 */
61
62 typedef enum {
63     sent=0x1,
64     posted=0x2,
65     parent=0x4,
66     wparam=0x8,
67     lparam=0x10,
68     defwinproc=0x20,
69     beginpaint=0x40,
70     optional=0x80,
71     hook=0x100,
72     winevent_hook=0x200
73 } msg_flags_t;
74
75 struct message {
76     UINT message;          /* the WM_* code */
77     msg_flags_t flags;     /* message props */
78     WPARAM wParam;         /* expected value of wParam */
79     LPARAM lParam;         /* expected value of lParam */
80 };
81
82 /* Empty message sequence */
83 static const struct message WmEmptySeq[] =
84 {
85     { 0 }
86 };
87 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
88 static const struct message WmCreateOverlappedSeq[] = {
89     { HCBT_CREATEWND, hook },
90     { WM_GETMINMAXINFO, sent },
91     { WM_NCCREATE, sent },
92     { WM_NCCALCSIZE, sent|wparam, 0 },
93     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
94     { WM_CREATE, sent },
95     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
96     { 0 }
97 };
98 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
99  * for a not visible overlapped window.
100  */
101 static const struct message WmSWP_ShowOverlappedSeq[] = {
102     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
103     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
104     { WM_NCPAINT, sent|wparam|optional, 1 },
105     { WM_GETTEXT, sent|defwinproc|optional },
106     { WM_ERASEBKGND, sent|optional },
107     { HCBT_ACTIVATE, hook },
108     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
109     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
110     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
111     { WM_ACTIVATEAPP, sent|wparam, 1 },
112     { WM_NCACTIVATE, sent|wparam, 1 },
113     { WM_GETTEXT, sent|defwinproc|optional },
114     { WM_ACTIVATE, sent|wparam, 1 },
115     { HCBT_SETFOCUS, hook },
116     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
117     { WM_IME_NOTIFY, sent|defwinproc|optional },
118     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
119     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
120     { WM_NCPAINT, sent|wparam|optional, 1 },
121     { WM_GETTEXT, sent|defwinproc|optional },
122     { WM_ERASEBKGND, sent|optional },
123     /* Win9x adds SWP_NOZORDER below */
124     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
125     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
126     { WM_NCPAINT, sent|wparam|optional, 1 },
127     { WM_ERASEBKGND, sent|optional },
128     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
129     { 0 }
130 };
131 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
132  * for a visible overlapped window.
133  */
134 static const struct message WmSWP_HideOverlappedSeq[] = {
135     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
136     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
137     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
138     { 0 }
139 };
140
141 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
142  * for a visible overlapped window.
143  */
144 static const struct message WmSWP_ResizeSeq[] = {
145     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE },
146     { WM_GETMINMAXINFO, sent|defwinproc },
147     { WM_NCCALCSIZE, sent|wparam, TRUE },
148     { WM_NCPAINT, sent|optional },
149     { WM_GETTEXT, sent|defwinproc|optional },
150     { WM_ERASEBKGND, sent|optional },
151     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
152     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
153     { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
154     { WM_NCPAINT, sent|optional },
155     { WM_GETTEXT, sent|defwinproc|optional },
156     { WM_ERASEBKGND, sent|optional },
157     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
158     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
159     { 0 }
160 };
161
162 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
163  * for a visible popup window.
164  */
165 static const struct message WmSWP_ResizePopupSeq[] = {
166     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE },
167     { WM_NCCALCSIZE, sent|wparam, TRUE },
168     { WM_NCPAINT, sent|optional },
169     { WM_GETTEXT, sent|defwinproc|optional },
170     { WM_ERASEBKGND, sent|optional },
171     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
172     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
173     { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
174     { WM_NCPAINT, sent|optional },
175     { WM_GETTEXT, sent|defwinproc|optional },
176     { WM_ERASEBKGND, sent|optional },
177     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
178     { 0 }
179 };
180
181 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
182  * for a visible overlapped window.
183  */
184 static const struct message WmSWP_MoveSeq[] = {
185     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE },
186     { WM_NCPAINT, sent|optional },
187     { WM_GETTEXT, sent|defwinproc|optional },
188     { WM_ERASEBKGND, sent|optional },
189     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCLIENTSIZE },
190     { WM_MOVE, sent|defwinproc|wparam, 0 },
191     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
192     { 0 }
193 };
194
195 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
196                 SWP_NOZORDER|SWP_FRAMECHANGED)
197  * for a visible overlapped window with WS_CLIPCHILDREN style set.
198  */
199 static const struct message WmSWP_FrameChanged_clip[] = {
200     { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED },
201     { WM_NCCALCSIZE, sent|wparam|parent, 1 },
202     { WM_NCPAINT, sent|parent }, /* wparam != 1 */
203     { WM_GETTEXT, sent|parent|defwinproc|optional },
204     { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
205     { WM_NCPAINT, sent }, /* wparam != 1 */
206     { WM_ERASEBKGND, sent },
207     { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
208     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
209     { WM_PAINT, sent },
210     { 0 }
211 };
212 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
213                 SWP_NOZORDER|SWP_FRAMECHANGED)
214  * for a visible overlapped window.
215  */
216 static const struct message WmSWP_FrameChangedDeferErase[] = {
217     { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED },
218     { WM_NCCALCSIZE, sent|wparam|parent, 1 },
219     { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
220     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
221     { WM_PAINT, sent|parent },
222     { WM_NCPAINT, sent|beginpaint|parent }, /* wparam != 1 */
223     { WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
224     { WM_PAINT, sent },
225     { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
226     { WM_ERASEBKGND, sent|beginpaint },
227     { 0 }
228 };
229
230 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
231                 SWP_NOZORDER|SWP_FRAMECHANGED)
232  * for a visible overlapped window without WS_CLIPCHILDREN style set.
233  */
234 static const struct message WmSWP_FrameChanged_noclip[] = {
235     { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED },
236     { WM_NCCALCSIZE, sent|wparam|parent, 1 },
237     { WM_NCPAINT, sent|parent }, /* wparam != 1 */
238     { WM_GETTEXT, sent|parent|defwinproc|optional },
239     { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
240     { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
241     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
242     { WM_PAINT, sent },
243     { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
244     { WM_ERASEBKGND, sent|beginpaint },
245     { 0 }
246 };
247
248 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
249 static const struct message WmShowOverlappedSeq[] = {
250     { WM_SHOWWINDOW, sent|wparam, 1 },
251     { WM_NCPAINT, sent|wparam|optional, 1 },
252     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
253     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
254     { WM_NCPAINT, sent|wparam|optional, 1 },
255     { WM_GETTEXT, sent|defwinproc|optional },
256     { WM_ERASEBKGND, sent|optional },
257     { HCBT_ACTIVATE, hook },
258     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
259     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
260     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
261     { WM_ACTIVATEAPP, sent|wparam, 1 },
262     { WM_NCACTIVATE, sent|wparam, 1 },
263     { WM_GETTEXT, sent|defwinproc|optional },
264     { WM_ACTIVATE, sent|wparam, 1 },
265     { HCBT_SETFOCUS, hook },
266     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
267     { WM_IME_NOTIFY, sent|defwinproc|optional },
268     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
269     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
270     { WM_NCPAINT, sent|wparam|optional, 1 },
271     { WM_GETTEXT, sent|defwinproc|optional },
272     { WM_ERASEBKGND, sent|optional },
273     /* Win9x adds SWP_NOZORDER below */
274     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
275     { WM_NCCALCSIZE, sent|optional },
276     { WM_NCPAINT, sent|optional },
277     { WM_ERASEBKGND, sent|optional },
278 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
279        * messages. Does that mean that CreateWindow doesn't set initial
280        * window dimensions for overlapped windows?
281        */
282     { WM_SIZE, sent },
283     { WM_MOVE, sent },
284 #endif
285     { 0 }
286 };
287 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
288 static const struct message WmShowMaxOverlappedSeq[] = {
289     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
290     { WM_GETMINMAXINFO, sent },
291     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
292     { WM_GETMINMAXINFO, sent|defwinproc },
293     { WM_NCCALCSIZE, sent|wparam, TRUE },
294     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
295     { HCBT_ACTIVATE, hook },
296     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
297     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
298     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
299     { WM_ACTIVATEAPP, sent|wparam, 1 },
300     { WM_NCACTIVATE, sent|wparam, 1 },
301     { WM_GETTEXT, sent|defwinproc|optional },
302     { WM_ACTIVATE, sent|wparam, 1 },
303     { HCBT_SETFOCUS, hook },
304     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
305     { WM_IME_NOTIFY, sent|defwinproc|optional },
306     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
307     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
308     { WM_NCPAINT, sent|wparam|optional, 1 },
309     { WM_GETTEXT, sent|defwinproc|optional },
310     { WM_ERASEBKGND, sent|optional },
311     /* Win9x adds SWP_NOZORDER below */
312     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
313     { WM_MOVE, sent|defwinproc },
314     { WM_SIZE, sent|defwinproc },
315     { WM_NCCALCSIZE, sent|optional },
316     { WM_NCPAINT, sent|optional },
317     { WM_ERASEBKGND, sent|optional },
318     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
319     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
320     { 0 }
321 };
322 /* ShowWindow(SW_HIDE) for a visible overlapped window */
323 static const struct message WmHideOverlappedSeq[] = {
324     { WM_SHOWWINDOW, sent|wparam, 0 },
325     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
326     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
327     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
328     { WM_SIZE, sent|optional }, /* XP doesn't send it */
329     { WM_MOVE, sent|optional }, /* XP doesn't send it */
330     { WM_NCACTIVATE, sent|wparam, 0 },
331     { WM_ACTIVATE, sent|wparam, 0 },
332     { WM_ACTIVATEAPP, sent|wparam, 0 },
333     { WM_KILLFOCUS, sent|wparam, 0 },
334     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
335     { WM_IME_NOTIFY, sent|optional|defwinproc },
336     { 0 }
337 };
338 /* DestroyWindow for a visible overlapped window */
339 static const struct message WmDestroyOverlappedSeq[] = {
340     { HCBT_DESTROYWND, hook },
341     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
342     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
343     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
344     { WM_NCACTIVATE, sent|wparam, 0 },
345     { WM_ACTIVATE, sent|wparam, 0 },
346     { WM_ACTIVATEAPP, sent|wparam, 0 },
347     { WM_KILLFOCUS, sent|wparam, 0 },
348     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
349     { WM_IME_NOTIFY, sent|optional|defwinproc },
350     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
351     { WM_DESTROY, sent },
352     { WM_NCDESTROY, sent },
353     { 0 }
354 };
355 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
356 static const struct message WmCreateMaxPopupSeq[] = {
357     { HCBT_CREATEWND, hook },
358     { WM_NCCREATE, sent },
359     { WM_NCCALCSIZE, sent|wparam, 0 },
360     { WM_CREATE, sent },
361     { WM_SIZE, sent },
362     { WM_MOVE, sent },
363     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
364     { WM_GETMINMAXINFO, sent },
365     { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000*/ },
366     { WM_NCCALCSIZE, sent|wparam, TRUE },
367     { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOZORDER|0x8000*/ },
368     { WM_MOVE, sent|defwinproc },
369     { WM_SIZE, sent|defwinproc },
370     { WM_SHOWWINDOW, sent|wparam, 1 },
371     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
372     { HCBT_ACTIVATE, hook },
373     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
374     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
375     { WM_ACTIVATEAPP, sent|wparam, 1 },
376     { WM_NCACTIVATE, sent|wparam, 1 },
377     { WM_ACTIVATE, sent|wparam, 1 },
378     { HCBT_SETFOCUS, hook },
379     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
380     { WM_SYNCPAINT, sent|wparam|optional, 4 },
381     { WM_NCPAINT, sent|wparam|optional, 1 },
382     { WM_ERASEBKGND, sent|optional },
383     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOSIZE },
384     { 0 }
385 };
386 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
387 static const struct message WmCreateInvisibleMaxPopupSeq[] = {
388     { HCBT_CREATEWND, hook },
389     { WM_NCCREATE, sent },
390     { WM_NCCALCSIZE, sent|wparam, 0 },
391     { WM_CREATE, sent },
392     { WM_SIZE, sent },
393     { WM_MOVE, sent },
394     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
395     { WM_GETMINMAXINFO, sent },
396     { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000*/ },
397     { WM_NCCALCSIZE, sent|wparam, TRUE },
398     { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOZORDER|0x8000*/ },
399     { WM_MOVE, sent|defwinproc },
400     { WM_SIZE, sent|defwinproc },
401     { 0 }
402 };
403 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
404 static const struct message WmShowMaxPopupResizedSeq[] = {
405     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
406     { WM_GETMINMAXINFO, sent },
407     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
408     { WM_NCCALCSIZE, sent|wparam, TRUE },
409     { HCBT_ACTIVATE, hook },
410     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
411     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
412     { WM_ACTIVATEAPP, sent|wparam, 1 },
413     { WM_NCACTIVATE, sent|wparam, 1 },
414     { WM_ACTIVATE, sent|wparam, 1 },
415     { HCBT_SETFOCUS, hook },
416     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
417     { WM_NCPAINT, sent|wparam|optional, 1 },
418     { WM_ERASEBKGND, sent|optional },
419     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOZORDER },
420     /* WinNT4.0 sends WM_MOVE */
421     { WM_MOVE, sent|defwinproc|optional },
422     { WM_SIZE, sent|defwinproc },
423     { 0 }
424 };
425 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
426 static const struct message WmShowMaxPopupSeq[] = {
427     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
428     { WM_GETMINMAXINFO, sent },
429     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
430     { WM_NCCALCSIZE, sent|wparam, TRUE },
431     { HCBT_ACTIVATE, hook },
432     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
433     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
434     { WM_ACTIVATEAPP, sent|wparam, 1 },
435     { WM_NCACTIVATE, sent|wparam, 1 },
436     { WM_ACTIVATE, sent|wparam, 1 },
437     { HCBT_SETFOCUS, hook },
438     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
439     { WM_SYNCPAINT, sent|wparam|optional, 4 },
440     { WM_NCPAINT, sent|wparam|optional, 1 },
441     { WM_ERASEBKGND, sent|optional },
442     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
443     { 0 }
444 };
445 /* CreateWindow(WS_VISIBLE) for popup window */
446 static const struct message WmCreatePopupSeq[] = {
447     { HCBT_CREATEWND, hook },
448     { WM_NCCREATE, sent },
449     { WM_NCCALCSIZE, sent|wparam, 0 },
450     { WM_CREATE, sent },
451     { WM_SIZE, sent },
452     { WM_MOVE, sent },
453     { WM_SHOWWINDOW, sent|wparam, 1 },
454     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
455     { HCBT_ACTIVATE, hook },
456     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
457     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
458     { WM_NCPAINT, sent|wparam|optional, 1 },
459     { WM_ERASEBKGND, sent|optional },
460     { WM_ACTIVATEAPP, sent|wparam, 1 },
461     { WM_NCACTIVATE, sent|wparam, 1 },
462     { WM_ACTIVATE, sent|wparam, 1 },
463     { HCBT_SETFOCUS, hook },
464     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
465     { WM_SYNCPAINT, sent|wparam|optional, 4 },
466     { WM_NCPAINT, sent|wparam|optional, 1 },
467     { WM_ERASEBKGND, sent|optional },
468     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOSIZE },
469     { 0 }
470 };
471 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
472 static const struct message WmShowVisMaxPopupSeq[] = {
473     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
474     { WM_GETMINMAXINFO, sent },
475     { WM_GETTEXT, sent|optional },
476     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
477     { WM_NCCALCSIZE, sent|wparam, TRUE },
478     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
479     { WM_NCPAINT, sent|wparam|optional, 1 },
480     { WM_ERASEBKGND, sent|optional },
481     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOZORDER|0x8000 },
482     { WM_MOVE, sent|defwinproc },
483     { WM_SIZE, sent|defwinproc },
484     { 0 }
485 };
486 /* CreateWindow (for a child popup window, not initially visible) */
487 static const struct message WmCreateChildPopupSeq[] = {
488     { HCBT_CREATEWND, hook },
489     { WM_NCCREATE, sent }, 
490     { WM_NCCALCSIZE, sent|wparam, 0 },
491     { WM_CREATE, sent },
492     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
493     { WM_SIZE, sent },
494     { WM_MOVE, sent },
495     { 0 }
496 };
497 /* CreateWindow (for a popup window, not initially visible,
498  * which sets WS_VISIBLE in WM_CREATE handler)
499  */
500 static const struct message WmCreateInvisiblePopupSeq[] = {
501     { HCBT_CREATEWND, hook },
502     { WM_NCCREATE, sent }, 
503     { WM_NCCALCSIZE, sent|wparam, 0 },
504     { WM_CREATE, sent },
505     { WM_STYLECHANGING, sent },
506     { WM_STYLECHANGED, sent },
507     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
508     { WM_SIZE, sent },
509     { WM_MOVE, sent },
510     { 0 }
511 };
512 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
513  * for a popup window with WS_VISIBLE style set
514  */
515 static const struct message WmShowVisiblePopupSeq_2[] = {
516     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
517     { 0 }
518 };
519 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
520  * for a popup window with WS_VISIBLE style set
521  */
522 static const struct message WmShowVisiblePopupSeq_3[] = {
523     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
524     { HCBT_ACTIVATE, hook },
525     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
526     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
527     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
528     { WM_NCACTIVATE, sent|wparam, 1 },
529     { WM_ACTIVATE, sent|wparam, 1 },
530     { HCBT_SETFOCUS, hook },
531     { WM_KILLFOCUS, sent|parent },
532     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
533     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
534     { WM_IME_NOTIFY, sent|defwinproc|optional },
535     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
536     { WM_SETFOCUS, sent|defwinproc },
537     { 0 }
538 };
539 /* CreateWindow (for child window, not initially visible) */
540 static const struct message WmCreateChildSeq[] = {
541     { HCBT_CREATEWND, hook },
542     { WM_NCCREATE, sent }, 
543     /* child is inserted into parent's child list after WM_NCCREATE returns */
544     { WM_NCCALCSIZE, sent|wparam, 0 },
545     { WM_CREATE, sent },
546     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
547     { WM_SIZE, sent },
548     { WM_MOVE, sent },
549     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
550     { 0 }
551 };
552 /* CreateWindow (for maximized child window, not initially visible) */
553 static const struct message WmCreateMaximizedChildSeq[] = {
554     { HCBT_CREATEWND, hook },
555     { WM_NCCREATE, sent }, 
556     { WM_NCCALCSIZE, sent|wparam, 0 },
557     { WM_CREATE, sent },
558     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
559     { WM_SIZE, sent },
560     { WM_MOVE, sent },
561     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
562     { WM_GETMINMAXINFO, sent },
563     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
564     { WM_NCCALCSIZE, sent|wparam, 1 },
565     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE|0x8000 },
566     { WM_SIZE, sent|defwinproc },
567     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
568     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
569     { 0 }
570 };
571 /* CreateWindow (for a child window, initially visible) */
572 static const struct message WmCreateVisibleChildSeq[] = {
573     { HCBT_CREATEWND, hook },
574     { WM_NCCREATE, sent }, 
575     /* child is inserted into parent's child list after WM_NCCREATE returns */
576     { WM_NCCALCSIZE, sent|wparam, 0 },
577     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
578     { WM_CREATE, sent },
579     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
580     { WM_SIZE, sent },
581     { WM_MOVE, sent },
582     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
583     { WM_SHOWWINDOW, sent|wparam, 1 },
584     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
585     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
586     { WM_ERASEBKGND, sent|parent|optional },
587     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
588     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
589     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
590     { 0 }
591 };
592 /* ShowWindow(SW_SHOW) for a not visible child window */
593 static const struct message WmShowChildSeq[] = {
594     { WM_SHOWWINDOW, sent|wparam, 1 },
595     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
596     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
597     { WM_ERASEBKGND, sent|parent|optional },
598     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
599     { 0 }
600 };
601 /* ShowWindow(SW_HIDE) for a visible child window */
602 static const struct message WmHideChildSeq[] = {
603     { WM_SHOWWINDOW, sent|wparam, 0 },
604     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
605     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
606     { WM_ERASEBKGND, sent|parent|optional },
607     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
608     { 0 }
609 };
610 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
611  * for a not visible child window
612  */
613 static const struct message WmShowChildSeq_2[] = {
614     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
615     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
616     { WM_CHILDACTIVATE, sent },
617     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
618     { 0 }
619 };
620 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
621  * for a not visible child window
622  */
623 static const struct message WmShowChildSeq_3[] = {
624     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
625     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
626     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
627     { 0 }
628 };
629 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
630  * for a visible child window with a caption
631  */
632 static const struct message WmShowChildSeq_4[] = {
633     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
634     { WM_CHILDACTIVATE, sent },
635     { 0 }
636 };
637 /* ShowWindow(SW_SHOW) for child with invisible parent */
638 static const struct message WmShowChildInvisibleParentSeq[] = {
639     { WM_SHOWWINDOW, sent|wparam, 1 },
640     { 0 }
641 };
642 /* ShowWindow(SW_HIDE) for child with invisible parent */
643 static const struct message WmHideChildInvisibleParentSeq[] = {
644     { WM_SHOWWINDOW, sent|wparam, 0 },
645     { 0 }
646 };
647 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
648 static const struct message WmShowChildInvisibleParentSeq_2[] = {
649     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
650     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
651     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
652     { 0 }
653 };
654 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
655 static const struct message WmHideChildInvisibleParentSeq_2[] = {
656     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
657     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
658     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
659     { 0 }
660 };
661 /* DestroyWindow for a visible child window */
662 static const struct message WmDestroyChildSeq[] = {
663     { HCBT_DESTROYWND, hook },
664     { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
665     { WM_SHOWWINDOW, sent|wparam, 0 },
666     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
667     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
668     { WM_ERASEBKGND, sent|parent|optional },
669     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
670     { HCBT_SETFOCUS, hook }, /* set focus to a parent */
671     { WM_KILLFOCUS, sent },
672     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
673     { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
674     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
675     { WM_SETFOCUS, sent|parent },
676     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
677     { WM_DESTROY, sent },
678     { WM_DESTROY, sent|optional }, /* some other (IME?) window */
679     { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
680     { WM_NCDESTROY, sent },
681     { 0 }
682 };
683 /* DestroyWindow for a visible child window with invisible parent */
684 static const struct message WmDestroyInvisibleChildSeq[] = {
685     { HCBT_DESTROYWND, hook },
686     { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
687     { WM_SHOWWINDOW, sent|wparam, 0 },
688     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
689     { WM_DESTROY, sent },
690     { WM_NCDESTROY, sent },
691     { 0 }
692 };
693 /* Moving the mouse in nonclient area */
694 static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
695     { WM_NCHITTEST, sent },
696     { WM_SETCURSOR, sent },
697     { WM_NCMOUSEMOVE, posted },
698     { 0 }
699 };
700 /* Moving the mouse in client area */
701 static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
702     { WM_NCHITTEST, sent },
703     { WM_SETCURSOR, sent },
704     { WM_MOUSEMOVE, posted },
705     { 0 }
706 };
707 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
708 static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
709     { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
710     { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
711     { WM_GETMINMAXINFO, sent|defwinproc },
712     { WM_ENTERSIZEMOVE, sent|defwinproc },
713     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
714     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
715     { WM_MOVE, sent|defwinproc },
716     { WM_EXITSIZEMOVE, sent|defwinproc },
717     { 0 }
718 };
719 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
720 static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
721     { WM_NCLBUTTONDOWN, sent|wparam, 0xd },
722     { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 },
723     { WM_GETMINMAXINFO, sent|defwinproc },
724     { WM_ENTERSIZEMOVE, sent|defwinproc },
725     { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */
726     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
727     { WM_GETMINMAXINFO, sent|defwinproc },
728     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
729     { WM_NCPAINT, sent|defwinproc|wparam, 1 },
730     { WM_GETTEXT, sent|defwinproc },
731     { WM_ERASEBKGND, sent|defwinproc },
732     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
733     { WM_MOVE, sent|defwinproc },
734     { WM_SIZE, sent|defwinproc },
735     { WM_EXITSIZEMOVE, sent|defwinproc },
736     { 0 }
737 };
738 /* Resizing child window with MoveWindow (32) */
739 static const struct message WmResizingChildWithMoveWindowSeq[] = {
740     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
741     { WM_NCCALCSIZE, sent|wparam, 1 },
742     { WM_ERASEBKGND, sent|optional },
743     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
744     { WM_MOVE, sent|defwinproc },
745     { WM_SIZE, sent|defwinproc },
746     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
747     { 0 }
748 };
749 /* Clicking on inactive button */
750 static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
751     { WM_NCHITTEST, sent },
752     { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN },
753     { WM_MOUSEACTIVATE, sent },
754     { WM_MOUSEACTIVATE, sent|parent|defwinproc },
755     { WM_SETCURSOR, sent },
756     { WM_SETCURSOR, sent|parent|defwinproc },
757     { WM_LBUTTONDOWN, posted },
758     { WM_KILLFOCUS, posted|parent },
759     { WM_SETFOCUS, posted },
760     { WM_CTLCOLORBTN, posted|parent },
761     { BM_SETSTATE, posted },
762     { WM_CTLCOLORBTN, posted|parent },
763     { WM_LBUTTONUP, posted },
764     { BM_SETSTATE, posted },
765     { WM_CTLCOLORBTN, posted|parent },
766     { WM_COMMAND, posted|parent },
767     { 0 }
768 };
769 /* Reparenting a button (16/32) */
770 /* The last child (button) reparented gets topmost for its new parent. */
771 static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
772     { WM_SHOWWINDOW, sent|wparam, 0 },
773     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
774     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
775     { WM_ERASEBKGND, sent|parent },
776     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
777     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOZORDER },
778     { WM_CHILDACTIVATE, sent },
779     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW|SWP_NOZORDER },
780     { WM_MOVE, sent|defwinproc },
781     { WM_SHOWWINDOW, sent|wparam, 1 },
782     { 0 }
783 };
784 /* Creation of a custom dialog (32) */
785 static const struct message WmCreateCustomDialogSeq[] = {
786     { HCBT_CREATEWND, hook },
787     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
788     { WM_GETMINMAXINFO, sent },
789     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
790     { WM_NCCREATE, sent },
791     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
792     { WM_NCCALCSIZE, sent|wparam, 0 },
793     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
794     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
795     { WM_CREATE, sent },
796     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
797     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
798     { WM_SHOWWINDOW, sent|wparam, 1 },
799     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
800     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
801     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
802     { HCBT_ACTIVATE, hook },
803     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
804
805     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
806
807     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
808     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
809
810     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
811
812     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
813     { WM_NCACTIVATE, sent|wparam, 1 },
814     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
815     { WM_GETTEXT, sent|optional|defwinproc },
816     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
817     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
818     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
819     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
820     { WM_GETTEXT, sent|optional|defwinproc },
821     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
822     { WM_ACTIVATE, sent|wparam, 1 },
823     { WM_KILLFOCUS, sent|parent },
824     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
825     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
826     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
827     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
828     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
829     { WM_IME_NOTIFY, sent|optional|defwinproc },
830     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
831     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
832     { WM_SETFOCUS, sent },
833     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
834     { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
835     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
836     { WM_NCPAINT, sent|wparam, 1 },
837     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
838     { WM_GETTEXT, sent|optional|defwinproc },
839     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
840     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
841     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
842     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
843     { WM_GETTEXT, sent|optional|defwinproc },
844     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
845     { WM_ERASEBKGND, sent },
846     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
847     { WM_CTLCOLORDLG, sent|defwinproc },
848     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
849     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
850     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
851     { WM_GETTEXT, sent|optional },
852     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
853     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
854     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
855     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
856     { WM_GETTEXT, sent|optional },
857     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
858     { WM_NCCALCSIZE, sent|optional },
859     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
860     { WM_NCPAINT, sent|optional },
861     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
862     { WM_GETTEXT, sent|optional|defwinproc },
863     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
864     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
865     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
866     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
867     { WM_GETTEXT, sent|optional|defwinproc },
868     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
869     { WM_ERASEBKGND, sent|optional },
870     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
871     { WM_CTLCOLORDLG, sent|optional|defwinproc },
872     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
873     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
874     { WM_SIZE, sent },
875     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
876     { WM_MOVE, sent },
877     { 0 }
878 };
879 /* Calling EndDialog for a custom dialog (32) */
880 static const struct message WmEndCustomDialogSeq[] = {
881     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
882     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
883     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
884     { WM_GETTEXT, sent|optional },
885     { HCBT_ACTIVATE, hook },
886     { WM_NCACTIVATE, sent|wparam, 0 },
887     { WM_GETTEXT, sent|optional|defwinproc },
888     { WM_GETTEXT, sent|optional|defwinproc },
889     { WM_ACTIVATE, sent|wparam, 0 },
890     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
891     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
892     { HCBT_SETFOCUS, hook },
893     { WM_KILLFOCUS, sent },
894     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
895     { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
896     { WM_IME_NOTIFY, sent|optional },
897     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
898     { WM_SETFOCUS, sent|parent|defwinproc },
899     { 0 }
900 };
901 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
902 static const struct message WmShowCustomDialogSeq[] = {
903     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
904     { WM_SHOWWINDOW, sent|wparam, 1 },
905     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
906     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
907     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
908     { HCBT_ACTIVATE, hook },
909     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
910
911     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
912     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
913
914     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
915     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
916     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
917     { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
918     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
919     { WM_NCACTIVATE, sent|wparam, 1 },
920     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
921     { WM_ACTIVATE, sent|wparam, 1 },
922
923     { WM_KILLFOCUS, sent|parent },
924     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
925     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
926     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
927     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
928     { WM_IME_NOTIFY, sent|optional|defwinproc },
929     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
930     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
931     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
932     { WM_SETFOCUS, sent },
933     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
934     { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
935     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
936     { WM_NCPAINT, sent|wparam, 1 },
937     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
938     { WM_ERASEBKGND, sent },
939     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
940     { WM_CTLCOLORDLG, sent|defwinproc },
941
942     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
943     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
944     { 0 }
945 };
946 /* Creation and destruction of a modal dialog (32) */
947 static const struct message WmModalDialogSeq[] = {
948     { WM_CANCELMODE, sent|parent },
949     { HCBT_SETFOCUS, hook },
950     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
951     { WM_KILLFOCUS, sent|parent },
952     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
953     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
954     { WM_ENABLE, sent|parent|wparam, 0 },
955     { HCBT_CREATEWND, hook },
956     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
957     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
958     { WM_SETFONT, sent },
959     { WM_INITDIALOG, sent },
960     { WM_CHANGEUISTATE, sent|optional },
961     { WM_SHOWWINDOW, sent },
962     { HCBT_ACTIVATE, hook },
963     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
964     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
965     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
966     { WM_NCACTIVATE, sent|wparam, 1 },
967     { WM_GETTEXT, sent|optional },
968     { WM_ACTIVATE, sent|wparam, 1 },
969     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE },
970     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
971     { WM_NCPAINT, sent },
972     { WM_GETTEXT, sent|optional },
973     { WM_ERASEBKGND, sent },
974     { WM_CTLCOLORDLG, sent },
975     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
976     { WM_GETTEXT, sent|optional },
977     { WM_NCCALCSIZE, sent|optional },
978     { WM_NCPAINT, sent|optional },
979     { WM_GETTEXT, sent|optional },
980     { WM_ERASEBKGND, sent|optional },
981     { WM_CTLCOLORDLG, sent|optional },
982     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
983     { WM_PAINT, sent|optional },
984     { WM_CTLCOLORBTN, sent },
985     { WM_ENTERIDLE, sent|parent|optional },
986     { WM_ENTERIDLE, sent|parent|optional },
987     { WM_ENTERIDLE, sent|parent|optional },
988     { WM_ENTERIDLE, sent|parent|optional },
989     { WM_ENTERIDLE, sent|parent|optional },
990     { WM_ENTERIDLE, sent|parent|optional },
991     { WM_ENTERIDLE, sent|parent|optional },
992     { WM_ENTERIDLE, sent|parent|optional },
993     { WM_ENTERIDLE, sent|parent|optional },
994     { WM_ENTERIDLE, sent|parent|optional },
995     { WM_ENTERIDLE, sent|parent|optional },
996     { WM_ENTERIDLE, sent|parent|optional },
997     { WM_ENTERIDLE, sent|parent|optional },
998     { WM_ENTERIDLE, sent|parent|optional },
999     { WM_ENTERIDLE, sent|parent|optional },
1000     { WM_ENTERIDLE, sent|parent|optional },
1001     { WM_ENTERIDLE, sent|parent|optional },
1002     { WM_ENTERIDLE, sent|parent|optional },
1003     { WM_ENTERIDLE, sent|parent|optional },
1004     { WM_ENTERIDLE, sent|parent|optional },
1005     { WM_TIMER, sent },
1006     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1007     { WM_ENABLE, sent|parent|wparam, 1 },
1008     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE },
1009     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1010     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1011     { WM_GETTEXT, sent|optional },
1012     { HCBT_ACTIVATE, hook },
1013     { WM_NCACTIVATE, sent|wparam, 0 },
1014     { WM_GETTEXT, sent|optional },
1015     { WM_ACTIVATE, sent|wparam, 0 },
1016     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1017     { WM_WINDOWPOSCHANGING, sent|optional },
1018     { HCBT_SETFOCUS, hook },
1019     { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1020     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1021     { WM_SETFOCUS, sent|parent|defwinproc },
1022     { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
1023     { HCBT_DESTROYWND, hook },
1024     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1025     { WM_DESTROY, sent },
1026     { WM_NCDESTROY, sent },
1027     { 0 }
1028 };
1029 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
1030 static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
1031     /* (inside dialog proc, handling WM_INITDIALOG) */
1032     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1033     { WM_NCCALCSIZE, sent },
1034     { WM_NCACTIVATE, sent|parent|wparam, 0 },
1035     { WM_GETTEXT, sent|defwinproc },
1036     { WM_ACTIVATE, sent|parent|wparam, 0 },
1037     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1038     { WM_WINDOWPOSCHANGING, sent|parent },
1039     { WM_NCACTIVATE, sent|wparam, 1 },
1040     { WM_ACTIVATE, sent|wparam, 1 },
1041     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1042     { WM_SIZE, sent|defwinproc },
1043     /* (setting focus) */
1044     { WM_SHOWWINDOW, sent|wparam, 1 },
1045     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1046     { WM_NCPAINT, sent },
1047     { WM_GETTEXT, sent|defwinproc },
1048     { WM_ERASEBKGND, sent },
1049     { WM_CTLCOLORDLG, sent|defwinproc },
1050     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1051     { WM_PAINT, sent },
1052     /* (bunch of WM_CTLCOLOR* for each control) */
1053     { WM_PAINT, sent|parent },
1054     { WM_ENTERIDLE, sent|parent|wparam, 0 },
1055     { WM_SETCURSOR, sent|parent },
1056     { 0 }
1057 };
1058 /* SetMenu for NonVisible windows with size change*/
1059 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
1060     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1061     { WM_NCCALCSIZE, sent|wparam, 1 },
1062     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1063     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW },
1064     { WM_MOVE, sent|defwinproc },
1065     { WM_SIZE, sent|defwinproc },
1066     { WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
1067     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1068     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1069     { WM_GETTEXT, sent|optional },
1070     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1071     { 0 }
1072 };
1073 /* SetMenu for NonVisible windows with no size change */
1074 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
1075     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1076     { WM_NCCALCSIZE, sent|wparam, 1 },
1077     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1078     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1079     { 0 }
1080 };
1081 /* SetMenu for Visible windows with size change */
1082 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
1083     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1084     { WM_NCCALCSIZE, sent|wparam, 1 },
1085     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1086     { WM_NCPAINT, sent }, /* wparam != 1 */
1087     { WM_GETTEXT, sent|defwinproc|optional },
1088     { WM_ERASEBKGND, sent|optional },
1089     { WM_ACTIVATE, sent|optional },
1090     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1091     { WM_MOVE, sent|defwinproc },
1092     { WM_SIZE, sent|defwinproc },
1093     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1094     { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1095     { WM_ERASEBKGND, sent|optional },
1096     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1097     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1098     { 0 }
1099 };
1100 /* SetMenu for Visible windows with no size change */
1101 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
1102     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1103     { WM_NCCALCSIZE, sent|wparam, 1 },
1104     { WM_NCPAINT, sent }, /* wparam != 1 */
1105     { WM_GETTEXT, sent|defwinproc|optional },
1106     { WM_ERASEBKGND, sent|optional },
1107     { WM_ACTIVATE, sent|optional },
1108     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1109     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1110     { 0 }
1111 };
1112 /* DrawMenuBar for a visible window */
1113 static const struct message WmDrawMenuBarSeq[] =
1114 {
1115     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1116     { WM_NCCALCSIZE, sent|wparam, 1 },
1117     { WM_NCPAINT, sent }, /* wparam != 1 */
1118     { WM_GETTEXT, sent|defwinproc|optional },
1119     { WM_ERASEBKGND, sent|optional },
1120     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1121     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1122     { 0 }
1123 };
1124
1125 static const struct message WmSetRedrawFalseSeq[] =
1126 {
1127     { WM_SETREDRAW, sent|wparam, 0 },
1128     { 0 }
1129 };
1130
1131 static const struct message WmSetRedrawTrueSeq[] =
1132 {
1133     { WM_SETREDRAW, sent|wparam, 1 },
1134     { 0 }
1135 };
1136
1137 static const struct message WmEnableWindowSeq_1[] =
1138 {
1139     { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1140     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1141     { WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
1142     { 0 }
1143 };
1144
1145 static const struct message WmEnableWindowSeq_2[] =
1146 {
1147     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1148     { WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
1149     { 0 }
1150 };
1151
1152 static const struct message WmGetScrollRangeSeq[] =
1153 {
1154     { SBM_GETRANGE, sent },
1155     { 0 }
1156 };
1157 static const struct message WmGetScrollInfoSeq[] =
1158 {
1159     { SBM_GETSCROLLINFO, sent },
1160     { 0 }
1161 };
1162 static const struct message WmSetScrollRangeSeq[] =
1163 {
1164     /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
1165        sends SBM_SETSCROLLINFO.
1166      */
1167     { SBM_SETSCROLLINFO, sent },
1168     { 0 }
1169 };
1170 /* SetScrollRange for a window without a non-client area */
1171 static const struct message WmSetScrollRangeHSeq_empty[] =
1172 {
1173     { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
1174     { 0 }
1175 };
1176 static const struct message WmSetScrollRangeVSeq_empty[] =
1177 {
1178     { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
1179     { 0 }
1180 };
1181 static const struct message WmSetScrollRangeHVSeq[] =
1182 {
1183     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER },
1184     { WM_NCCALCSIZE, sent|wparam, 1 },
1185     { WM_GETTEXT, sent|defwinproc|optional },
1186     { WM_ERASEBKGND, sent|optional },
1187     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1188     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1189     { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1190     { 0 }
1191 };
1192 /* SetScrollRange for a window with a non-client area */
1193 static const struct message WmSetScrollRangeHV_NC_Seq[] =
1194 {
1195     { WM_WINDOWPOSCHANGING, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER*/ },
1196     { WM_NCCALCSIZE, sent|wparam, 1 },
1197     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1198     { WM_NCPAINT, sent|optional },
1199     { WM_GETTEXT, sent|defwinproc|optional },
1200     { WM_GETTEXT, sent|defwinproc|optional },
1201     { WM_ERASEBKGND, sent|optional },
1202     { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
1203     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|0x1000*/ },
1204     { WM_SIZE, sent|defwinproc },
1205     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1206     { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1207     { WM_GETTEXT, sent|optional },
1208     { WM_GETTEXT, sent|optional },
1209     { WM_GETTEXT, sent|optional },
1210     { WM_GETTEXT, sent|optional },
1211     { 0 }
1212 };
1213 /* test if we receive the right sequence of messages */
1214 /* after calling ShowWindow( SW_SHOWNA) */
1215 static const struct message WmSHOWNAChildInvisParInvis[] = {
1216     { WM_SHOWWINDOW, sent|wparam, 1 },
1217     { 0 }
1218 };
1219 static const struct message WmSHOWNAChildVisParInvis[] = {
1220     { WM_SHOWWINDOW, sent|wparam, 1 },
1221     { 0 }
1222 };
1223 static const struct message WmSHOWNAChildVisParVis[] = {
1224     { WM_SHOWWINDOW, sent|wparam, 1 },
1225     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER },
1226     { 0 }
1227 };
1228 static const struct message WmSHOWNAChildInvisParVis[] = {
1229     { WM_SHOWWINDOW, sent|wparam, 1 },
1230     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER},
1231     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1232     { WM_ERASEBKGND, sent|optional },
1233     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1234     { 0 }
1235 };
1236 static const struct message WmSHOWNATopVisible[] = {
1237     { WM_SHOWWINDOW, sent|wparam, 1 },
1238     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1239     { 0 }
1240 };
1241 static const struct message WmSHOWNATopInvisible[] = {
1242     { WM_SHOWWINDOW, sent|wparam, 1 },
1243     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1244     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1245     { WM_NCPAINT, sent|wparam, 1 },
1246     { WM_GETTEXT, sent|defwinproc|optional },
1247     { WM_ERASEBKGND, sent|optional },
1248     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1249     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1250     { WM_NCPAINT, sent|wparam|optional, 1 },
1251     { WM_ERASEBKGND, sent|optional },
1252     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1253     { WM_SIZE, sent },
1254     { WM_MOVE, sent },
1255     { 0 }
1256 };
1257
1258 static int after_end_dialog;
1259 static int sequence_cnt, sequence_size;
1260 static struct message* sequence;
1261 static int log_all_parent_messages;
1262
1263 static void add_message(const struct message *msg)
1264 {
1265     if (!sequence) 
1266     {
1267         sequence_size = 10;
1268         sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) );
1269     }
1270     if (sequence_cnt == sequence_size) 
1271     {
1272         sequence_size *= 2;
1273         sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) );
1274     }
1275     assert(sequence);
1276
1277     sequence[sequence_cnt].message = msg->message;
1278     sequence[sequence_cnt].flags = msg->flags;
1279     sequence[sequence_cnt].wParam = msg->wParam;
1280     sequence[sequence_cnt].lParam = msg->lParam;
1281
1282     sequence_cnt++;
1283 }
1284
1285 /* try to make sure pending X events have been processed before continuing */
1286 static void flush_events(void)
1287 {
1288     MSG msg;
1289     int diff = 100;
1290     DWORD time = GetTickCount() + diff;
1291
1292     while (diff > 0)
1293     {
1294         MsgWaitForMultipleObjects( 0, NULL, FALSE, diff, QS_ALLINPUT );
1295         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
1296         diff = time - GetTickCount();
1297     }
1298 }
1299
1300 static void flush_sequence(void)
1301 {
1302     HeapFree(GetProcessHeap(), 0, sequence);
1303     sequence = 0;
1304     sequence_cnt = sequence_size = 0;
1305 }
1306
1307 #define ok_sequence( exp, contx, todo) \
1308         ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
1309
1310
1311 static void ok_sequence_(const struct message *expected, const char *context, int todo,
1312         const char *file, int line)
1313 {
1314     static const struct message end_of_sequence = { 0, 0, 0, 0 };
1315     const struct message *actual;
1316     int failcount = 0;
1317     
1318     add_message(&end_of_sequence);
1319
1320     actual = sequence;
1321
1322     while (expected->message && actual->message)
1323     {
1324         trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
1325
1326         if (expected->message == actual->message)
1327         {
1328             if (expected->flags & wparam)
1329             {
1330                 if (expected->wParam != actual->wParam && todo)
1331                 {
1332                     todo_wine {
1333                         failcount ++;
1334                         ok_( file, line) (FALSE,
1335                             "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
1336                             context, expected->message, expected->wParam, actual->wParam);
1337                     }
1338                 }
1339                 else
1340                 ok_( file, line) (expected->wParam == actual->wParam,
1341                      "%s: in msg 0x%04x expecting wParam 0x%x got 0x%x\n",
1342                      context, expected->message, expected->wParam, actual->wParam);
1343             }
1344             if (expected->flags & lparam)
1345                  ok_( file, line) (expected->lParam == actual->lParam,
1346                      "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1347                      context, expected->message, expected->lParam, actual->lParam);
1348             ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
1349                 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1350                 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1351             ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
1352                 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
1353                 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
1354             ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
1355                 "%s: the msg 0x%04x should have been %s\n",
1356                 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
1357             ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
1358                 "%s: the msg 0x%04x was expected in %s\n",
1359                 context, expected->message, (expected->flags & parent) ? "parent" : "child");
1360             ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
1361                 "%s: the msg 0x%04x should have been sent by a hook\n",
1362                 context, expected->message);
1363             ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
1364                 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
1365                 context, expected->message);
1366             expected++;
1367             actual++;
1368         }
1369         /* silently drop winevent messages if there is no support for them */
1370         else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
1371             expected++;
1372         else if (todo)
1373         {
1374             failcount++;
1375             todo_wine {
1376                 ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1377                     context, expected->message, actual->message);
1378             }
1379             flush_sequence();
1380             return;
1381         }
1382         else
1383         {
1384             ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1385                 context, expected->message, actual->message);
1386             expected++;
1387             actual++;
1388         }
1389     }
1390
1391     /* skip all optional trailing messages */
1392     while (expected->message && ((expected->flags & optional) ||
1393             ((expected->flags & winevent_hook) && !hEvent_hook)))
1394         expected++;
1395
1396     if (todo)
1397     {
1398         todo_wine {
1399             if (expected->message || actual->message) {
1400                 failcount++;
1401                 ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1402                     context, expected->message, actual->message);
1403             }
1404         }
1405     }
1406     else
1407     {
1408         if (expected->message || actual->message)
1409             ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1410                 context, expected->message, actual->message);
1411     }
1412     if( todo && !failcount) /* succeeded yet marked todo */
1413         todo_wine {
1414             ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
1415         }
1416
1417     flush_sequence();
1418 }
1419
1420 /******************************** MDI test **********************************/
1421
1422 /* CreateWindow for MDI frame window, initially visible */
1423 static const struct message WmCreateMDIframeSeq[] = {
1424     { HCBT_CREATEWND, hook },
1425     { WM_GETMINMAXINFO, sent },
1426     { WM_NCCREATE, sent },
1427     { WM_NCCALCSIZE, sent|wparam, 0 },
1428     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1429     { WM_CREATE, sent },
1430     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1431     { WM_SHOWWINDOW, sent|wparam, 1 },
1432     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1433     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1434     { HCBT_ACTIVATE, hook },
1435     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1436     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1437     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1438     { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* Win9x */
1439     { WM_ACTIVATEAPP, sent|wparam, 1 },
1440     { WM_NCACTIVATE, sent|wparam, 1 },
1441     { WM_GETTEXT, sent|defwinproc|optional },
1442     { WM_ACTIVATE, sent|wparam, 1 },
1443     { HCBT_SETFOCUS, hook },
1444     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1445     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1446     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
1447     /* Win9x adds SWP_NOZORDER below */
1448     { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
1449     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
1450     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1451     { WM_SIZE, sent },
1452     { WM_MOVE, sent },
1453     { 0 }
1454 };
1455 /* DestroyWindow for MDI frame window, initially visible */
1456 static const struct message WmDestroyMDIframeSeq[] = {
1457     { HCBT_DESTROYWND, hook },
1458     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1459     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1460     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1461     { WM_NCACTIVATE, sent|wparam, 0 },
1462     { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
1463     { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
1464     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
1465     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1466     { WM_DESTROY, sent },
1467     { WM_NCDESTROY, sent },
1468     { 0 }
1469 };
1470 /* CreateWindow for MDI client window, initially visible */
1471 static const struct message WmCreateMDIclientSeq[] = {
1472     { HCBT_CREATEWND, hook },
1473     { WM_NCCREATE, sent },
1474     { WM_NCCALCSIZE, sent|wparam, 0 },
1475     { WM_CREATE, sent },
1476     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1477     { WM_SIZE, sent },
1478     { WM_MOVE, sent },
1479     { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
1480     { WM_SHOWWINDOW, sent|wparam, 1 },
1481     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE },
1482     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1483     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1484     { 0 }
1485 };
1486 /* DestroyWindow for MDI client window, initially visible */
1487 static const struct message WmDestroyMDIclientSeq[] = {
1488     { HCBT_DESTROYWND, hook },
1489     { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
1490     { WM_SHOWWINDOW, sent|wparam, 0 },
1491     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1492     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1493     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1494     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1495     { WM_DESTROY, sent },
1496     { WM_NCDESTROY, sent },
1497     { 0 }
1498 };
1499 /* CreateWindow for MDI child window, initially visible */
1500 static const struct message WmCreateMDIchildVisibleSeq[] = {
1501     { HCBT_CREATEWND, hook },
1502     { WM_NCCREATE, sent }, 
1503     { WM_NCCALCSIZE, sent|wparam, 0 },
1504     { WM_CREATE, sent },
1505     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1506     { WM_SIZE, sent },
1507     { WM_MOVE, sent },
1508     /* Win2k sends wparam set to
1509      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1510      * while Win9x doesn't bother to set child window id according to
1511      * CLIENTCREATESTRUCT.idFirstChild
1512      */
1513     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1514     { WM_SHOWWINDOW, sent|wparam, 1 },
1515     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1516     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1517     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1518     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1519     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1520     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1521     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1522
1523     /* Win9x: message sequence terminates here. */
1524
1525     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1526     { HCBT_SETFOCUS, hook }, /* in MDI client */
1527     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1528     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1529     { WM_SETFOCUS, sent }, /* in MDI client */
1530     { HCBT_SETFOCUS, hook },
1531     { WM_KILLFOCUS, sent }, /* in MDI client */
1532     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1533     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1534     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1535     { WM_SETFOCUS, sent|defwinproc },
1536     { WM_MDIACTIVATE, sent|defwinproc },
1537     { 0 }
1538 };
1539 /* DestroyWindow for MDI child window, initially visible */
1540 static const struct message WmDestroyMDIchildVisibleSeq[] = {
1541     { HCBT_DESTROYWND, hook },
1542     /* Win2k sends wparam set to
1543      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1544      * while Win9x doesn't bother to set child window id according to
1545      * CLIENTCREATESTRUCT.idFirstChild
1546      */
1547     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1548     { WM_SHOWWINDOW, sent|wparam, 0 },
1549     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1550     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1551     { WM_ERASEBKGND, sent|parent|optional },
1552     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1553
1554     /* { WM_DESTROY, sent }
1555      * Win9x: message sequence terminates here.
1556      */
1557
1558     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1559     { WM_KILLFOCUS, sent },
1560     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1561     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1562     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1563     { WM_SETFOCUS, sent }, /* in MDI client */
1564
1565     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1566     { WM_KILLFOCUS, sent }, /* in MDI client */
1567     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1568     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1569     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1570     { WM_SETFOCUS, sent }, /* in MDI client */
1571
1572     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1573
1574     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1575     { WM_KILLFOCUS, sent },
1576     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1577     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1578     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1579     { WM_SETFOCUS, sent }, /* in MDI client */
1580
1581     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1582     { WM_KILLFOCUS, sent }, /* in MDI client */
1583     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1584     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1585     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1586     { WM_SETFOCUS, sent }, /* in MDI client */
1587
1588     { WM_DESTROY, sent },
1589
1590     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1591     { WM_KILLFOCUS, sent },
1592     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1593     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1594     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1595     { WM_SETFOCUS, sent }, /* in MDI client */
1596
1597     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1598     { WM_KILLFOCUS, sent }, /* in MDI client */
1599     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1600     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1601     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1602     { WM_SETFOCUS, sent }, /* in MDI client */
1603
1604     { WM_NCDESTROY, sent },
1605     { 0 }
1606 };
1607 /* CreateWindow for MDI child window, initially invisible */
1608 static const struct message WmCreateMDIchildInvisibleSeq[] = {
1609     { HCBT_CREATEWND, hook },
1610     { WM_NCCREATE, sent }, 
1611     { WM_NCCALCSIZE, sent|wparam, 0 },
1612     { WM_CREATE, sent },
1613     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1614     { WM_SIZE, sent },
1615     { WM_MOVE, sent },
1616     /* Win2k sends wparam set to
1617      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1618      * while Win9x doesn't bother to set child window id according to
1619      * CLIENTCREATESTRUCT.idFirstChild
1620      */
1621     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1622     { 0 }
1623 };
1624 /* DestroyWindow for MDI child window, initially invisible */
1625 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
1626     { HCBT_DESTROYWND, hook },
1627     /* Win2k sends wparam set to
1628      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1629      * while Win9x doesn't bother to set child window id according to
1630      * CLIENTCREATESTRUCT.idFirstChild
1631      */
1632     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1633     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1634     { WM_DESTROY, sent },
1635     { WM_NCDESTROY, sent },
1636     { 0 }
1637 };
1638 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
1639 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
1640     { HCBT_CREATEWND, hook },
1641     { WM_NCCREATE, sent }, 
1642     { WM_NCCALCSIZE, sent|wparam, 0 },
1643     { WM_CREATE, sent },
1644     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1645     { WM_SIZE, sent },
1646     { WM_MOVE, sent },
1647     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1648     { WM_GETMINMAXINFO, sent },
1649     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1650     { WM_NCCALCSIZE, sent|wparam, 1 },
1651     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1652     { WM_SIZE, sent|defwinproc },
1653      /* in MDI frame */
1654     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1655     { WM_NCCALCSIZE, sent|wparam, 1 },
1656     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1657     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1658     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1659     /* Win2k sends wparam set to
1660      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1661      * while Win9x doesn't bother to set child window id according to
1662      * CLIENTCREATESTRUCT.idFirstChild
1663      */
1664     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1665     { WM_SHOWWINDOW, sent|wparam, 1 },
1666     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1667     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1668     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1669     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1670     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1671     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1672     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1673
1674     /* Win9x: message sequence terminates here. */
1675
1676     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1677     { HCBT_SETFOCUS, hook }, /* in MDI client */
1678     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1679     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1680     { WM_SETFOCUS, sent }, /* in MDI client */
1681     { HCBT_SETFOCUS, hook },
1682     { WM_KILLFOCUS, sent }, /* in MDI client */
1683     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1684     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1685     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1686     { WM_SETFOCUS, sent|defwinproc },
1687     { WM_MDIACTIVATE, sent|defwinproc },
1688      /* in MDI frame */
1689     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1690     { WM_NCCALCSIZE, sent|wparam, 1 },
1691     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1692     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1693     { 0 }
1694 };
1695 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
1696 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
1697     /* restore the 1st MDI child */
1698     { WM_SETREDRAW, sent|wparam, 0 },
1699     { HCBT_MINMAX, hook },
1700     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1701     { WM_NCCALCSIZE, sent|wparam, 1 },
1702     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1703     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1704     { WM_SIZE, sent|defwinproc },
1705      /* in MDI frame */
1706     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1707     { WM_NCCALCSIZE, sent|wparam, 1 },
1708     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1709     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1710     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1711     { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
1712     /* create the 2nd MDI child */
1713     { HCBT_CREATEWND, hook },
1714     { WM_NCCREATE, sent }, 
1715     { WM_NCCALCSIZE, sent|wparam, 0 },
1716     { WM_CREATE, sent },
1717     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1718     { WM_SIZE, sent },
1719     { WM_MOVE, sent },
1720     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1721     { WM_GETMINMAXINFO, sent },
1722     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1723     { WM_NCCALCSIZE, sent|wparam, 1 },
1724     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1725     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1726     { WM_SIZE, sent|defwinproc },
1727      /* in MDI frame */
1728     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1729     { WM_NCCALCSIZE, sent|wparam, 1 },
1730     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1731     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1732     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1733     /* Win2k sends wparam set to
1734      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1735      * while Win9x doesn't bother to set child window id according to
1736      * CLIENTCREATESTRUCT.idFirstChild
1737      */
1738     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1739     { WM_SHOWWINDOW, sent|wparam, 1 },
1740     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1741     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1742     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1743     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1744     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1745     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1746
1747     { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
1748     { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
1749
1750     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1751
1752     /* Win9x: message sequence terminates here. */
1753
1754     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1755     { HCBT_SETFOCUS, hook },
1756     { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
1757     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
1758     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1759     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1760     { WM_SETFOCUS, sent }, /* in MDI client */
1761     { HCBT_SETFOCUS, hook },
1762     { WM_KILLFOCUS, sent }, /* in MDI client */
1763     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1764     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1765     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1766     { WM_SETFOCUS, sent|defwinproc },
1767
1768     { WM_MDIACTIVATE, sent|defwinproc },
1769      /* in MDI frame */
1770     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1771     { WM_NCCALCSIZE, sent|wparam, 1 },
1772     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1773     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1774     { 0 }
1775 };
1776 /* WM_MDICREATE MDI child window, initially visible and maximized */
1777 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
1778     { WM_MDICREATE, sent },
1779     { HCBT_CREATEWND, hook },
1780     { WM_NCCREATE, sent }, 
1781     { WM_NCCALCSIZE, sent|wparam, 0 },
1782     { WM_CREATE, sent },
1783     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1784     { WM_SIZE, sent },
1785     { WM_MOVE, sent },
1786     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1787     { WM_GETMINMAXINFO, sent },
1788     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1789     { WM_NCCALCSIZE, sent|wparam, 1 },
1790     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1791     { WM_SIZE, sent|defwinproc },
1792
1793      /* in MDI frame */
1794     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1795     { WM_NCCALCSIZE, sent|wparam, 1 },
1796     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1797     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1798     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1799
1800     /* Win2k sends wparam set to
1801      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1802      * while Win9x doesn't bother to set child window id according to
1803      * CLIENTCREATESTRUCT.idFirstChild
1804      */
1805     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1806     { WM_SHOWWINDOW, sent|wparam, 1 },
1807     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1808
1809     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1810
1811     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1812     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1813     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1814
1815     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1816     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1817
1818     /* Win9x: message sequence terminates here. */
1819
1820     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1821     { HCBT_SETFOCUS, hook }, /* in MDI client */
1822     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1823     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1824     { WM_SETFOCUS, sent }, /* in MDI client */
1825     { HCBT_SETFOCUS, hook },
1826     { WM_KILLFOCUS, sent }, /* in MDI client */
1827     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1828     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1829     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1830     { WM_SETFOCUS, sent|defwinproc },
1831
1832     { WM_MDIACTIVATE, sent|defwinproc },
1833
1834      /* in MDI child */
1835     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1836     { WM_NCCALCSIZE, sent|wparam, 1 },
1837     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1838     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1839
1840      /* in MDI frame */
1841     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1842     { WM_NCCALCSIZE, sent|wparam, 1 },
1843     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1844     { WM_MOVE, sent|defwinproc },
1845     { WM_SIZE, sent|defwinproc },
1846
1847      /* in MDI client */
1848     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1849     { WM_NCCALCSIZE, sent|wparam, 1 },
1850     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1851     { WM_SIZE, sent },
1852
1853      /* in MDI child */
1854     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1855     { WM_NCCALCSIZE, sent|wparam, 1 },
1856     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1857     { WM_SIZE, sent|defwinproc },
1858
1859     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1860     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
1861     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
1862     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1863     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
1864
1865     { 0 }
1866 };
1867 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
1868 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
1869     { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
1870     { HCBT_SYSCOMMAND, hook },
1871     { WM_CLOSE, sent|defwinproc },
1872     { WM_MDIDESTROY, sent }, /* in MDI client */
1873
1874     /* bring the 1st MDI child to top */
1875     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
1876     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
1877
1878     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1879
1880     { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
1881     { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
1882     { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
1883
1884     /* maximize the 1st MDI child */
1885     { HCBT_MINMAX, hook },
1886     { WM_GETMINMAXINFO, sent|defwinproc },
1887     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|0x8000 },
1888     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1889     { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
1890     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1891     { WM_SIZE, sent|defwinproc },
1892
1893     /* restore the 2nd MDI child */
1894     { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
1895     { HCBT_MINMAX, hook },
1896     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOZORDER|0x8000 },
1897     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1898
1899     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1900
1901     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1902     { WM_SIZE, sent|defwinproc },
1903
1904     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1905
1906     { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
1907      /* in MDI frame */
1908     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1909     { WM_NCCALCSIZE, sent|wparam, 1 },
1910     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1911     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1912     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1913
1914     /* bring the 1st MDI child to top */
1915     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1916     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1917     { HCBT_SETFOCUS, hook },
1918     { WM_KILLFOCUS, sent|defwinproc },
1919     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
1920     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1921     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1922     { WM_SETFOCUS, sent }, /* in MDI client */
1923     { HCBT_SETFOCUS, hook },
1924     { WM_KILLFOCUS, sent }, /* in MDI client */
1925     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1926     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1927     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1928     { WM_SETFOCUS, sent|defwinproc },
1929     { WM_MDIACTIVATE, sent|defwinproc },
1930     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1931
1932     /* apparently ShowWindow(SW_SHOW) on an MDI client */
1933     { WM_SHOWWINDOW, sent|wparam, 1 },
1934     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1935     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1936     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1937     { WM_MDIREFRESHMENU, sent },
1938
1939     { HCBT_DESTROYWND, hook },
1940     /* Win2k sends wparam set to
1941      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1942      * while Win9x doesn't bother to set child window id according to
1943      * CLIENTCREATESTRUCT.idFirstChild
1944      */
1945     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1946     { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
1947     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1948     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1949     { WM_ERASEBKGND, sent|parent|optional },
1950     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1951
1952     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1953     { WM_DESTROY, sent|defwinproc },
1954     { WM_NCDESTROY, sent|defwinproc },
1955     { 0 }
1956 };
1957 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
1958 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
1959     { WM_MDIDESTROY, sent }, /* in MDI client */
1960     { WM_SHOWWINDOW, sent|wparam, 0 },
1961     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1962     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1963     { WM_ERASEBKGND, sent|parent|optional },
1964     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1965
1966     { HCBT_SETFOCUS, hook },
1967     { WM_KILLFOCUS, sent },
1968     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1969     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1970     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1971     { WM_SETFOCUS, sent }, /* in MDI client */
1972     { HCBT_SETFOCUS, hook },
1973     { WM_KILLFOCUS, sent }, /* in MDI client */
1974     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1975     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1976     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1977     { WM_SETFOCUS, sent },
1978
1979      /* in MDI child */
1980     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1981     { WM_NCCALCSIZE, sent|wparam, 1 },
1982     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1983     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1984
1985      /* in MDI frame */
1986     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1987     { WM_NCCALCSIZE, sent|wparam, 1 },
1988     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
1989     { WM_MOVE, sent|defwinproc },
1990     { WM_SIZE, sent|defwinproc },
1991
1992      /* in MDI client */
1993     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
1994     { WM_NCCALCSIZE, sent|wparam, 1 },
1995     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
1996     { WM_SIZE, sent },
1997
1998      /* in MDI child */
1999     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
2000     { WM_NCCALCSIZE, sent|wparam, 1 },
2001     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2002     { WM_SIZE, sent|defwinproc },
2003
2004      /* in MDI child */
2005     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2006     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2007     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2008     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2009
2010      /* in MDI frame */
2011     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2012     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2013     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2014     { WM_MOVE, sent|defwinproc },
2015     { WM_SIZE, sent|defwinproc },
2016
2017      /* in MDI client */
2018     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
2019     { WM_NCCALCSIZE, sent|wparam, 1 },
2020     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
2021     { WM_SIZE, sent },
2022
2023      /* in MDI child */
2024     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOZORDER },
2025     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2026     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2027     { WM_SIZE, sent|defwinproc },
2028     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2029     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2030
2031     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
2032
2033     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2034     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2035     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2036     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2037     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2038
2039      /* in MDI frame */
2040     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2041     { WM_NCCALCSIZE, sent|wparam, 1 },
2042     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2043     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2044
2045     { WM_NCACTIVATE, sent|wparam, 0 },
2046     { WM_MDIACTIVATE, sent },
2047
2048     { HCBT_MINMAX, hook },
2049     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|0x8000 },
2050     { WM_NCCALCSIZE, sent|wparam, 1 },
2051
2052     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2053
2054     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2055     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE|0x8000 },
2056     { WM_SIZE, sent|defwinproc },
2057
2058      /* in MDI child */
2059     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2060     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2061     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2062     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2063
2064      /* in MDI frame */
2065     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2066     { WM_NCCALCSIZE, sent|wparam, 1 },
2067     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2068     { WM_MOVE, sent|defwinproc },
2069     { WM_SIZE, sent|defwinproc },
2070
2071      /* in MDI client */
2072     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOZORDER },
2073     { WM_NCCALCSIZE, sent|wparam, 1 },
2074     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTMOVE },
2075     { WM_SIZE, sent },
2076     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2077     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2078     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2079     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2080     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2081
2082     { HCBT_SETFOCUS, hook },
2083     { WM_KILLFOCUS, sent },
2084     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2085     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2086     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2087     { WM_SETFOCUS, sent }, /* in MDI client */
2088
2089     { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2090
2091     { HCBT_DESTROYWND, hook },
2092     /* Win2k sends wparam set to
2093      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2094      * while Win9x doesn't bother to set child window id according to
2095      * CLIENTCREATESTRUCT.idFirstChild
2096      */
2097     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2098
2099     { WM_SHOWWINDOW, sent|wparam, 0 },
2100     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2101     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2102     { WM_ERASEBKGND, sent|parent|optional },
2103     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2104
2105     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2106     { WM_DESTROY, sent },
2107     { WM_NCDESTROY, sent },
2108     { 0 }
2109 };
2110 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
2111 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
2112     { HCBT_MINMAX, hook },
2113     { WM_GETMINMAXINFO, sent },
2114     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
2115     { WM_NCCALCSIZE, sent|wparam, 1 },
2116     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2117     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2118
2119     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2120     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2121     { HCBT_SETFOCUS, hook },
2122     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2123     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2124     { WM_SETFOCUS, sent }, /* in MDI client */
2125     { HCBT_SETFOCUS, hook },
2126     { WM_KILLFOCUS, sent }, /* in MDI client */
2127     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2128     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2129     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2130     { WM_SETFOCUS, sent|defwinproc },
2131     { WM_MDIACTIVATE, sent|defwinproc },
2132     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2133     { WM_SIZE, sent|defwinproc },
2134      /* in MDI frame */
2135     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2136     { WM_NCCALCSIZE, sent|wparam, 1 },
2137     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2138     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2139     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2140     { 0 }
2141 };
2142 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
2143 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
2144     { HCBT_MINMAX, hook },
2145     { WM_GETMINMAXINFO, sent },
2146     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
2147     { WM_NCCALCSIZE, sent|wparam, 1 },
2148     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2149     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2150     { WM_SIZE, sent|defwinproc },
2151      /* in MDI frame */
2152     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2153     { WM_NCCALCSIZE, sent|wparam, 1 },
2154     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2155     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2156     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2157     { 0 }
2158 };
2159 /* ShowWindow(SW_RESTORE) for a visible MDI child window */
2160 static const struct message WmRestoreMDIchildVisibleSeq[] = {
2161     { HCBT_MINMAX, hook },
2162     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
2163     { WM_NCCALCSIZE, sent|wparam, 1 },
2164     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2165     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2166     { WM_SIZE, sent|defwinproc },
2167      /* in MDI frame */
2168     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2169     { WM_NCCALCSIZE, sent|wparam, 1 },
2170     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2171     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2172     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2173     { 0 }
2174 };
2175 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
2176 static const struct message WmRestoreMDIchildInisibleSeq[] = {
2177     { HCBT_MINMAX, hook },
2178     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
2179     { WM_NCCALCSIZE, sent|wparam, 1 },
2180     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2181     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2182     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2183     { WM_SIZE, sent|defwinproc },
2184      /* in MDI frame */
2185     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER },
2186     { WM_NCCALCSIZE, sent|wparam, 1 },
2187     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2188     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2189     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2190     { 0 }
2191 };
2192
2193 static HWND mdi_client;
2194 static WNDPROC old_mdi_client_proc;
2195
2196 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2197 {
2198     struct message msg;
2199
2200     /* do not log painting messages */
2201     if (message != WM_PAINT &&
2202         message != WM_ERASEBKGND &&
2203         message != WM_NCPAINT &&
2204         message != WM_NCHITTEST &&
2205         message != WM_GETTEXT &&
2206         message != WM_MDIGETACTIVE &&
2207         message != WM_GETICON &&
2208         message != WM_DEVICECHANGE)
2209     {
2210         trace("mdi client: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2211
2212         switch (message)
2213         {
2214             case WM_WINDOWPOSCHANGING:
2215             case WM_WINDOWPOSCHANGED:
2216             {
2217                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2218
2219                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2220                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2221                       winpos->hwnd, winpos->hwndInsertAfter,
2222                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2223
2224                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2225                  * in the high word for internal purposes
2226                  */
2227                 wParam = winpos->flags & 0xffff;
2228                 break;
2229             }
2230         }
2231
2232         msg.message = message;
2233         msg.flags = sent|wparam|lparam;
2234         msg.wParam = wParam;
2235         msg.lParam = lParam;
2236         add_message(&msg);
2237     }
2238
2239     return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
2240 }
2241
2242 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2243 {
2244     static long defwndproc_counter = 0;
2245     LRESULT ret;
2246     struct message msg;
2247
2248     /* do not log painting messages */
2249     if (message != WM_PAINT &&
2250         message != WM_ERASEBKGND &&
2251         message != WM_NCPAINT &&
2252         message != WM_NCHITTEST &&
2253         message != WM_GETTEXT &&
2254         message != WM_GETICON &&
2255         message != WM_DEVICECHANGE)
2256     {
2257         trace("mdi child: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2258
2259         switch (message)
2260         {
2261             case WM_WINDOWPOSCHANGING:
2262             case WM_WINDOWPOSCHANGED:
2263             {
2264                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2265
2266                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2267                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2268                       winpos->hwnd, winpos->hwndInsertAfter,
2269                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2270
2271                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2272                  * in the high word for internal purposes
2273                  */
2274                 wParam = winpos->flags & 0xffff;
2275                 break;
2276             }
2277
2278             case WM_MDIACTIVATE:
2279             {
2280                 HWND active, client = GetParent(hwnd);
2281
2282                 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
2283
2284                 if (hwnd == (HWND)lParam) /* if we are being activated */
2285                     ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
2286                 else
2287                     ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
2288                 break;
2289             }
2290         }
2291
2292         msg.message = message;
2293         msg.flags = sent|wparam|lparam;
2294         if (defwndproc_counter) msg.flags |= defwinproc;
2295         msg.wParam = wParam;
2296         msg.lParam = lParam;
2297         add_message(&msg);
2298     }
2299
2300     defwndproc_counter++;
2301     ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
2302     defwndproc_counter--;
2303
2304     return ret;
2305 }
2306
2307 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2308 {
2309     static long defwndproc_counter = 0;
2310     LRESULT ret;
2311     struct message msg;
2312
2313     /* do not log painting messages */
2314     if (message != WM_PAINT &&
2315         message != WM_ERASEBKGND &&
2316         message != WM_NCPAINT &&
2317         message != WM_NCHITTEST &&
2318         message != WM_GETTEXT &&
2319         message != WM_GETICON &&
2320         message != WM_DEVICECHANGE)
2321     {
2322         trace("mdi frame: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2323
2324         switch (message)
2325         {
2326             case WM_WINDOWPOSCHANGING:
2327             case WM_WINDOWPOSCHANGED:
2328             {
2329                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2330
2331                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2332                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2333                       winpos->hwnd, winpos->hwndInsertAfter,
2334                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2335
2336                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2337                  * in the high word for internal purposes
2338                  */
2339                 wParam = winpos->flags & 0xffff;
2340                 break;
2341             }
2342         }
2343
2344         msg.message = message;
2345         msg.flags = sent|wparam|lparam;
2346         if (defwndproc_counter) msg.flags |= defwinproc;
2347         msg.wParam = wParam;
2348         msg.lParam = lParam;
2349         add_message(&msg);
2350     }
2351
2352     defwndproc_counter++;
2353     ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
2354     defwndproc_counter--;
2355
2356     return ret;
2357 }
2358
2359 static BOOL mdi_RegisterWindowClasses(void)
2360 {
2361     WNDCLASSA cls;
2362
2363     cls.style = 0;
2364     cls.lpfnWndProc = mdi_frame_wnd_proc;
2365     cls.cbClsExtra = 0;
2366     cls.cbWndExtra = 0;
2367     cls.hInstance = GetModuleHandleA(0);
2368     cls.hIcon = 0;
2369     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
2370     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
2371     cls.lpszMenuName = NULL;
2372     cls.lpszClassName = "MDI_frame_class";
2373     if (!RegisterClassA(&cls)) return FALSE;
2374
2375     cls.lpfnWndProc = mdi_child_wnd_proc;
2376     cls.lpszClassName = "MDI_child_class";
2377     if (!RegisterClassA(&cls)) return FALSE;
2378
2379     if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
2380     old_mdi_client_proc = cls.lpfnWndProc;
2381     cls.hInstance = GetModuleHandleA(0);
2382     cls.lpfnWndProc = mdi_client_hook_proc;
2383     cls.lpszClassName = "MDI_client_class";
2384     if (!RegisterClassA(&cls)) assert(0);
2385
2386     return TRUE;
2387 }
2388
2389 static void test_mdi_messages(void)
2390 {
2391     MDICREATESTRUCTA mdi_cs;
2392     CLIENTCREATESTRUCT client_cs;
2393     HWND mdi_frame, mdi_child, mdi_child2, active_child;
2394     BOOL zoomed;
2395     HMENU hMenu = CreateMenu();
2396
2397     assert(mdi_RegisterWindowClasses());
2398
2399     flush_sequence();
2400
2401     trace("creating MDI frame window\n");
2402     mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
2403                                 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
2404                                 WS_MAXIMIZEBOX | WS_VISIBLE,
2405                                 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
2406                                 GetDesktopWindow(), hMenu,
2407                                 GetModuleHandleA(0), NULL);
2408     assert(mdi_frame);
2409     ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", TRUE);
2410
2411     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2412     ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
2413
2414     trace("creating MDI client window\n");
2415     client_cs.hWindowMenu = 0;
2416     client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
2417     mdi_client = CreateWindowExA(0, "MDI_client_class",
2418                                  NULL,
2419                                  WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
2420                                  0, 0, 0, 0,
2421                                  mdi_frame, 0, GetModuleHandleA(0), &client_cs);
2422     assert(mdi_client);
2423     ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
2424
2425     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2426     ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
2427
2428     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2429     ok(!active_child, "wrong active MDI child %p\n", active_child);
2430     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2431
2432     SetFocus(0);
2433     flush_sequence();
2434
2435     trace("creating invisible MDI child window\n");
2436     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2437                                 WS_CHILD,
2438                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2439                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2440     assert(mdi_child);
2441
2442     flush_sequence();
2443     ShowWindow(mdi_child, SW_SHOWNORMAL);
2444     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
2445
2446     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2447     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2448
2449     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2450     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2451
2452     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2453     ok(!active_child, "wrong active MDI child %p\n", active_child);
2454     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2455
2456     ShowWindow(mdi_child, SW_HIDE);
2457     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
2458     flush_sequence();
2459
2460     ShowWindow(mdi_child, SW_SHOW);
2461     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
2462
2463     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2464     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2465
2466     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2467     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2468
2469     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2470     ok(!active_child, "wrong active MDI child %p\n", active_child);
2471     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2472
2473     DestroyWindow(mdi_child);
2474     flush_sequence();
2475
2476     trace("creating visible MDI child window\n");
2477     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2478                                 WS_CHILD | WS_VISIBLE,
2479                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2480                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2481     assert(mdi_child);
2482     ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
2483
2484     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2485     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2486
2487     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2488     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2489
2490     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2491     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2492     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2493     flush_sequence();
2494
2495     DestroyWindow(mdi_child);
2496     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2497
2498     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2499     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2500
2501     /* Win2k: MDI client still returns a just destroyed child as active
2502      * Win9x: MDI client returns 0
2503      */
2504     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2505     ok(active_child == mdi_child || /* win2k */
2506        !active_child, /* win9x */
2507        "wrong active MDI child %p\n", active_child);
2508     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2509
2510     flush_sequence();
2511
2512     trace("creating invisible MDI child window\n");
2513     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2514                                 WS_CHILD,
2515                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2516                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2517     assert(mdi_child2);
2518     ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
2519
2520     ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
2521     ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
2522
2523     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2524     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2525
2526     /* Win2k: MDI client still returns a just destroyed child as active
2527      * Win9x: MDI client returns mdi_child2
2528      */
2529     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2530     ok(active_child == mdi_child || /* win2k */
2531        active_child == mdi_child2, /* win9x */
2532        "wrong active MDI child %p\n", active_child);
2533     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2534     flush_sequence();
2535
2536     ShowWindow(mdi_child2, SW_MAXIMIZE);
2537     ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", TRUE);
2538
2539     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2540     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
2541
2542     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2543     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2544     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2545     flush_sequence();
2546
2547     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2548     ok(GetFocus() == mdi_child2 || /* win2k */
2549        GetFocus() == 0, /* win9x */
2550        "wrong focus window %p\n", GetFocus());
2551
2552     SetFocus(0);
2553     flush_sequence();
2554
2555     ShowWindow(mdi_child2, SW_HIDE);
2556     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2557
2558     ShowWindow(mdi_child2, SW_RESTORE);
2559     ok_sequence(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", TRUE);
2560     flush_sequence();
2561
2562     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2563     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
2564
2565     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2566     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2567     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2568     flush_sequence();
2569
2570     SetFocus(0);
2571     flush_sequence();
2572
2573     ShowWindow(mdi_child2, SW_HIDE);
2574     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2575
2576     ShowWindow(mdi_child2, SW_SHOW);
2577     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
2578
2579     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2580     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2581
2582     ShowWindow(mdi_child2, SW_MAXIMIZE);
2583     ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", TRUE);
2584
2585     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2586     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2587
2588     ShowWindow(mdi_child2, SW_RESTORE);
2589     ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):MDI child", TRUE);
2590
2591     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2592     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2593
2594     SetFocus(0);
2595     flush_sequence();
2596
2597     ShowWindow(mdi_child2, SW_HIDE);
2598     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2599
2600     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2601     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2602
2603     DestroyWindow(mdi_child2);
2604     ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
2605
2606     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2607     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2608
2609     /* test for maximized MDI children */
2610     trace("creating maximized visible MDI child window 1\n");
2611     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2612                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
2613                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2614                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2615     assert(mdi_child);
2616     ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
2617     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2618
2619     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2620     ok(GetFocus() == mdi_child || /* win2k */
2621        GetFocus() == 0, /* win9x */
2622        "wrong focus window %p\n", GetFocus());
2623
2624     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2625     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2626     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2627     flush_sequence();
2628
2629     trace("creating maximized visible MDI child window 2\n");
2630     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2631                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
2632                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2633                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2634     assert(mdi_child2);
2635     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
2636     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
2637     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
2638
2639     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2640     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
2641
2642     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2643     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2644     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2645     flush_sequence();
2646
2647     trace("destroying maximized visible MDI child window 2\n");
2648     DestroyWindow(mdi_child2);
2649     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2650
2651     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
2652
2653     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2654     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2655
2656     /* Win2k: MDI client still returns a just destroyed child as active
2657      * Win9x: MDI client returns 0
2658      */
2659     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2660     ok(active_child == mdi_child2 || /* win2k */
2661        !active_child, /* win9x */
2662        "wrong active MDI child %p\n", active_child);
2663     flush_sequence();
2664
2665     ShowWindow(mdi_child, SW_MAXIMIZE);
2666     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2667     flush_sequence();
2668
2669     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2670     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2671
2672     trace("re-creating maximized visible MDI child window 2\n");
2673     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2674                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
2675                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2676                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2677     assert(mdi_child2);
2678     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
2679     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
2680     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
2681
2682     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2683     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
2684
2685     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2686     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2687     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2688     flush_sequence();
2689
2690     SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
2691     ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
2692     ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
2693
2694     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
2695     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2696     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2697
2698     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2699     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2700     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2701     flush_sequence();
2702
2703     DestroyWindow(mdi_child);
2704     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2705
2706     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2707     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2708
2709     /* Win2k: MDI client still returns a just destroyed child as active
2710      * Win9x: MDI client returns 0
2711      */
2712     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2713     ok(active_child == mdi_child || /* win2k */
2714        !active_child, /* win9x */
2715        "wrong active MDI child %p\n", active_child);
2716     flush_sequence();
2717     /* end of test for maximized MDI children */
2718
2719     mdi_cs.szClass = "MDI_child_Class";
2720     mdi_cs.szTitle = "MDI child";
2721     mdi_cs.hOwner = GetModuleHandleA(0);
2722     mdi_cs.x = 0;
2723     mdi_cs.y = 0;
2724     mdi_cs.cx = CW_USEDEFAULT;
2725     mdi_cs.cy = CW_USEDEFAULT;
2726     mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
2727     mdi_cs.lParam = 0;
2728     mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
2729     ok(mdi_child != 0, "MDI child creation failed\n");
2730     ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
2731
2732     ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
2733
2734     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2735     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2736
2737     ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
2738     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2739     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2740
2741     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2742     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2743     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2744     flush_sequence();
2745
2746     SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
2747     ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
2748
2749     ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
2750     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2751     ok(!active_child, "wrong active MDI child %p\n", active_child);
2752
2753     SetFocus(0);
2754     flush_sequence();
2755
2756     DestroyWindow(mdi_client);
2757     ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
2758
2759     DestroyWindow(mdi_frame);
2760     ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
2761 }
2762 /************************* End of MDI test **********************************/
2763
2764 static void test_WM_SETREDRAW(HWND hwnd)
2765 {
2766     DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
2767
2768     flush_sequence();
2769
2770     SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
2771     ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
2772
2773     ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
2774     ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
2775
2776     flush_sequence();
2777     SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
2778     ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
2779
2780     ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
2781     ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
2782
2783     /* restore original WS_VISIBLE state */
2784     SetWindowLongA(hwnd, GWL_STYLE, style);
2785
2786     flush_sequence();
2787 }
2788
2789 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2790 {
2791     struct message msg;
2792
2793     trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
2794
2795     /* explicitly ignore WM_GETICON message */
2796     if (message == WM_GETICON) return 0;
2797
2798     switch (message)
2799     {
2800         case WM_WINDOWPOSCHANGING:
2801         case WM_WINDOWPOSCHANGED:
2802         {
2803             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2804
2805             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2806             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2807                   winpos->hwnd, winpos->hwndInsertAfter,
2808                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2809
2810             /* Log only documented flags, win2k uses 0x1000 and 0x2000
2811              * in the high word for internal purposes
2812              */
2813             wParam = winpos->flags & 0xffff;
2814             break;
2815         }
2816     }
2817
2818     msg.message = message;
2819     msg.flags = sent|wparam|lparam;
2820     msg.wParam = wParam;
2821     msg.lParam = lParam;
2822     add_message(&msg);
2823
2824     if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
2825     if (message == WM_TIMER) EndDialog( hwnd, 0 );
2826     return 0;
2827 }
2828
2829 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
2830 {
2831     DWORD style, exstyle;
2832     INT xmin, xmax;
2833     BOOL ret;
2834
2835     exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
2836     style = GetWindowLongA(hwnd, GWL_STYLE);
2837     /* do not be confused by WS_DLGFRAME set */
2838     if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
2839
2840     if (clear) ok(style & clear, "style %08lx should be set\n", clear);
2841     if (set) ok(!(style & set), "style %08lx should not be set\n", set);
2842
2843     ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
2844     ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
2845     if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
2846         ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
2847     else
2848         ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
2849
2850     style = GetWindowLongA(hwnd, GWL_STYLE);
2851     if (set) ok(style & set, "style %08lx should be set\n", set);
2852     if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
2853
2854     /* a subsequent call should do nothing */
2855     ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
2856     ok( ret, "SetScrollRange(%d) error %ld\n", ctl, GetLastError());
2857     ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
2858
2859     xmin = 0xdeadbeef;
2860     xmax = 0xdeadbeef;
2861     trace("Ignore GetScrollRange error below if you are on Win9x\n");
2862     ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
2863     ok( ret, "GetScrollRange(%d) error %ld\n", ctl, GetLastError());
2864     ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
2865     ok(xmin == min, "unexpected min scroll value %d\n", xmin);
2866     ok(xmax == max, "unexpected max scroll value %d\n", xmax);
2867 }
2868
2869 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
2870 {
2871     DWORD style, exstyle;
2872     SCROLLINFO si;
2873     BOOL ret;
2874
2875     exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
2876     style = GetWindowLongA(hwnd, GWL_STYLE);
2877     /* do not be confused by WS_DLGFRAME set */
2878     if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
2879
2880     if (clear) ok(style & clear, "style %08lx should be set\n", clear);
2881     if (set) ok(!(style & set), "style %08lx should not be set\n", set);
2882
2883     si.cbSize = sizeof(si);
2884     si.fMask = SIF_RANGE;
2885     si.nMin = min;
2886     si.nMax = max;
2887     SetScrollInfo(hwnd, ctl, &si, TRUE);
2888     if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
2889         ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
2890     else
2891         ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
2892
2893     style = GetWindowLongA(hwnd, GWL_STYLE);
2894     if (set) ok(style & set, "style %08lx should be set\n", set);
2895     if (clear) ok(!(style & clear), "style %08lx should not be set\n", clear);
2896
2897     /* a subsequent call should do nothing */
2898     SetScrollInfo(hwnd, ctl, &si, TRUE);
2899     if (style & WS_HSCROLL)
2900         ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2901     else if (style & WS_VSCROLL)
2902         ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2903     else
2904         ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2905
2906     si.fMask = SIF_PAGE;
2907     si.nPage = 5;
2908     SetScrollInfo(hwnd, ctl, &si, FALSE);
2909     ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2910
2911     si.fMask = SIF_POS;
2912     si.nPos = max - 1;
2913     SetScrollInfo(hwnd, ctl, &si, FALSE);
2914     ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
2915
2916     si.fMask = SIF_RANGE;
2917     si.nMin = 0xdeadbeef;
2918     si.nMax = 0xdeadbeef;
2919     ret = GetScrollInfo(hwnd, ctl, &si);
2920     ok( ret, "GetScrollInfo error %ld\n", GetLastError());
2921     ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
2922     ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
2923     ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
2924 }
2925
2926 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
2927 static void test_scroll_messages(HWND hwnd)
2928 {
2929     SCROLLINFO si;
2930     INT min, max;
2931     BOOL ret;
2932
2933     min = 0xdeadbeef;
2934     max = 0xdeadbeef;
2935     ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
2936     ok( ret, "GetScrollRange error %ld\n", GetLastError());
2937     if (sequence->message != WmGetScrollRangeSeq[0].message)
2938         trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2939     /* values of min and max are undefined */
2940     flush_sequence();
2941
2942     ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
2943     ok( ret, "SetScrollRange error %ld\n", GetLastError());
2944     if (sequence->message != WmSetScrollRangeSeq[0].message)
2945         trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2946     flush_sequence();
2947
2948     min = 0xdeadbeef;
2949     max = 0xdeadbeef;
2950     ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
2951     ok( ret, "GetScrollRange error %ld\n", GetLastError());
2952     if (sequence->message != WmGetScrollRangeSeq[0].message)
2953         trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
2954     /* values of min and max are undefined */
2955     flush_sequence();
2956
2957     si.cbSize = sizeof(si);
2958     si.fMask = SIF_RANGE;
2959     si.nMin = 20;
2960     si.nMax = 160;
2961     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2962     if (sequence->message != WmSetScrollRangeSeq[0].message)
2963         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2964     flush_sequence();
2965
2966     si.fMask = SIF_PAGE;
2967     si.nPage = 10;
2968     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2969     if (sequence->message != WmSetScrollRangeSeq[0].message)
2970         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2971     flush_sequence();
2972
2973     si.fMask = SIF_POS;
2974     si.nPos = 20;
2975     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
2976     if (sequence->message != WmSetScrollRangeSeq[0].message)
2977         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2978     flush_sequence();
2979
2980     si.fMask = SIF_RANGE;
2981     si.nMin = 0xdeadbeef;
2982     si.nMax = 0xdeadbeef;
2983     ret = GetScrollInfo(hwnd, SB_CTL, &si);
2984     ok( ret, "GetScrollInfo error %ld\n", GetLastError());
2985     if (sequence->message != WmGetScrollInfoSeq[0].message)
2986         trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
2987     /* values of min and max are undefined */
2988     flush_sequence();
2989
2990     /* set WS_HSCROLL */
2991     test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
2992     /* clear WS_HSCROLL */
2993     test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
2994
2995     /* set WS_HSCROLL */
2996     test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
2997     /* clear WS_HSCROLL */
2998     test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
2999
3000     /* set WS_VSCROLL */
3001     test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
3002     /* clear WS_VSCROLL */
3003     test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
3004
3005     /* set WS_VSCROLL */
3006     test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
3007     /* clear WS_VSCROLL */
3008     test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
3009 }
3010
3011 static void test_showwindow(void)
3012 {
3013     HWND hwnd, hchild;
3014     RECT rc;
3015
3016     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3017                            100, 100, 200, 200, 0, 0, 0, NULL);
3018     ok (hwnd != 0, "Failed to create overlapped window\n");
3019     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
3020                              0, 0, 10, 10, hwnd, 0, 0, NULL);
3021     ok (hchild != 0, "Failed to create child\n");
3022     flush_sequence();
3023
3024     /* ShowWindow( SW_SHOWNA) for invisible top level window */
3025     trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
3026     ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3027     ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", TRUE);
3028     trace("done\n");
3029
3030     /* ShowWindow( SW_SHOWNA) for now visible top level window */
3031     trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
3032     ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3033     ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
3034     trace("done\n");
3035     /* back to invisible */
3036     ShowWindow(hchild, SW_HIDE);
3037     ShowWindow(hwnd, SW_HIDE);
3038     flush_sequence();
3039     /* ShowWindow(SW_SHOWNA) with child and parent invisible */ 
3040     trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
3041     ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3042     ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
3043     trace("done\n");
3044     /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */ 
3045     ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
3046     flush_sequence();
3047     trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
3048     ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3049     ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
3050     trace("done\n");
3051     /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
3052     ShowWindow( hwnd, SW_SHOW);
3053     flush_sequence();
3054     trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
3055     ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3056     ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
3057     trace("done\n");
3058
3059     /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
3060     ShowWindow( hchild, SW_HIDE);
3061     flush_sequence();
3062     trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
3063     ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3064     ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
3065     trace("done\n");
3066
3067     SetCapture(hchild);
3068     ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
3069     DestroyWindow(hchild);
3070     ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
3071
3072     DestroyWindow(hwnd);
3073     flush_sequence();
3074
3075     /* Popup windows */
3076     /* Test 1:
3077      * 1. Create invisible maximized popup window.
3078      * 2. Move and resize it.
3079      * 3. Show it maximized.
3080      */
3081     trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3082     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
3083                            100, 100, 200, 200, 0, 0, 0, NULL);
3084     ok (hwnd != 0, "Failed to create popup window\n");
3085     ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3086     trace("done\n");
3087
3088     GetWindowRect(hwnd, &rc);
3089     ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
3090         rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
3091         "Invalid maximized size before ShowWindow (%ld,%ld)-(%ld,%ld)\n",
3092         rc.left, rc.top, rc.right, rc.bottom);
3093     /* Reset window's size & position */
3094     SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
3095     flush_sequence();
3096
3097     trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible popup window\n");
3098     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3099     ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
3100     trace("done\n");
3101
3102     GetWindowRect(hwnd, &rc);
3103     ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
3104         rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
3105         "Invalid maximized size after ShowWindow (%ld,%ld)-(%ld,%ld)\n",
3106         rc.left, rc.top, rc.right, rc.bottom);
3107     DestroyWindow(hwnd);
3108     flush_sequence();
3109
3110     /* Test 2:
3111      * 1. Create invisible maximized popup window.
3112      * 2. Show it maximized.
3113      */
3114     trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3115     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
3116                            100, 100, 200, 200, 0, 0, 0, NULL);
3117     ok (hwnd != 0, "Failed to create popup window\n");
3118     ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3119     trace("done\n");
3120
3121     trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible popup window\n");
3122     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3123     ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
3124     trace("done\n");
3125     DestroyWindow(hwnd);
3126     flush_sequence();
3127
3128     /* Test 3:
3129      * 1. Create visible maximized popup window.
3130      */
3131     trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
3132     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
3133                            100, 100, 200, 200, 0, 0, 0, NULL);
3134     ok (hwnd != 0, "Failed to create popup window\n");
3135     ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3136     trace("done\n");
3137     DestroyWindow(hwnd);
3138     flush_sequence();
3139
3140     /* Test 4:
3141      * 1. Create visible popup window.
3142      * 2. Maximize it.
3143      */
3144     trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
3145     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
3146                            100, 100, 200, 200, 0, 0, 0, NULL);
3147     ok (hwnd != 0, "Failed to create popup window\n");
3148     ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", TRUE);
3149     trace("done\n");
3150
3151     trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
3152     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3153     ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", TRUE);
3154     trace("done\n");
3155     DestroyWindow(hwnd);
3156     flush_sequence();
3157 }
3158
3159 static void test_sys_menu(HWND hwnd)
3160 {
3161     HMENU hmenu;
3162     UINT state;
3163
3164     /* test existing window without CS_NOCLOSE style */
3165     hmenu = GetSystemMenu(hwnd, FALSE);
3166     ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
3167
3168     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3169     ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3170     ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
3171
3172     EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
3173     ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
3174
3175     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3176     ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3177     ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
3178
3179     EnableMenuItem(hmenu, SC_CLOSE, 0);
3180     ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
3181
3182     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3183     ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3184     ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
3185
3186     /* test new window with CS_NOCLOSE style */
3187     hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
3188                            100, 100, 200, 200, 0, 0, 0, NULL);
3189     ok (hwnd != 0, "Failed to create overlapped window\n");
3190
3191     hmenu = GetSystemMenu(hwnd, FALSE);
3192     ok(hmenu != 0, "GetSystemMenu error %ld\n", GetLastError());
3193
3194     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3195     ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3196
3197     DestroyWindow(hwnd);
3198 }
3199
3200 /* test if we receive the right sequence of messages */
3201 static void test_messages(void)
3202 {
3203     HWND hwnd, hparent, hchild;
3204     HWND hchild2, hbutton;
3205     HMENU hmenu;
3206     MSG msg;
3207     DWORD ret;
3208
3209     flush_sequence();
3210
3211     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3212                            100, 100, 200, 200, 0, 0, 0, NULL);
3213     ok (hwnd != 0, "Failed to create overlapped window\n");
3214     ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
3215
3216     /* test ShowWindow(SW_HIDE) on a newly created invisible window */
3217     ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
3218     ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
3219
3220     /* test WM_SETREDRAW on a not visible top level window */
3221     test_WM_SETREDRAW(hwnd);
3222
3223     SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3224     ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
3225     ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
3226
3227     ok(GetActiveWindow() == hwnd, "window should be active\n");
3228     ok(GetFocus() == hwnd, "window should have input focus\n");
3229     ShowWindow(hwnd, SW_HIDE);
3230     ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", TRUE);
3231
3232     ShowWindow(hwnd, SW_SHOW);
3233     ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
3234
3235     ShowWindow(hwnd, SW_HIDE);
3236     ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
3237
3238     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3239     ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
3240
3241     ShowWindow(hwnd, SW_RESTORE);
3242     /* FIXME: add ok_sequence() here */
3243     flush_sequence();
3244
3245     ShowWindow(hwnd, SW_SHOW);
3246     ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
3247
3248     ok(GetActiveWindow() == hwnd, "window should be active\n");
3249     ok(GetFocus() == hwnd, "window should have input focus\n");
3250     SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3251     ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
3252     ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
3253     ok(GetActiveWindow() == hwnd, "window should still be active\n");
3254
3255     /* test WM_SETREDRAW on a visible top level window */
3256     ShowWindow(hwnd, SW_SHOW);
3257     test_WM_SETREDRAW(hwnd);
3258
3259     trace("testing scroll APIs on a visible top level window %p\n", hwnd);
3260     test_scroll_messages(hwnd);
3261
3262     /* test resizing and moving */
3263     SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE );
3264     ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
3265     SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE );
3266     ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
3267
3268     /* popups don't get WM_GETMINMAXINFO */
3269     SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
3270     SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
3271     flush_sequence();
3272     SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE );
3273     ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
3274
3275     test_sys_menu(hwnd);
3276
3277     flush_sequence();
3278     DestroyWindow(hwnd);
3279     ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
3280
3281     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
3282                               100, 100, 200, 200, 0, 0, 0, NULL);
3283     ok (hparent != 0, "Failed to create parent window\n");
3284     flush_sequence();
3285
3286     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
3287                              0, 0, 10, 10, hparent, 0, 0, NULL);
3288     ok (hchild != 0, "Failed to create child window\n");
3289     ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", TRUE);
3290     DestroyWindow(hchild);
3291     flush_sequence();
3292
3293     /* visible child window with a caption */
3294     hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
3295                              WS_CHILD | WS_VISIBLE | WS_CAPTION,
3296                              0, 0, 10, 10, hparent, 0, 0, NULL);
3297     ok (hchild != 0, "Failed to create child window\n");
3298     ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
3299
3300     trace("testing scroll APIs on a visible child window %p\n", hchild);
3301     test_scroll_messages(hchild);
3302
3303     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3304     ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
3305
3306     DestroyWindow(hchild);
3307     flush_sequence();
3308
3309     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
3310                              0, 0, 10, 10, hparent, 0, 0, NULL);
3311     ok (hchild != 0, "Failed to create child window\n");
3312     ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
3313     
3314     hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
3315                                100, 100, 50, 50, hparent, 0, 0, NULL);
3316     ok (hchild2 != 0, "Failed to create child2 window\n");
3317     flush_sequence();
3318
3319     hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
3320                               0, 100, 50, 50, hchild, 0, 0, NULL);
3321     ok (hbutton != 0, "Failed to create button window\n");
3322
3323     /* test WM_SETREDRAW on a not visible child window */
3324     test_WM_SETREDRAW(hchild);
3325
3326     ShowWindow(hchild, SW_SHOW);
3327     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
3328
3329     ShowWindow(hchild, SW_HIDE);
3330     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
3331
3332     ShowWindow(hchild, SW_SHOW);
3333     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
3334
3335     /* test WM_SETREDRAW on a visible child window */
3336     test_WM_SETREDRAW(hchild);
3337
3338     MoveWindow(hchild, 10, 10, 20, 20, TRUE);
3339     ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
3340
3341     ShowWindow(hchild, SW_HIDE);
3342     flush_sequence();
3343     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3344     ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
3345
3346     ShowWindow(hchild, SW_HIDE);
3347     flush_sequence();
3348     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
3349     ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
3350
3351     /* DestroyWindow sequence below expects that a child has focus */
3352     SetFocus(hchild);
3353     flush_sequence();
3354
3355     DestroyWindow(hchild);
3356     ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
3357     DestroyWindow(hchild2);
3358     DestroyWindow(hbutton);
3359
3360     flush_sequence();
3361     hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
3362                              0, 0, 100, 100, hparent, 0, 0, NULL);
3363     ok (hchild != 0, "Failed to create child popup window\n");
3364     ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
3365     DestroyWindow(hchild);
3366
3367     /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
3368     flush_sequence();
3369     hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
3370                              0, 0, 100, 100, hparent, 0, 0, NULL);
3371     ok (hchild != 0, "Failed to create popup window\n");
3372     ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
3373     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3374     ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
3375     flush_sequence();
3376     ShowWindow(hchild, SW_SHOW);
3377     ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
3378     flush_sequence();
3379     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
3380     ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
3381     flush_sequence();
3382     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3383     ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", FALSE);
3384     DestroyWindow(hchild);
3385
3386     /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
3387      * changes nothing in message sequences.
3388      */
3389     flush_sequence();
3390     hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
3391                              0, 0, 100, 100, hparent, 0, 0, NULL);
3392     ok (hchild != 0, "Failed to create popup window\n");
3393     ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
3394     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3395     ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
3396     flush_sequence();
3397     ShowWindow(hchild, SW_SHOW);
3398     ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
3399     flush_sequence();
3400     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
3401     ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
3402     DestroyWindow(hchild);
3403
3404     flush_sequence();
3405     hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
3406                            0, 0, 100, 100, hparent, 0, 0, NULL);
3407     ok(hwnd != 0, "Failed to create custom dialog window\n");
3408     ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
3409
3410     /*
3411     trace("testing scroll APIs on a visible dialog %p\n", hwnd);
3412     test_scroll_messages(hwnd);
3413     */
3414
3415     flush_sequence();
3416     after_end_dialog = 1;
3417     EndDialog( hwnd, 0 );
3418     ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
3419
3420     DestroyWindow(hwnd);
3421     after_end_dialog = 0;
3422
3423     hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP,
3424                            0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
3425     ok(hwnd != 0, "Failed to create custom dialog window\n");
3426     flush_sequence();
3427     trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
3428     ShowWindow(hwnd, SW_SHOW);
3429     ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
3430     DestroyWindow(hwnd);
3431
3432     flush_sequence();
3433     DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
3434     ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
3435
3436     /* test showing child with hidden parent */
3437     ShowWindow( hparent, SW_HIDE );
3438     flush_sequence();
3439
3440     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
3441                              0, 0, 10, 10, hparent, 0, 0, NULL);
3442     ok (hchild != 0, "Failed to create child window\n");
3443     ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
3444
3445     ShowWindow( hchild, SW_SHOW );
3446     ok_sequence(WmShowChildInvisibleParentSeq, "ShowWindow:show child with invisible parent", FALSE);
3447     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3448     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
3449
3450     ShowWindow( hchild, SW_HIDE );
3451     ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
3452     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
3453     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
3454
3455     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
3456     ok_sequence(WmShowChildInvisibleParentSeq_2, "SetWindowPos:show child with invisible parent", FALSE);
3457     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3458     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
3459
3460     SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
3461     ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
3462     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
3463     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
3464
3465     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
3466     flush_sequence();
3467     DestroyWindow(hchild);
3468     ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
3469
3470     DestroyWindow(hparent);
3471     flush_sequence();
3472
3473     /* Message sequence for SetMenu */
3474     ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
3475     ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
3476
3477     hmenu = CreateMenu();
3478     ok (hmenu != 0, "Failed to create menu\n");
3479     ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
3480     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3481                            100, 100, 200, 200, 0, hmenu, 0, NULL);
3482     ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
3483     ok (SetMenu(hwnd, 0), "SetMenu\n");
3484     ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
3485     ok (SetMenu(hwnd, 0), "SetMenu\n");
3486     ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
3487     ShowWindow(hwnd, SW_SHOW);
3488     UpdateWindow( hwnd );
3489     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3490     flush_sequence();
3491     ok (SetMenu(hwnd, 0), "SetMenu\n");
3492     ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
3493     ok (SetMenu(hwnd, hmenu), "SetMenu\n");
3494     ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
3495
3496     UpdateWindow( hwnd );
3497     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3498     flush_sequence();
3499     ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
3500     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3501     ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
3502
3503     DestroyWindow(hwnd);
3504     flush_sequence();
3505
3506     /* Message sequence for EnableWindow */
3507     hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
3508                               100, 100, 200, 200, 0, 0, 0, NULL);
3509     ok (hparent != 0, "Failed to create parent window\n");
3510     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
3511                              0, 0, 10, 10, hparent, 0, 0, NULL);
3512     ok (hchild != 0, "Failed to create child window\n");
3513
3514     SetFocus(hchild);
3515     flush_sequence();
3516
3517     EnableWindow(hparent, FALSE);
3518     ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
3519
3520     EnableWindow(hparent, TRUE);
3521     ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
3522
3523     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3524     flush_sequence();
3525
3526     /* MsgWaitForMultipleObjects test */
3527     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3528     ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
3529
3530     PostMessageA(hparent, WM_USER, 0, 0);
3531
3532     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3533     ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %lx\n", ret);
3534
3535     ok(PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
3536     ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
3537
3538     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3539     ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %lx\n", ret);
3540     /* end of MsgWaitForMultipleObjects test */
3541
3542     /* the following test causes an exception in user.exe under win9x */
3543     if (!PostMessageW( hparent, WM_USER, 0, 0 )) return;
3544     PostMessageW( hparent, WM_USER+1, 0, 0 );
3545     /* PeekMessage(NULL) fails, but still removes the message */
3546     SetLastError(0xdeadbeef);
3547     ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
3548     ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
3549         GetLastError() == 0xdeadbeef, /* NT4 */
3550         "last error is %ld\n", GetLastError() );
3551     ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
3552     ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
3553
3554     DestroyWindow(hchild);
3555     DestroyWindow(hparent);
3556     flush_sequence();
3557
3558     test_showwindow();
3559 }
3560
3561 /****************** button message test *************************/
3562 static const struct message WmSetFocusButtonSeq[] =
3563 {
3564     { HCBT_SETFOCUS, hook },
3565     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3566     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3567     { WM_SETFOCUS, sent|wparam, 0 },
3568     { WM_CTLCOLORBTN, sent|defwinproc },
3569     { 0 }
3570 };
3571 static const struct message WmKillFocusButtonSeq[] =
3572 {
3573     { HCBT_SETFOCUS, hook },
3574     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3575     { WM_KILLFOCUS, sent|wparam, 0 },
3576     { WM_CTLCOLORBTN, sent|defwinproc },
3577     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3578     { 0 }
3579 };
3580 static const struct message WmSetFocusStaticSeq[] =
3581 {
3582     { HCBT_SETFOCUS, hook },
3583     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
3584     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3585     { WM_SETFOCUS, sent|wparam, 0 },
3586     { WM_CTLCOLORSTATIC, sent|defwinproc },
3587     { 0 }
3588 };
3589 static const struct message WmKillFocusStaticSeq[] =
3590 {
3591     { HCBT_SETFOCUS, hook },
3592     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3593     { WM_KILLFOCUS, sent|wparam, 0 },
3594     { WM_CTLCOLORSTATIC, sent|defwinproc },
3595     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
3596     { 0 }
3597 };
3598 static const struct message WmLButtonDownSeq[] =
3599 {
3600     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
3601     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
3602     { HCBT_SETFOCUS, hook },
3603     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
3604     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3605     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
3606     { WM_CTLCOLORBTN, sent|defwinproc },
3607     { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
3608     { WM_CTLCOLORBTN, sent|defwinproc },
3609     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3610     { 0 }
3611 };
3612 static const struct message WmLButtonUpSeq[] =
3613 {
3614     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
3615     { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
3616     { WM_CTLCOLORBTN, sent|defwinproc },
3617     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
3618     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
3619     { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
3620     { 0 }
3621 };
3622
3623 static WNDPROC old_button_proc;
3624
3625 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3626 {
3627     static long defwndproc_counter = 0;
3628     LRESULT ret;
3629     struct message msg;
3630
3631     trace("button: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
3632
3633     /* explicitly ignore WM_GETICON message */
3634     if (message == WM_GETICON) return 0;
3635
3636     msg.message = message;
3637     msg.flags = sent|wparam|lparam;
3638     if (defwndproc_counter) msg.flags |= defwinproc;
3639     msg.wParam = wParam;
3640     msg.lParam = lParam;
3641     add_message(&msg);
3642
3643     if (message == BM_SETSTATE)
3644         ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
3645
3646     defwndproc_counter++;
3647     ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
3648     defwndproc_counter--;
3649
3650     return ret;
3651 }
3652
3653 static void subclass_button(void)
3654 {
3655     WNDCLASSA cls;
3656
3657     if (!GetClassInfoA(0, "button", &cls)) assert(0);
3658
3659     old_button_proc = cls.lpfnWndProc;
3660
3661     cls.hInstance = GetModuleHandle(0);
3662     cls.lpfnWndProc = button_hook_proc;
3663     cls.lpszClassName = "my_button_class";
3664     if (!RegisterClassA(&cls)) assert(0);
3665 }
3666
3667 static void test_button_messages(void)
3668 {
3669     static const struct
3670     {
3671         DWORD style;
3672         DWORD dlg_code;
3673         const struct message *setfocus;
3674         const struct message *killfocus;
3675     } button[] = {
3676         { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
3677           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
3678         { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
3679           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
3680         { BS_CHECKBOX, DLGC_BUTTON,
3681           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3682         { BS_AUTOCHECKBOX, DLGC_BUTTON,
3683           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3684         { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
3685           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3686         { BS_3STATE, DLGC_BUTTON,
3687           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3688         { BS_AUTO3STATE, DLGC_BUTTON,
3689           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3690         { BS_GROUPBOX, DLGC_STATIC,
3691           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3692         { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
3693           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
3694         { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
3695           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
3696         { BS_OWNERDRAW, DLGC_BUTTON,
3697           WmSetFocusButtonSeq, WmKillFocusButtonSeq }
3698     };
3699     unsigned int i;
3700     HWND hwnd;
3701     DWORD dlg_code;
3702
3703     subclass_button();
3704
3705     for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
3706     {
3707         hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
3708                                0, 0, 50, 14, 0, 0, 0, NULL);
3709         ok(hwnd != 0, "Failed to create button window\n");
3710
3711         dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
3712         ok(dlg_code == button[i].dlg_code, "%d: wrong dlg_code %08lx\n", i, dlg_code);
3713
3714         ShowWindow(hwnd, SW_SHOW);
3715         UpdateWindow(hwnd);
3716         SetFocus(0);
3717         flush_sequence();
3718
3719         trace("button style %08lx\n", button[i].style);
3720         SetFocus(hwnd);
3721         ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
3722
3723         SetFocus(0);
3724         ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
3725
3726         DestroyWindow(hwnd);
3727     }
3728
3729     hwnd = CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON | WS_POPUP | WS_VISIBLE,
3730                            0, 0, 50, 14, 0, 0, 0, NULL);
3731     ok(hwnd != 0, "Failed to create button window\n");
3732
3733     SetFocus(0);
3734     flush_sequence();
3735
3736     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
3737     ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
3738
3739     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
3740     ok_sequence(WmLButtonUpSeq, "WM_LBUTTONUP on a button", FALSE);
3741     DestroyWindow(hwnd);
3742 }
3743
3744 /************* painting message test ********************/
3745
3746 void dump_region(HRGN hrgn)
3747 {
3748     DWORD i, size;
3749     RGNDATA *data = NULL;
3750     RECT *rect;
3751
3752     if (!hrgn)
3753     {
3754         printf( "null region\n" );
3755         return;
3756     }
3757     if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
3758     if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
3759     GetRegionData( hrgn, size, data );
3760     printf("%ld rects:", data->rdh.nCount );
3761     for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
3762         printf( " (%ld,%ld)-(%ld,%ld)", rect->left, rect->top, rect->right, rect->bottom );
3763     printf("\n");
3764     HeapFree( GetProcessHeap(), 0, data );
3765 }
3766
3767 static void check_update_rgn( HWND hwnd, HRGN hrgn )
3768 {
3769     INT ret;
3770     RECT r1, r2;
3771     HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
3772     HRGN update = CreateRectRgn( 0, 0, 0, 0 );
3773
3774     ret = GetUpdateRgn( hwnd, update, FALSE );
3775     ok( ret != ERROR, "GetUpdateRgn failed\n" );
3776     if (ret == NULLREGION)
3777     {
3778         ok( !hrgn, "Update region shouldn't be empty\n" );
3779     }
3780     else
3781     {
3782         if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
3783         {
3784             ok( 0, "Regions are different\n" );
3785             if (winetest_debug > 0)
3786             {
3787                 printf( "Update region: " );
3788                 dump_region( update );
3789                 printf( "Wanted region: " );
3790                 dump_region( hrgn );
3791             }
3792         }
3793     }
3794     GetRgnBox( update, &r1 );
3795     GetUpdateRect( hwnd, &r2, FALSE );
3796     ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
3797         "Rectangles are different: %ld,%ld-%ld,%ld / %ld,%ld-%ld,%ld\n",
3798         r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
3799
3800     DeleteObject( tmp );
3801     DeleteObject( update );
3802 }
3803
3804 static const struct message WmInvalidateRgn[] = {
3805     { WM_NCPAINT, sent },
3806     { WM_GETTEXT, sent|defwinproc|optional },
3807     { 0 }
3808 };
3809
3810 static const struct message WmGetUpdateRect[] = {
3811     { WM_NCPAINT, sent },
3812     { WM_GETTEXT, sent|defwinproc|optional },
3813     { WM_PAINT, sent },
3814     { 0 }
3815 };
3816
3817 static const struct message WmInvalidateFull[] = {
3818     { WM_NCPAINT, sent|wparam, 1 },
3819     { WM_GETTEXT, sent|defwinproc|optional },
3820     { 0 }
3821 };
3822
3823 static const struct message WmInvalidateErase[] = {
3824     { WM_NCPAINT, sent|wparam, 1 },
3825     { WM_GETTEXT, sent|defwinproc|optional },
3826     { WM_ERASEBKGND, sent },
3827     { 0 }
3828 };
3829
3830 static const struct message WmInvalidatePaint[] = {
3831     { WM_PAINT, sent },
3832     { WM_NCPAINT, sent|wparam|beginpaint, 1 },
3833     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3834     { 0 }
3835 };
3836
3837 static const struct message WmInvalidateErasePaint[] = {
3838     { WM_PAINT, sent },
3839     { WM_NCPAINT, sent|wparam|beginpaint, 1 },
3840     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3841     { WM_ERASEBKGND, sent|beginpaint },
3842     { 0 }
3843 };
3844
3845 static const struct message WmInvalidateErasePaint2[] = {
3846     { WM_PAINT, sent },
3847     { WM_NCPAINT, sent|beginpaint },
3848     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3849     { WM_ERASEBKGND, sent|beginpaint },
3850     { 0 }
3851 };
3852
3853 static const struct message WmErase[] = {
3854     { WM_ERASEBKGND, sent },
3855     { 0 }
3856 };
3857
3858 static const struct message WmPaint[] = {
3859     { WM_PAINT, sent },
3860     { 0 }
3861 };
3862
3863 static const struct message WmParentOnlyPaint[] = {
3864     { WM_PAINT, sent|parent },
3865     { 0 }
3866 };
3867
3868 static const struct message WmInvalidateParent[] = {
3869     { WM_NCPAINT, sent|parent },
3870     { WM_GETTEXT, sent|defwinproc|parent|optional },
3871     { WM_ERASEBKGND, sent|parent },
3872     { 0 }
3873 };
3874
3875 static const struct message WmInvalidateParentChild[] = {
3876     { WM_NCPAINT, sent|parent },
3877     { WM_GETTEXT, sent|defwinproc|parent|optional },
3878     { WM_ERASEBKGND, sent|parent },
3879     { WM_NCPAINT, sent },
3880     { WM_GETTEXT, sent|defwinproc|optional },
3881     { WM_ERASEBKGND, sent },
3882     { 0 }
3883 };
3884
3885 static const struct message WmInvalidateParentChild2[] = {
3886     { WM_ERASEBKGND, sent|parent },
3887     { WM_NCPAINT, sent },
3888     { WM_GETTEXT, sent|defwinproc|optional },
3889     { WM_ERASEBKGND, sent },
3890     { 0 }
3891 };
3892
3893 static const struct message WmParentPaint[] = {
3894     { WM_PAINT, sent|parent },
3895     { WM_PAINT, sent },
3896     { 0 }
3897 };
3898
3899 static const struct message WmParentPaintNc[] = {
3900     { WM_PAINT, sent|parent },
3901     { WM_PAINT, sent },
3902     { WM_NCPAINT, sent|beginpaint },
3903     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3904     { WM_ERASEBKGND, sent|beginpaint },
3905     { 0 }
3906 };
3907
3908 static const struct message WmChildPaintNc[] = {
3909     { WM_PAINT, sent },
3910     { WM_NCPAINT, sent|beginpaint },
3911     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3912     { WM_ERASEBKGND, sent|beginpaint },
3913     { 0 }
3914 };
3915
3916 static const struct message WmParentErasePaint[] = {
3917     { WM_PAINT, sent|parent },
3918     { WM_NCPAINT, sent|parent|beginpaint },
3919     { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
3920     { WM_ERASEBKGND, sent|parent|beginpaint },
3921     { WM_PAINT, sent },
3922     { WM_NCPAINT, sent|beginpaint },
3923     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
3924     { WM_ERASEBKGND, sent|beginpaint },
3925     { 0 }
3926 };
3927
3928 static const struct message WmParentOnlyNcPaint[] = {
3929     { WM_PAINT, sent|parent },
3930     { WM_NCPAINT, sent|parent|beginpaint },
3931     { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
3932     { 0 }
3933 };
3934
3935 static const struct message WmSetParentStyle[] = {
3936     { WM_STYLECHANGING, sent|parent },
3937     { WM_STYLECHANGED, sent|parent },
3938     { 0 }
3939 };
3940
3941 static void test_paint_messages(void)
3942 {
3943     BOOL ret;
3944     RECT rect;
3945     POINT pt;
3946     MSG msg;
3947     HWND hparent, hchild;
3948     HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
3949     HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
3950     HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3951                                 100, 100, 200, 200, 0, 0, 0, NULL);
3952     ok (hwnd != 0, "Failed to create overlapped window\n");
3953
3954     ShowWindow( hwnd, SW_SHOW );
3955     UpdateWindow( hwnd );
3956     flush_events();
3957
3958     check_update_rgn( hwnd, 0 );
3959     SetRectRgn( hrgn, 10, 10, 20, 20 );
3960     ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
3961     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
3962     check_update_rgn( hwnd, hrgn );
3963     SetRectRgn( hrgn2, 20, 20, 30, 30 );
3964     ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
3965     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
3966     CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
3967     check_update_rgn( hwnd, hrgn );
3968     /* validate everything */
3969     ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
3970     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
3971     check_update_rgn( hwnd, 0 );
3972
3973     /* test empty region */
3974     SetRectRgn( hrgn, 10, 10, 10, 15 );
3975     ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
3976     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
3977     check_update_rgn( hwnd, 0 );
3978     /* test empty rect */
3979     SetRect( &rect, 10, 10, 10, 15 );
3980     ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
3981     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
3982     check_update_rgn( hwnd, 0 );
3983
3984     /* flush pending messages */
3985     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3986     flush_sequence();
3987
3988     GetClientRect( hwnd, &rect );
3989     SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
3990     /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
3991      * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
3992      */
3993     trace("testing InvalidateRect(0, NULL, FALSE)\n");
3994     SetRectEmpty( &rect );
3995     ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
3996     check_update_rgn( hwnd, hrgn );
3997     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
3998     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
3999     ok_sequence( WmPaint, "Paint", FALSE );
4000     RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
4001     check_update_rgn( hwnd, 0 );
4002
4003     /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
4004      * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
4005      */
4006     trace("testing ValidateRect(0, NULL)\n");
4007     SetRectEmpty( &rect );
4008     ok(ValidateRect(0, &rect), "ValidateRect(0, &rc) should not fail\n");
4009     check_update_rgn( hwnd, hrgn );
4010     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
4011     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4012     ok_sequence( WmPaint, "Paint", FALSE );
4013     RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
4014     check_update_rgn( hwnd, 0 );
4015
4016     trace("testing InvalidateRgn(0, NULL, FALSE)\n");
4017     SetLastError(0xdeadbeef);
4018     ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
4019     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %ld\n", GetLastError());
4020     check_update_rgn( hwnd, 0 );
4021     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4022     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
4023
4024     trace("testing ValidateRgn(0, NULL)\n");
4025     SetLastError(0xdeadbeef);
4026     ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
4027     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %ld\n", GetLastError());
4028     check_update_rgn( hwnd, 0 );
4029     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4030     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
4031
4032     /* now with frame */
4033     SetRectRgn( hrgn, -5, -5, 20, 20 );
4034
4035     /* flush pending messages */
4036     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4037
4038     flush_sequence();
4039     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
4040     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
4041
4042     SetRectRgn( hrgn, 0, 0, 20, 20 );  /* GetUpdateRgn clips to client area */
4043     check_update_rgn( hwnd, hrgn );
4044
4045     flush_sequence();
4046     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
4047     ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
4048
4049     flush_sequence();
4050     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
4051     ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
4052
4053     GetClientRect( hwnd, &rect );
4054     SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
4055     check_update_rgn( hwnd, hrgn );
4056
4057     flush_sequence();
4058     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
4059     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
4060
4061     flush_sequence();
4062     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
4063     ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
4064     check_update_rgn( hwnd, 0 );
4065
4066     flush_sequence();
4067     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
4068     ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
4069     check_update_rgn( hwnd, 0 );
4070
4071     flush_sequence();
4072     SetRectRgn( hrgn, 0, 0, 100, 100 );
4073     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
4074     SetRectRgn( hrgn, 0, 0, 50, 100 );
4075     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
4076     SetRectRgn( hrgn, 50, 0, 100, 100 );
4077     check_update_rgn( hwnd, hrgn );
4078     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
4079     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );  /* must not generate messages, everything is valid */
4080     check_update_rgn( hwnd, 0 );
4081
4082     flush_sequence();
4083     SetRectRgn( hrgn, 0, 0, 100, 100 );
4084     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
4085     SetRectRgn( hrgn, 0, 0, 100, 50 );
4086     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
4087     ok_sequence( WmErase, "Erase", FALSE );
4088     SetRectRgn( hrgn, 0, 50, 100, 100 );
4089     check_update_rgn( hwnd, hrgn );
4090
4091     flush_sequence();
4092     SetRectRgn( hrgn, 0, 0, 100, 100 );
4093     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
4094     SetRectRgn( hrgn, 0, 0, 50, 50 );
4095     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
4096     ok_sequence( WmPaint, "Paint", FALSE );
4097
4098     flush_sequence();
4099     SetRectRgn( hrgn, -4, -4, -2, -2 );
4100     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
4101     SetRectRgn( hrgn, -200, -200, -198, -198 );
4102     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
4103     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
4104
4105     flush_sequence();
4106     SetRectRgn( hrgn, -4, -4, -2, -2 );
4107     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
4108     SetRectRgn( hrgn, -4, -4, -3, -3 );
4109     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
4110     SetRectRgn( hrgn, 0, 0, 1, 1 );
4111     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
4112     ok_sequence( WmPaint, "Paint", FALSE );
4113
4114     flush_sequence();
4115     SetRectRgn( hrgn, -4, -4, -1, -1 );
4116     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
4117     RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
4118     /* make sure no WM_PAINT was generated */
4119     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4120     ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
4121
4122     flush_sequence();
4123     SetRectRgn( hrgn, -4, -4, -1, -1 );
4124     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
4125     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
4126     {
4127         if (msg.hwnd == hwnd && msg.message == WM_PAINT)
4128         {
4129             /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
4130             INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
4131             ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
4132             ret = GetUpdateRect( hwnd, &rect, FALSE );
4133             ok( ret, "Invalid GetUpdateRect result %d\n", ret );
4134             /* this will send WM_NCPAINT and validate the non client area */
4135             ret = GetUpdateRect( hwnd, &rect, TRUE );
4136             ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
4137         }
4138         DispatchMessage( &msg );
4139     }
4140     ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
4141
4142     DestroyWindow( hwnd );
4143
4144     /* now test with a child window */
4145
4146     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
4147                               100, 100, 200, 200, 0, 0, 0, NULL);
4148     ok (hparent != 0, "Failed to create parent window\n");
4149
4150     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
4151                            10, 10, 100, 100, hparent, 0, 0, NULL);
4152     ok (hchild != 0, "Failed to create child window\n");
4153
4154     ShowWindow( hparent, SW_SHOW );
4155     UpdateWindow( hparent );
4156     UpdateWindow( hchild );
4157     flush_events();
4158     flush_sequence();
4159     log_all_parent_messages++;
4160
4161     SetRect( &rect, 0, 0, 50, 50 );
4162     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4163     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
4164     ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
4165
4166     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4167     pt.x = pt.y = 0;
4168     MapWindowPoints( hchild, hparent, &pt, 1 );
4169     SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
4170     check_update_rgn( hchild, hrgn );
4171     SetRectRgn( hrgn, 0, 0, 50, 50 );
4172     check_update_rgn( hparent, hrgn );
4173     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
4174     ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
4175     RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
4176     ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
4177
4178     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4179     ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
4180
4181     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
4182     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
4183     ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
4184     RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
4185     ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
4186
4187     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
4188     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
4189     ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
4190
4191     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
4192     flush_sequence();
4193     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
4194     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
4195     ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
4196
4197     /* flush all paint messages */
4198     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4199     flush_sequence();
4200
4201     /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
4202     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
4203     SetRectRgn( hrgn, 0, 0, 50, 50 );
4204     check_update_rgn( hparent, hrgn );
4205     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
4206     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
4207     SetRectRgn( hrgn, 0, 0, 50, 50 );
4208     check_update_rgn( hparent, hrgn );
4209
4210     /* flush all paint messages */
4211     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4212     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
4213     flush_sequence();
4214
4215     /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
4216     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4217     SetRectRgn( hrgn, 0, 0, 50, 50 );
4218     check_update_rgn( hparent, hrgn );
4219     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
4220     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
4221     SetRectRgn( hrgn2, 10, 10, 50, 50 );
4222     CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
4223     check_update_rgn( hparent, hrgn );
4224     /* flush all paint messages */
4225     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4226     flush_sequence();
4227
4228     /* same as above but parent gets completely validated */
4229     SetRect( &rect, 20, 20, 30, 30 );
4230     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4231     SetRectRgn( hrgn, 20, 20, 30, 30 );
4232     check_update_rgn( hparent, hrgn );
4233     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
4234     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
4235     check_update_rgn( hparent, 0 );  /* no update region */
4236     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4237     ok_sequence( WmEmptySeq, "WmEmpty", FALSE );  /* and no paint messages */
4238
4239     /* make sure RDW_VALIDATE on child doesn't have the same effect */
4240     flush_sequence();
4241     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4242     SetRectRgn( hrgn, 20, 20, 30, 30 );
4243     check_update_rgn( hparent, hrgn );
4244     RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
4245     SetRectRgn( hrgn, 20, 20, 30, 30 );
4246     check_update_rgn( hparent, hrgn );
4247
4248     /* same as above but normal WM_PAINT doesn't validate parent */
4249     flush_sequence();
4250     SetRect( &rect, 20, 20, 30, 30 );
4251     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4252     SetRectRgn( hrgn, 20, 20, 30, 30 );
4253     check_update_rgn( hparent, hrgn );
4254     /* no WM_PAINT in child while parent still pending */
4255     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4256     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
4257     while (PeekMessage( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4258     ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
4259
4260     flush_sequence();
4261     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4262     /* no WM_PAINT in child while parent still pending */
4263     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4264     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
4265     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
4266     /* now that parent is valid child should get WM_PAINT */
4267     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4268     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
4269     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4270     ok_sequence( WmEmptySeq, "No other message", FALSE );
4271
4272     /* same thing with WS_CLIPCHILDREN in parent */
4273     flush_sequence();
4274     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
4275     ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
4276     /* changing style invalidates non client area, but we need to invalidate something else to see it */
4277     RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
4278     ok_sequence( WmEmptySeq, "No message", FALSE );
4279     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
4280     ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
4281
4282     flush_sequence();
4283     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
4284     SetRectRgn( hrgn, 20, 20, 30, 30 );
4285     check_update_rgn( hparent, hrgn );
4286     /* no WM_PAINT in child while parent still pending */
4287     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4288     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
4289     /* WM_PAINT in parent first */
4290     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4291     ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
4292
4293     /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
4294     flush_sequence();
4295     SetRect( &rect, 0, 0, 30, 30 );
4296     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
4297     SetRectRgn( hrgn, 0, 0, 30, 30 );
4298     check_update_rgn( hparent, hrgn );
4299     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4300     ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
4301
4302     /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
4303     flush_sequence();
4304     SetRect( &rect, -10, 0, 30, 30 );
4305     RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
4306     SetRect( &rect, 0, 0, 20, 20 );
4307     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
4308     RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
4309     ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
4310
4311     /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
4312     flush_sequence();
4313     SetRect( &rect, -10, 0, 30, 30 );
4314     RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
4315     SetRect( &rect, 0, 0, 100, 100 );
4316     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
4317     RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
4318     ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
4319     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
4320     ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
4321
4322     /* test RDW_INTERNALPAINT behavior */
4323
4324     flush_sequence();
4325     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
4326     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4327     ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
4328
4329     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
4330     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4331     ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
4332
4333     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
4334     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4335     ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
4336
4337     assert( GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
4338     UpdateWindow( hparent );
4339     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4340     flush_sequence();
4341     trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
4342     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4343     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4344                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4345     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4346     ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
4347
4348     UpdateWindow( hparent );
4349     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4350     flush_sequence();
4351     trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
4352     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4353     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
4354                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4355     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4356     ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
4357
4358     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
4359     ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
4360     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
4361     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4362     ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
4363
4364     assert( !(GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
4365     UpdateWindow( hparent );
4366     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4367     flush_sequence();
4368     trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
4369     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4370     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
4371                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4372     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4373     ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
4374
4375     UpdateWindow( hparent );
4376     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4377     flush_sequence();
4378     trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
4379     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
4380     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
4381                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
4382     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
4383     ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
4384
4385     log_all_parent_messages--;
4386     DestroyWindow( hparent );
4387     ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
4388
4389     DeleteObject( hrgn );
4390     DeleteObject( hrgn2 );
4391 }
4392
4393 struct wnd_event
4394 {
4395     HWND hwnd;
4396     HANDLE event;
4397 };
4398
4399 static DWORD WINAPI thread_proc(void *param)
4400 {
4401     MSG msg;
4402     struct wnd_event *wnd_event = (struct wnd_event *)param;
4403
4404     wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
4405                                       100, 100, 200, 200, 0, 0, 0, NULL);
4406     ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
4407
4408     SetEvent(wnd_event->event);
4409
4410     while (GetMessage(&msg, 0, 0, 0))
4411     {
4412         TranslateMessage(&msg);
4413         DispatchMessage(&msg);
4414     }
4415
4416     ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
4417
4418     return 0;
4419 }
4420
4421 static void test_interthread_messages(void)
4422 {
4423     HANDLE hThread;
4424     DWORD tid;
4425     WNDPROC proc;
4426     MSG msg;
4427     char buf[256];
4428     int len, expected_len;
4429     struct wnd_event wnd_event;
4430     BOOL ret;
4431
4432     wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
4433     if (!wnd_event.event)
4434     {
4435         trace("skipping interthread message test under win9x\n");
4436         return;
4437     }
4438
4439     hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
4440     ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
4441
4442     ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
4443
4444     CloseHandle(wnd_event.event);
4445
4446     SetLastError(0xdeadbeef);
4447     ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
4448     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error code %ld\n", GetLastError());
4449
4450     proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
4451     ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %ld\n", GetLastError());
4452
4453     expected_len = lstrlenA("window caption text");
4454     memset(buf, 0, sizeof(buf));
4455     SetLastError(0xdeadbeef);
4456     len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
4457     ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %ld, len %d, expected len %d\n", GetLastError(), len, expected_len);
4458     ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
4459
4460     msg.hwnd = wnd_event.hwnd;
4461     msg.message = WM_GETTEXT;
4462     msg.wParam = sizeof(buf);
4463     msg.lParam = (LPARAM)buf;
4464     memset(buf, 0, sizeof(buf));
4465     SetLastError(0xdeadbeef);
4466     len = DispatchMessageA(&msg);
4467     ok(!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
4468        "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %ld\n", len, GetLastError());
4469
4470     /* the following test causes an exception in user.exe under win9x */
4471     msg.hwnd = wnd_event.hwnd;
4472     msg.message = WM_TIMER;
4473     msg.wParam = 0;
4474     msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
4475     SetLastError(0xdeadbeef);
4476     len = DispatchMessageA(&msg);
4477     ok(!len && GetLastError() == 0xdeadbeef,
4478        "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %ld\n", len, GetLastError());
4479
4480     ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
4481     ok( ret, "PostMessageA(WM_QUIT) error %ld\n", GetLastError());
4482
4483     ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
4484     CloseHandle(hThread);
4485
4486     ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
4487 }
4488
4489
4490 static const struct message WmVkN[] = {
4491     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
4492     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
4493     { WM_CHAR, wparam|lparam, 'n', 1 },
4494     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
4495     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
4496     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
4497     { 0 }
4498 };
4499 static const struct message WmShiftVkN[] = {
4500     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
4501     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
4502     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
4503     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
4504     { WM_CHAR, wparam|lparam, 'N', 1 },
4505     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
4506     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
4507     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
4508     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
4509     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
4510     { 0 }
4511 };
4512 static const struct message WmCtrlVkN[] = {
4513     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
4514     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
4515     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
4516     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
4517     { WM_CHAR, wparam|lparam, 0x000e, 1 },
4518     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
4519     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
4520     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
4521     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
4522     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
4523     { 0 }
4524 };
4525 static const struct message WmCtrlVkN_2[] = {
4526     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
4527     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
4528     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
4529     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
4530     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
4531     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
4532     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
4533     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
4534     { 0 }
4535 };
4536 static const struct message WmAltVkN[] = {
4537     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
4538     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
4539     { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
4540     { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
4541     { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
4542     { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
4543     { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
4544     { HCBT_SYSCOMMAND, hook },
4545     { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
4546     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
4547     { 0x00AE, sent|defwinproc|optional }, /* XP */
4548     { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
4549     { WM_INITMENU, sent|defwinproc },
4550     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
4551     { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
4552     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
4553     { WM_CAPTURECHANGED, sent|defwinproc },
4554     { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
4555     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
4556     { WM_EXITMENULOOP, sent|defwinproc },
4557     { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
4558     { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
4559     { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
4560     { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
4561     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4562     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4563     { 0 }
4564 };
4565 static const struct message WmAltVkN_2[] = {
4566     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
4567     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
4568     { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
4569     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
4570     { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
4571     { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
4572     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4573     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4574     { 0 }
4575 };
4576 static const struct message WmCtrlAltVkN[] = {
4577     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
4578     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
4579     { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
4580     { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
4581     { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
4582     { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
4583     { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
4584     { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
4585     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4586     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4587     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
4588     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
4589     { 0 }
4590 };
4591 static const struct message WmCtrlShiftVkN[] = {
4592     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
4593     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
4594     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
4595     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
4596     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
4597     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
4598     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
4599     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
4600     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
4601     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
4602     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
4603     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
4604     { 0 }
4605 };
4606 static const struct message WmCtrlAltShiftVkN[] = {
4607     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
4608     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
4609     { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
4610     { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
4611     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
4612     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
4613     { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
4614     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
4615     { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
4616     { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
4617     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
4618     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
4619     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4620     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4621     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
4622     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
4623     { 0 }
4624 };
4625 static const struct message WmAltPressRelease[] = {
4626     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
4627     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
4628     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4629     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4630     { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
4631     { HCBT_SYSCOMMAND, hook },
4632     { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
4633     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
4634     { WM_INITMENU, sent|defwinproc },
4635     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
4636     { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE) },
4637     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
4638
4639     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
4640     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
4641     { WM_CAPTURECHANGED, sent|defwinproc },
4642     { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
4643     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
4644     { WM_EXITMENULOOP, sent|defwinproc },
4645     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4646     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4647     { 0 }
4648 };
4649 static const struct message WmAltMouseButton[] = {
4650     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
4651     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
4652     { WM_MOUSEMOVE, wparam|optional, 0, 0 },
4653     { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
4654     { WM_LBUTTONDOWN, wparam, MK_LBUTTON, 0 },
4655     { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON, 0 },
4656     { WM_LBUTTONUP, wparam, 0, 0 },
4657     { WM_LBUTTONUP, sent|wparam, 0, 0 },
4658     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
4659     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
4660     { 0 }
4661 };
4662 static const struct message WmF1Seq[] = {
4663     { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
4664     { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
4665     { 0x4d, wparam|lparam, 0, 0 },
4666     { 0x4d, sent|wparam|lparam, 0, 0 },
4667     { WM_HELP, sent|defwinproc },
4668     { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
4669     { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
4670     { 0 }
4671 };
4672
4673 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
4674 {
4675     MSG msg;
4676
4677     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
4678     {
4679         struct message log_msg;
4680
4681         trace("accel: %p, %04x, %08x, %08lx\n", msg.hwnd, msg.message, msg.wParam, msg.lParam);
4682
4683         /* ignore some unwanted messages */
4684         if (msg.message == WM_MOUSEMOVE ||
4685             msg.message == WM_GETICON ||
4686             msg.message == WM_DEVICECHANGE)
4687             continue;
4688
4689         log_msg.message = msg.message;
4690         log_msg.flags = wparam|lparam;
4691         log_msg.wParam = msg.wParam;
4692         log_msg.lParam = msg.lParam;
4693         add_message(&log_msg);
4694
4695         if (!hAccel || !TranslateAccelerator(hwnd, hAccel, &msg))
4696         {
4697             TranslateMessage(&msg);
4698             DispatchMessage(&msg);
4699         }
4700     }
4701 }
4702
4703 static void test_accelerators(void)
4704 {
4705     RECT rc;
4706     SHORT state;
4707     HACCEL hAccel;
4708     HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4709                                 100, 100, 200, 200, 0, 0, 0, NULL);
4710     BOOL ret;
4711
4712     assert(hwnd != 0);
4713     UpdateWindow(hwnd);
4714     flush_events();
4715     SetFocus(hwnd);
4716     ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
4717
4718     state = GetKeyState(VK_SHIFT);
4719     ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
4720     state = GetKeyState(VK_CAPITAL);
4721     ok(state == 0, "wrong CapsLock state %04x\n", state);
4722
4723     hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
4724     assert(hAccel != 0);
4725
4726     pump_msg_loop(hwnd, 0);
4727     flush_sequence();
4728
4729     trace("testing VK_N press/release\n");
4730     flush_sequence();
4731     keybd_event('N', 0, 0, 0);
4732     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4733     pump_msg_loop(hwnd, hAccel);
4734     ok_sequence(WmVkN, "VK_N press/release", FALSE);
4735
4736     trace("testing Shift+VK_N press/release\n");
4737     flush_sequence();
4738     keybd_event(VK_SHIFT, 0, 0, 0);
4739     keybd_event('N', 0, 0, 0);
4740     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4741     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
4742     pump_msg_loop(hwnd, hAccel);
4743     ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
4744
4745     trace("testing Ctrl+VK_N press/release\n");
4746     flush_sequence();
4747     keybd_event(VK_CONTROL, 0, 0, 0);
4748     keybd_event('N', 0, 0, 0);
4749     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4750     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4751     pump_msg_loop(hwnd, hAccel);
4752     ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
4753
4754     trace("testing Alt+VK_N press/release\n");
4755     flush_sequence();
4756     keybd_event(VK_MENU, 0, 0, 0);
4757     keybd_event('N', 0, 0, 0);
4758     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4759     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4760     pump_msg_loop(hwnd, hAccel);
4761     ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
4762
4763     trace("testing Ctrl+Alt+VK_N press/release 1\n");
4764     flush_sequence();
4765     keybd_event(VK_CONTROL, 0, 0, 0);
4766     keybd_event(VK_MENU, 0, 0, 0);
4767     keybd_event('N', 0, 0, 0);
4768     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4769     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4770     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4771     pump_msg_loop(hwnd, hAccel);
4772     ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
4773
4774     ret = DestroyAcceleratorTable(hAccel);
4775     ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
4776
4777     hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
4778     assert(hAccel != 0);
4779
4780     trace("testing VK_N press/release\n");
4781     flush_sequence();
4782     keybd_event('N', 0, 0, 0);
4783     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4784     pump_msg_loop(hwnd, hAccel);
4785     ok_sequence(WmVkN, "VK_N press/release", FALSE);
4786
4787     trace("testing Shift+VK_N press/release\n");
4788     flush_sequence();
4789     keybd_event(VK_SHIFT, 0, 0, 0);
4790     keybd_event('N', 0, 0, 0);
4791     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4792     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
4793     pump_msg_loop(hwnd, hAccel);
4794     ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
4795
4796     trace("testing Ctrl+VK_N press/release 2\n");
4797     flush_sequence();
4798     keybd_event(VK_CONTROL, 0, 0, 0);
4799     keybd_event('N', 0, 0, 0);
4800     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4801     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4802     pump_msg_loop(hwnd, hAccel);
4803     ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
4804
4805     trace("testing Alt+VK_N press/release 2\n");
4806     flush_sequence();
4807     keybd_event(VK_MENU, 0, 0, 0);
4808     keybd_event('N', 0, 0, 0);
4809     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4810     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4811     pump_msg_loop(hwnd, hAccel);
4812     ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
4813
4814     trace("testing Ctrl+Alt+VK_N press/release 2\n");
4815     flush_sequence();
4816     keybd_event(VK_CONTROL, 0, 0, 0);
4817     keybd_event(VK_MENU, 0, 0, 0);
4818     keybd_event('N', 0, 0, 0);
4819     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4820     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4821     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4822     pump_msg_loop(hwnd, hAccel);
4823     ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
4824
4825     trace("testing Ctrl+Shift+VK_N press/release\n");
4826     flush_sequence();
4827     keybd_event(VK_CONTROL, 0, 0, 0);
4828     keybd_event(VK_SHIFT, 0, 0, 0);
4829     keybd_event('N', 0, 0, 0);
4830     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4831     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
4832     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4833     pump_msg_loop(hwnd, hAccel);
4834     ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
4835
4836     trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
4837     flush_sequence();
4838     keybd_event(VK_CONTROL, 0, 0, 0);
4839     keybd_event(VK_MENU, 0, 0, 0);
4840     keybd_event(VK_SHIFT, 0, 0, 0);
4841     keybd_event('N', 0, 0, 0);
4842     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
4843     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
4844     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4845     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
4846     pump_msg_loop(hwnd, hAccel);
4847     ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
4848
4849     ret = DestroyAcceleratorTable(hAccel);
4850     ok( ret, "DestroyAcceleratorTable error %ld\n", GetLastError());
4851
4852     trace("testing Alt press/release\n");
4853     flush_sequence();
4854     keybd_event(VK_MENU, 0, 0, 0);
4855     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4856     keybd_event(VK_MENU, 0, 0, 0);
4857     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4858     pump_msg_loop(hwnd, 0);
4859     /* this test doesn't pass in Wine for managed windows */
4860     ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
4861
4862     trace("testing Alt+MouseButton press/release\n");
4863     /* first, move mouse pointer inside of the window client area */
4864     GetClientRect(hwnd, &rc);
4865     MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
4866     rc.left += (rc.right - rc.left)/2;
4867     rc.top += (rc.bottom - rc.top)/2;
4868     SetCursorPos(rc.left, rc.top);
4869
4870     pump_msg_loop(hwnd, 0);
4871     flush_sequence();
4872     keybd_event(VK_MENU, 0, 0, 0);
4873     mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
4874     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
4875     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
4876     pump_msg_loop(hwnd, 0);
4877     ok_sequence(WmAltMouseButton, "Alt+MouseButton press/release", FALSE);
4878
4879     keybd_event(VK_F1, 0, 0, 0);
4880     keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
4881     pump_msg_loop(hwnd, 0);
4882     ok_sequence(WmF1Seq, "F1 press/release", TRUE);
4883
4884     DestroyWindow(hwnd);
4885 }
4886
4887 /************* window procedures ********************/
4888
4889 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message, 
4890                              WPARAM wParam, LPARAM lParam)
4891 {
4892     static long defwndproc_counter = 0;
4893     static long beginpaint_counter = 0;
4894     LRESULT ret;
4895     struct message msg;
4896
4897     trace("%p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
4898
4899     /* explicitly ignore WM_GETICON message */
4900     if (message == WM_GETICON) return 0;
4901
4902     switch (message)
4903     {
4904         case WM_ENABLE:
4905         {
4906             LONG style = GetWindowLongA(hwnd, GWL_STYLE);
4907             ok((BOOL)wParam == !(style & WS_DISABLED),
4908                 "wrong WS_DISABLED state: %d != %d\n", wParam, !(style & WS_DISABLED));
4909             break;
4910         }
4911
4912         case WM_CAPTURECHANGED:
4913             if (test_DestroyWindow_flag)
4914             {
4915                 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
4916                 if (style & WS_CHILD)
4917                     lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
4918                 else if (style & WS_POPUP)
4919                     lParam = WND_POPUP_ID;
4920                 else
4921                     lParam = WND_PARENT_ID;
4922             }
4923             break;
4924
4925         case WM_NCDESTROY:
4926         {
4927             HWND capture;
4928
4929             ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
4930             capture = GetCapture();
4931             if (capture)
4932             {
4933                 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
4934                 trace("current capture %p, releasing...\n", capture);
4935                 ReleaseCapture();
4936             }
4937         }
4938         /* fall through */
4939         case WM_DESTROY:
4940             if (pGetAncestor)
4941                 ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
4942             if (test_DestroyWindow_flag)
4943             {
4944                 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
4945                 if (style & WS_CHILD)
4946                     lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
4947                 else if (style & WS_POPUP)
4948                     lParam = WND_POPUP_ID;
4949                 else
4950                     lParam = WND_PARENT_ID;
4951             }
4952             break;
4953
4954         /* test_accelerators() depends on this */
4955         case WM_NCHITTEST:
4956             return HTCLIENT;
4957     
4958         /* ignore */
4959         case WM_MOUSEMOVE:
4960         case WM_SETCURSOR:
4961         case WM_DEVICECHANGE:
4962             return 0;
4963
4964         case WM_WINDOWPOSCHANGING:
4965         case WM_WINDOWPOSCHANGED:
4966         {
4967             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
4968
4969             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
4970             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
4971                   winpos->hwnd, winpos->hwndInsertAfter,
4972                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
4973
4974             /* Log only documented flags, win2k uses 0x1000 and 0x2000
4975              * in the high word for internal purposes
4976              */
4977             wParam = winpos->flags & 0xffff;
4978             break;
4979         }
4980     }
4981
4982     msg.message = message;
4983     msg.flags = sent|wparam|lparam;
4984     if (defwndproc_counter) msg.flags |= defwinproc;
4985     if (beginpaint_counter) msg.flags |= beginpaint;
4986     msg.wParam = wParam;
4987     msg.lParam = lParam;
4988     add_message(&msg);
4989
4990     if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
4991     {
4992         HWND parent = GetParent(hwnd);
4993         RECT rc;
4994         MINMAXINFO *minmax = (MINMAXINFO *)lParam;
4995
4996         GetClientRect(parent, &rc);
4997         trace("parent %p client size = (%ld x %ld)\n", parent, rc.right, rc.bottom);
4998
4999         trace("ptReserved = (%ld,%ld)\n"
5000               "ptMaxSize = (%ld,%ld)\n"
5001               "ptMaxPosition = (%ld,%ld)\n"
5002               "ptMinTrackSize = (%ld,%ld)\n"
5003               "ptMaxTrackSize = (%ld,%ld)\n",
5004               minmax->ptReserved.x, minmax->ptReserved.y,
5005               minmax->ptMaxSize.x, minmax->ptMaxSize.y,
5006               minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
5007               minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
5008               minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
5009
5010         ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %ld != %ld\n",
5011            minmax->ptMaxSize.x, rc.right);
5012         ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %ld != %ld\n",
5013            minmax->ptMaxSize.y, rc.bottom);
5014     }
5015
5016     if (message == WM_PAINT)
5017     {
5018         PAINTSTRUCT ps;
5019         beginpaint_counter++;
5020         BeginPaint( hwnd, &ps );
5021         beginpaint_counter--;
5022         EndPaint( hwnd, &ps );
5023         return 0;
5024     }
5025
5026     defwndproc_counter++;
5027     ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam) 
5028                   : DefWindowProcA(hwnd, message, wParam, lParam);
5029     defwndproc_counter--;
5030
5031     return ret;
5032 }
5033
5034 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5035 {
5036     return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
5037 }
5038
5039 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5040 {
5041     return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
5042 }
5043
5044 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5045 {
5046     static long defwndproc_counter = 0;
5047     LRESULT ret;
5048     struct message msg;
5049
5050     trace("popup: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
5051
5052     /* explicitly ignore WM_GETICON message */
5053     if (message == WM_GETICON) return 0;
5054
5055     msg.message = message;
5056     msg.flags = sent|wparam|lparam;
5057     if (defwndproc_counter) msg.flags |= defwinproc;
5058     msg.wParam = wParam;
5059     msg.lParam = lParam;
5060     add_message(&msg);
5061
5062     if (message == WM_CREATE)
5063     {
5064         DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
5065         SetWindowLongA(hwnd, GWL_STYLE, style);
5066     }
5067
5068     defwndproc_counter++;
5069     ret = DefWindowProcA(hwnd, message, wParam, lParam);
5070     defwndproc_counter--;
5071
5072     return ret;
5073 }
5074
5075 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5076 {
5077     static long defwndproc_counter = 0;
5078     static long beginpaint_counter = 0;
5079     LRESULT ret;
5080     struct message msg;
5081
5082     trace("parent: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
5083
5084     /* explicitly ignore WM_GETICON message */
5085     if (message == WM_GETICON) return 0;
5086
5087     if (log_all_parent_messages ||
5088         message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
5089         message == WM_SETFOCUS || message == WM_KILLFOCUS ||
5090         message == WM_ENABLE || message == WM_ENTERIDLE ||
5091         message == WM_IME_SETCONTEXT)
5092     {
5093         switch (message)
5094         {
5095             case WM_ERASEBKGND:
5096             {
5097                 RECT rc;
5098                 INT ret = GetClipBox((HDC)wParam, &rc);
5099
5100                 trace("WM_ERASEBKGND: GetClipBox()=%d, (%ld,%ld-%ld,%ld)\n",
5101                        ret, rc.left, rc.top, rc.right, rc.bottom);
5102                 break;
5103             }
5104
5105             case WM_WINDOWPOSCHANGING:
5106             case WM_WINDOWPOSCHANGED:
5107             {
5108                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
5109
5110                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
5111                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
5112                       winpos->hwnd, winpos->hwndInsertAfter,
5113                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
5114
5115                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
5116                  * in the high word for internal purposes
5117                  */
5118                 wParam = winpos->flags & 0xffff;
5119                 break;
5120             }
5121         }
5122
5123         msg.message = message;
5124         msg.flags = sent|parent|wparam|lparam;
5125         if (defwndproc_counter) msg.flags |= defwinproc;
5126         if (beginpaint_counter) msg.flags |= beginpaint;
5127         msg.wParam = wParam;
5128         msg.lParam = lParam;
5129         add_message(&msg);
5130     }
5131
5132     if (message == WM_PAINT)
5133     {
5134         PAINTSTRUCT ps;
5135         beginpaint_counter++;
5136         BeginPaint( hwnd, &ps );
5137         beginpaint_counter--;
5138         EndPaint( hwnd, &ps );
5139         return 0;
5140     }
5141
5142     defwndproc_counter++;
5143     ret = DefWindowProcA(hwnd, message, wParam, lParam);
5144     defwndproc_counter--;
5145
5146     return ret;
5147 }
5148
5149 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5150 {
5151     static long defwndproc_counter = 0;
5152     LRESULT ret;
5153     struct message msg;
5154
5155     trace("dialog: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
5156
5157     /* explicitly ignore WM_GETICON message */
5158     if (message == WM_GETICON) return 0;
5159
5160     DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
5161     ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
5162     if (after_end_dialog)
5163         ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
5164     else
5165         ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
5166
5167     switch (message)
5168     {
5169         case WM_WINDOWPOSCHANGING:
5170         case WM_WINDOWPOSCHANGED:
5171         {
5172             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
5173
5174             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
5175             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
5176                   winpos->hwnd, winpos->hwndInsertAfter,
5177                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
5178
5179             /* Log only documented flags, win2k uses 0x1000 and 0x2000
5180              * in the high word for internal purposes
5181              */
5182             wParam = winpos->flags & 0xffff;
5183             break;
5184         }
5185     }
5186
5187     msg.message = message;
5188     msg.flags = sent|wparam|lparam;
5189     if (defwndproc_counter) msg.flags |= defwinproc;
5190     msg.wParam = wParam;
5191     msg.lParam = lParam;
5192     add_message(&msg);
5193
5194     defwndproc_counter++;
5195     ret = DefDlgProcA(hwnd, message, wParam, lParam);
5196     defwndproc_counter--;
5197
5198     return ret;
5199 }
5200
5201 static BOOL RegisterWindowClasses(void)
5202 {
5203     WNDCLASSA cls;
5204
5205     cls.style = 0;
5206     cls.lpfnWndProc = MsgCheckProcA;
5207     cls.cbClsExtra = 0;
5208     cls.cbWndExtra = 0;
5209     cls.hInstance = GetModuleHandleA(0);
5210     cls.hIcon = 0;
5211     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
5212     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
5213     cls.lpszMenuName = NULL;
5214     cls.lpszClassName = "TestWindowClass";
5215     if(!RegisterClassA(&cls)) return FALSE;
5216
5217     cls.lpfnWndProc = PopupMsgCheckProcA;
5218     cls.lpszClassName = "TestPopupClass";
5219     if(!RegisterClassA(&cls)) return FALSE;
5220
5221     cls.lpfnWndProc = ParentMsgCheckProcA;
5222     cls.lpszClassName = "TestParentClass";
5223     if(!RegisterClassA(&cls)) return FALSE;
5224
5225     cls.lpfnWndProc = DefWindowProcA;
5226     cls.lpszClassName = "SimpleWindowClass";
5227     if(!RegisterClassA(&cls)) return FALSE;
5228
5229     cls.style = CS_NOCLOSE;
5230     cls.lpszClassName = "NoCloseWindowClass";
5231     if(!RegisterClassA(&cls)) return FALSE;
5232
5233     ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
5234     cls.style = 0;
5235     cls.hInstance = GetModuleHandleA(0);
5236     cls.hbrBackground = 0;
5237     cls.lpfnWndProc = TestDlgProcA;
5238     cls.lpszClassName = "TestDialogClass";
5239     if(!RegisterClassA(&cls)) return FALSE;
5240
5241     return TRUE;
5242 }
5243
5244 static HHOOK hCBT_hook;
5245 static DWORD cbt_hook_thread_id;
5246
5247 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam) 
5248 { 
5249     static const char *CBT_code_name[10] = {
5250         "HCBT_MOVESIZE",
5251         "HCBT_MINMAX",
5252         "HCBT_QS",
5253         "HCBT_CREATEWND",
5254         "HCBT_DESTROYWND",
5255         "HCBT_ACTIVATE",
5256         "HCBT_CLICKSKIPPED",
5257         "HCBT_KEYSKIPPED",
5258         "HCBT_SYSCOMMAND",
5259         "HCBT_SETFOCUS" };
5260     const char *code_name = (nCode >= 0 && nCode <= HCBT_SETFOCUS) ? CBT_code_name[nCode] : "Unknown";
5261     HWND hwnd;
5262     char buf[256];
5263
5264     trace("CBT: %d (%s), %08x, %08lx\n", nCode, code_name, wParam, lParam);
5265
5266     ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
5267
5268     if (nCode == HCBT_SYSCOMMAND)
5269     {
5270         struct message msg;
5271
5272         msg.message = nCode;
5273         msg.flags = hook|wparam|lparam;
5274         msg.wParam = wParam;
5275         msg.lParam = lParam;
5276         add_message(&msg);
5277
5278         return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
5279     }
5280
5281     if (nCode == HCBT_DESTROYWND)
5282     {
5283         if (test_DestroyWindow_flag)
5284         {
5285             DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
5286             if (style & WS_CHILD)
5287                 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
5288             else if (style & WS_POPUP)
5289                 lParam = WND_POPUP_ID;
5290             else
5291                 lParam = WND_PARENT_ID;
5292         }
5293     }
5294
5295     /* Log also SetFocus(0) calls */
5296     hwnd = wParam ? (HWND)wParam : (HWND)lParam;
5297
5298     if (GetClassNameA(hwnd, buf, sizeof(buf)))
5299     {
5300         if (!lstrcmpiA(buf, "TestWindowClass") ||
5301             !lstrcmpiA(buf, "TestParentClass") ||
5302             !lstrcmpiA(buf, "TestPopupClass") ||
5303             !lstrcmpiA(buf, "SimpleWindowClass") ||
5304             !lstrcmpiA(buf, "TestDialogClass") ||
5305             !lstrcmpiA(buf, "MDI_frame_class") ||
5306             !lstrcmpiA(buf, "MDI_client_class") ||
5307             !lstrcmpiA(buf, "MDI_child_class") ||
5308             !lstrcmpiA(buf, "my_button_class") ||
5309             !lstrcmpiA(buf, "my_edit_class") ||
5310             !lstrcmpiA(buf, "static") ||
5311             !lstrcmpiA(buf, "#32770"))
5312         {
5313             struct message msg;
5314
5315             msg.message = nCode;
5316             msg.flags = hook|wparam|lparam;
5317             msg.wParam = wParam;
5318             msg.lParam = lParam;
5319             add_message(&msg);
5320         }
5321     }
5322     return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
5323 }
5324
5325 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
5326                                     DWORD event,
5327                                     HWND hwnd,
5328                                     LONG object_id,
5329                                     LONG child_id,
5330                                     DWORD thread_id,
5331                                     DWORD event_time)
5332 {
5333     char buf[256];
5334
5335     trace("WEH:%p,event %08lx,hwnd %p,obj %08lx,id %08lx,thread %08lx,time %08lx\n",
5336            hevent, event, hwnd, object_id, child_id, thread_id, event_time);
5337
5338     ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
5339
5340     /* ignore mouse cursor events */
5341     if (object_id == OBJID_CURSOR) return;
5342
5343     if (!hwnd || GetClassNameA(hwnd, buf, sizeof(buf)))
5344     {
5345         if (!hwnd ||
5346             !lstrcmpiA(buf, "TestWindowClass") ||
5347             !lstrcmpiA(buf, "TestParentClass") ||
5348             !lstrcmpiA(buf, "TestPopupClass") ||
5349             !lstrcmpiA(buf, "SimpleWindowClass") ||
5350             !lstrcmpiA(buf, "TestDialogClass") ||
5351             !lstrcmpiA(buf, "MDI_frame_class") ||
5352             !lstrcmpiA(buf, "MDI_client_class") ||
5353             !lstrcmpiA(buf, "MDI_child_class") ||
5354             !lstrcmpiA(buf, "my_button_class") ||
5355             !lstrcmpiA(buf, "my_edit_class") ||
5356             !lstrcmpiA(buf, "static") ||
5357             !lstrcmpiA(buf, "#32770"))
5358         {
5359             struct message msg;
5360
5361             msg.message = event;
5362             msg.flags = winevent_hook|wparam|lparam;
5363             msg.wParam = object_id;
5364             msg.lParam = child_id;
5365             add_message(&msg);
5366         }
5367     }
5368 }
5369
5370 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
5371 static const WCHAR wszAnsi[] = {'U',0};
5372
5373 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
5374 {
5375     switch (uMsg)
5376     {
5377     case CB_FINDSTRINGEXACT:
5378         trace("String: %p\n", (LPCWSTR)lParam);
5379         if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
5380             return 1;
5381         if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
5382             return 0;
5383         return -1;
5384     }
5385     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
5386 }
5387
5388 static const struct message WmGetTextLengthAfromW[] = {
5389     { WM_GETTEXTLENGTH, sent },
5390     { WM_GETTEXT, sent },
5391     { 0 }
5392 };
5393
5394 static const WCHAR testWindowClassW[] = 
5395 { 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
5396
5397 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
5398
5399 /* dummy window proc for WM_GETTEXTLENGTH test */
5400 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
5401 {
5402     switch(msg)
5403     {
5404     case WM_GETTEXTLENGTH:
5405         return lstrlenW(dummy_window_text) + 37;  /* some random length */
5406     case WM_GETTEXT:
5407         lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
5408         return lstrlenW( (LPWSTR)lp );
5409     default:
5410         return DefWindowProcW( hwnd, msg, wp, lp );
5411     }
5412 }
5413
5414 static void test_message_conversion(void)
5415 {
5416     static const WCHAR wszMsgConversionClass[] =
5417         {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
5418     WNDCLASSW cls;
5419     LRESULT lRes;
5420     HWND hwnd;
5421     WNDPROC wndproc, newproc;
5422     BOOL ret;
5423
5424     cls.style = 0;
5425     cls.lpfnWndProc = MsgConversionProcW;
5426     cls.cbClsExtra = 0;
5427     cls.cbWndExtra = 0;
5428     cls.hInstance = GetModuleHandleW(NULL);
5429     cls.hIcon = NULL;
5430     cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
5431     cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
5432     cls.lpszMenuName = NULL;
5433     cls.lpszClassName = wszMsgConversionClass;
5434     /* this call will fail on Win9x, but that doesn't matter as this test is
5435      * meaningless on those platforms */
5436     if(!RegisterClassW(&cls)) return;
5437
5438     cls.style = 0;
5439     cls.lpfnWndProc = MsgCheckProcW;
5440     cls.cbClsExtra = 0;
5441     cls.cbWndExtra = 0;
5442     cls.hInstance = GetModuleHandleW(0);
5443     cls.hIcon = 0;
5444     cls.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
5445     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
5446     cls.lpszMenuName = NULL;
5447     cls.lpszClassName = testWindowClassW;
5448     if(!RegisterClassW(&cls)) return;
5449
5450     hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
5451                            100, 100, 200, 200, 0, 0, 0, NULL);
5452     ok(hwnd != NULL, "Window creation failed\n");
5453
5454     /* {W, A} -> A */
5455
5456     wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
5457     lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5458     ok(lRes == 0, "String should have been converted\n");
5459     lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5460     ok(lRes == 1, "String shouldn't have been converted\n");
5461
5462     /* {W, A} -> W */
5463
5464     wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
5465     lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5466     ok(lRes == 1, "String shouldn't have been converted\n");
5467     lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5468     ok(lRes == 1, "String shouldn't have been converted\n");
5469
5470     /* Synchronous messages */
5471
5472     lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5473     ok(lRes == 0, "String should have been converted\n");
5474     lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5475     ok(lRes == 1, "String shouldn't have been converted\n");
5476
5477     /* Asynchronous messages */
5478
5479     SetLastError(0);
5480     lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5481     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5482         "PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5483     SetLastError(0);
5484     lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5485     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5486         "PostMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5487     SetLastError(0);
5488     lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5489     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5490         "PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5491     SetLastError(0);
5492     lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5493     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5494         "PosThreadtMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5495     SetLastError(0);
5496     lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5497     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5498         "SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5499     SetLastError(0);
5500     lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
5501     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5502         "SendNotifyMessage on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5503     SetLastError(0);
5504     lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
5505     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5506         "SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5507     SetLastError(0);
5508     lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
5509     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
5510         "SendMessageCallback on sync only message returned %ld, last error %ld\n", lRes, GetLastError());
5511
5512     /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
5513
5514     hwnd = CreateWindowW (testWindowClassW, wszUnicode,
5515                           WS_OVERLAPPEDWINDOW,
5516                           100, 100, 200, 200, 0, 0, 0, NULL);
5517     assert(hwnd);
5518     flush_sequence();
5519     lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
5520     ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
5521     ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
5522         "got bad length %ld\n", lRes );
5523
5524     flush_sequence();
5525     lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
5526                             hwnd, WM_GETTEXTLENGTH, 0, 0);
5527     ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
5528     ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
5529         "got bad length %ld\n", lRes );
5530
5531     wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
5532     newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
5533     lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
5534     ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
5535                                      NULL, 0, NULL, NULL ),
5536         "got bad length %ld\n", lRes );
5537
5538     SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc );  /* restore old wnd proc */
5539     lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
5540     ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
5541                                      NULL, 0, NULL, NULL ),
5542         "got bad length %ld\n", lRes );
5543
5544     ret = DestroyWindow(hwnd);
5545     ok( ret, "DestroyWindow() error %ld\n", GetLastError());
5546 }
5547
5548 struct timer_info
5549 {
5550     HWND hWnd;
5551     HANDLE handles[2];
5552     DWORD id;
5553 };
5554
5555 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT id, DWORD dwTime)
5556 {
5557 }
5558
5559 #define TIMER_ID  0x19
5560
5561 static DWORD WINAPI timer_thread_proc(LPVOID x)
5562 {
5563     struct timer_info *info = x;
5564     DWORD r;
5565
5566     r = KillTimer(info->hWnd, 0x19);
5567     ok(r,"KillTimer failed in thread\n");
5568     r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
5569     ok(r,"SetTimer failed in thread\n");
5570     ok(r==TIMER_ID,"SetTimer id different\n");
5571     r = SetEvent(info->handles[0]);
5572     ok(r,"SetEvent failed in thread\n");
5573     return 0;
5574 }
5575
5576 static void test_timers(void)
5577 {
5578     struct timer_info info;
5579     DWORD id;
5580
5581     info.hWnd = CreateWindow ("TestWindowClass", NULL,
5582        WS_OVERLAPPEDWINDOW ,
5583        CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5584        NULL, NULL, 0);
5585
5586     info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
5587     ok(info.id, "SetTimer failed\n");
5588     ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
5589     info.handles[0] = CreateEvent(NULL,0,0,NULL);
5590     info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
5591
5592     WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
5593
5594     WaitForSingleObject(info.handles[1], INFINITE);
5595
5596     CloseHandle(info.handles[0]);
5597     CloseHandle(info.handles[1]);
5598
5599     ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
5600
5601     ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
5602 }
5603
5604 /* Various win events with arbitrary parameters */
5605 static const struct message WmWinEventsSeq[] = {
5606     { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
5607     { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
5608     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
5609     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
5610     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
5611     { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
5612     { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
5613     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
5614     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
5615     /* our win event hook ignores OBJID_CURSOR events */
5616     /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
5617     { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
5618     { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
5619     { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
5620     { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
5621     { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
5622     { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
5623     { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
5624     { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
5625     { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
5626     { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
5627     { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
5628     { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
5629     { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
5630     { 0 }
5631 };
5632 static const struct message WmWinEventCaretSeq[] = {
5633     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
5634     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
5635     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
5636     { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
5637     { 0 }
5638 };
5639 static const struct message WmWinEventCaretSeq_2[] = {
5640     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
5641     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
5642     { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
5643     { 0 }
5644 };
5645 static const struct message WmWinEventAlertSeq[] = {
5646     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
5647     { 0 }
5648 };
5649 static const struct message WmWinEventAlertSeq_2[] = {
5650     /* create window in the thread proc */
5651     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
5652     /* our test event */
5653     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
5654     { 0 }
5655 };
5656 static const struct message WmGlobalHookSeq_1[] = {
5657     /* create window in the thread proc */
5658     { HCBT_CREATEWND, hook|lparam, 0, 2 },
5659     /* our test events */
5660     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
5661     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
5662     { 0 }
5663 };
5664 static const struct message WmGlobalHookSeq_2[] = {
5665     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
5666     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
5667     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
5668     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
5669     { 0 }
5670 };
5671
5672 static const struct message WmMouseLLHookSeq[] = {
5673     { WM_MOUSEMOVE, hook },
5674     { WM_LBUTTONDOWN, hook },
5675     { WM_LBUTTONUP, hook },
5676     { 0 }
5677 };
5678
5679 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
5680                                          DWORD event,
5681                                          HWND hwnd,
5682                                          LONG object_id,
5683                                          LONG child_id,
5684                                          DWORD thread_id,
5685                                          DWORD event_time)
5686 {
5687     char buf[256];
5688
5689     trace("WEH_2:%p,event %08lx,hwnd %p,obj %08lx,id %08lx,thread %08lx,time %08lx\n",
5690            hevent, event, hwnd, object_id, child_id, thread_id, event_time);
5691
5692     if (GetClassNameA(hwnd, buf, sizeof(buf)))
5693     {
5694         if (!lstrcmpiA(buf, "TestWindowClass") ||
5695             !lstrcmpiA(buf, "static"))
5696         {
5697             struct message msg;
5698
5699             msg.message = event;
5700             msg.flags = winevent_hook|wparam|lparam;
5701             msg.wParam = object_id;
5702             msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
5703             add_message(&msg);
5704         }
5705     }
5706 }
5707
5708 static HHOOK hCBT_global_hook;
5709 static DWORD cbt_global_hook_thread_id;
5710
5711 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam) 
5712 { 
5713     HWND hwnd;
5714     char buf[256];
5715
5716     trace("CBT_2: %d, %08x, %08lx\n", nCode, wParam, lParam);
5717
5718     if (nCode == HCBT_SYSCOMMAND)
5719     {
5720         struct message msg;
5721
5722         msg.message = nCode;
5723         msg.flags = hook|wparam|lparam;
5724         msg.wParam = wParam;
5725         msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
5726         add_message(&msg);
5727
5728         return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
5729     }
5730     /* WH_MOUSE_LL hook */
5731     if (nCode == HC_ACTION)
5732     {
5733         struct message msg;
5734         MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
5735
5736         /* we can't test for real mouse events */
5737         if (mhll->flags & LLMHF_INJECTED)
5738         {
5739             msg.message = wParam;
5740             msg.flags = hook;
5741             add_message(&msg);
5742         }
5743         return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
5744     }
5745
5746     /* Log also SetFocus(0) calls */
5747     hwnd = wParam ? (HWND)wParam : (HWND)lParam;
5748
5749     if (GetClassNameA(hwnd, buf, sizeof(buf)))
5750     {
5751         if (!lstrcmpiA(buf, "TestWindowClass") ||
5752             !lstrcmpiA(buf, "static"))
5753         {
5754             struct message msg;
5755
5756             msg.message = nCode;
5757             msg.flags = hook|wparam|lparam;
5758             msg.wParam = wParam;
5759             msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
5760             add_message(&msg);
5761         }
5762     }
5763     return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
5764 }
5765
5766 static DWORD WINAPI win_event_global_thread_proc(void *param)
5767 {
5768     HWND hwnd;
5769     MSG msg;
5770     HANDLE hevent = *(HANDLE *)param;
5771     HMODULE user32 = GetModuleHandleA("user32.dll");
5772     FARPROC pNotifyWinEvent = GetProcAddress(user32, "NotifyWinEvent");
5773
5774     assert(pNotifyWinEvent);
5775
5776     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
5777     assert(hwnd);
5778     trace("created thread window %p\n", hwnd);
5779
5780     *(HWND *)param = hwnd;
5781
5782     flush_sequence();
5783     /* this event should be received only by our new hook proc,
5784      * an old one does not expect an event from another thread.
5785      */
5786     pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
5787     SetEvent(hevent);
5788
5789     while (GetMessage(&msg, 0, 0, 0))
5790     {
5791         TranslateMessage(&msg);
5792         DispatchMessage(&msg);
5793     }
5794     return 0;
5795 }
5796
5797 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
5798 {
5799     HWND hwnd;
5800     MSG msg;
5801     HANDLE hevent = *(HANDLE *)param;
5802
5803     flush_sequence();
5804     /* these events should be received only by our new hook proc,
5805      * an old one does not expect an event from another thread.
5806      */
5807
5808     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
5809     assert(hwnd);
5810     trace("created thread window %p\n", hwnd);
5811
5812     *(HWND *)param = hwnd;
5813
5814     /* Windows doesn't like when a thread plays games with the focus,
5815        that leads to all kinds of misbehaviours and failures to activate
5816        a window. So, better keep next lines commented out.
5817     SetFocus(0);
5818     SetFocus(hwnd);*/
5819
5820     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
5821     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
5822
5823     SetEvent(hevent);
5824
5825     while (GetMessage(&msg, 0, 0, 0))
5826     {
5827         TranslateMessage(&msg);
5828         DispatchMessage(&msg);
5829     }
5830     return 0;
5831 }
5832
5833 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
5834 {
5835     HWND hwnd;
5836     MSG msg;
5837     HANDLE hevent = *(HANDLE *)param;
5838
5839     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
5840     assert(hwnd);
5841     trace("created thread window %p\n", hwnd);
5842
5843     *(HWND *)param = hwnd;
5844
5845     flush_sequence();
5846
5847     mouse_event(MOUSEEVENTF_MOVE, 100, 0, 0, 0);
5848     mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
5849     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
5850
5851     SetEvent(hevent);
5852     while (GetMessage(&msg, 0, 0, 0))
5853     {
5854         TranslateMessage(&msg);
5855         DispatchMessage(&msg);
5856     }
5857     return 0;
5858 }
5859
5860 static void test_winevents(void)
5861 {
5862     BOOL ret;
5863     MSG msg;
5864     HWND hwnd, hwnd2;
5865     UINT i;
5866     HANDLE hthread, hevent;
5867     DWORD tid;
5868     HWINEVENTHOOK hhook;
5869     const struct message *events = WmWinEventsSeq;
5870     HMODULE user32 = GetModuleHandleA("user32.dll");
5871     FARPROC pSetWinEventHook = GetProcAddress(user32, "SetWinEventHook");
5872     FARPROC pUnhookWinEvent = GetProcAddress(user32, "UnhookWinEvent");
5873     FARPROC pNotifyWinEvent = GetProcAddress(user32, "NotifyWinEvent");
5874
5875     hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
5876                            WS_OVERLAPPEDWINDOW,
5877                            CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5878                            NULL, NULL, 0);
5879     assert(hwnd);
5880
5881     /****** start of global hook test *************/
5882     hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
5883     assert(hCBT_global_hook);
5884
5885     hevent = CreateEventA(NULL, 0, 0, NULL);
5886     assert(hevent);
5887     hwnd2 = (HWND)hevent;
5888
5889     hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
5890     ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
5891
5892     ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5893
5894     ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
5895
5896     flush_sequence();
5897     /* this one should be received only by old hook proc */
5898     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
5899     /* this one should be received only by old hook proc */
5900     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
5901
5902     ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
5903
5904     ret = UnhookWindowsHookEx(hCBT_global_hook);
5905     ok( ret, "UnhookWindowsHookEx error %ld\n", GetLastError());
5906
5907     PostThreadMessageA(tid, WM_QUIT, 0, 0);
5908     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5909     CloseHandle(hthread);
5910     CloseHandle(hevent);
5911     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
5912     /****** end of global hook test *************/
5913
5914     if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
5915     {
5916         ok(DestroyWindow(hwnd), "failed to destroy window\n");
5917         return;
5918     }
5919
5920     flush_sequence();
5921
5922 #if 0 /* this test doesn't pass under Win9x */
5923     /* win2k ignores events with hwnd == 0 */
5924     SetLastError(0xdeadbeef);
5925     pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
5926     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
5927        GetLastError() == 0xdeadbeef, /* Win9x */
5928        "unexpected error %ld\n", GetLastError());
5929     ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
5930 #endif
5931
5932     for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
5933         pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
5934
5935     ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
5936
5937     /****** start of event filtering test *************/
5938     hhook = (HWINEVENTHOOK)pSetWinEventHook(
5939         EVENT_OBJECT_SHOW, /* 0x8002 */
5940         EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
5941         GetModuleHandleA(0), win_event_global_hook_proc,
5942         GetCurrentProcessId(), 0,
5943         WINEVENT_INCONTEXT);
5944     ok(hhook != 0, "SetWinEventHook error %ld\n", GetLastError());
5945
5946     hevent = CreateEventA(NULL, 0, 0, NULL);
5947     assert(hevent);
5948     hwnd2 = (HWND)hevent;
5949
5950     hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
5951     ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
5952
5953     ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5954
5955     ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
5956
5957     flush_sequence();
5958     /* this one should be received only by old hook proc */
5959     pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
5960     pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
5961     /* this one should be received only by old hook proc */
5962     pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
5963
5964     ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
5965
5966     ret = pUnhookWinEvent(hhook);
5967     ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
5968
5969     PostThreadMessageA(tid, WM_QUIT, 0, 0);
5970     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5971     CloseHandle(hthread);
5972     CloseHandle(hevent);
5973     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
5974     /****** end of event filtering test *************/
5975
5976     /****** start of out of context event test *************/
5977     hhook = (HWINEVENTHOOK)pSetWinEventHook(
5978         EVENT_MIN, EVENT_MAX,
5979         0, win_event_global_hook_proc,
5980         GetCurrentProcessId(), 0,
5981         WINEVENT_OUTOFCONTEXT);
5982     ok(hhook != 0, "SetWinEventHook error %ld\n", GetLastError());
5983
5984     hevent = CreateEventA(NULL, 0, 0, NULL);
5985     assert(hevent);
5986     hwnd2 = (HWND)hevent;
5987
5988     flush_sequence();
5989
5990     hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
5991     ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
5992
5993     ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5994
5995     ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
5996     /* process pending winevent messages */
5997     ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
5998     ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
5999
6000     flush_sequence();
6001     /* this one should be received only by old hook proc */
6002     pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
6003     pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
6004     /* this one should be received only by old hook proc */
6005     pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
6006
6007     ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
6008     /* process pending winevent messages */
6009     ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
6010     ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
6011
6012     ret = pUnhookWinEvent(hhook);
6013     ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
6014
6015     PostThreadMessageA(tid, WM_QUIT, 0, 0);
6016     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
6017     CloseHandle(hthread);
6018     CloseHandle(hevent);
6019     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
6020     /****** end of out of context event test *************/
6021
6022     /****** start of MOUSE_LL hook test *************/
6023     hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
6024     assert(hCBT_global_hook);
6025
6026     hevent = CreateEventA(NULL, 0, 0, NULL);
6027     assert(hevent);
6028     hwnd2 = (HWND)hevent;
6029
6030     hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
6031     ok(hthread != NULL, "CreateThread failed, error %ld\n", GetLastError());
6032
6033     while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
6034         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6035
6036     ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
6037     flush_sequence();
6038
6039     mouse_event(MOUSEEVENTF_MOVE, 0, 0, 0, 0);
6040     mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
6041     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
6042
6043     ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
6044
6045     ret = UnhookWindowsHookEx(hCBT_global_hook);
6046     ok( ret, "UnhookWindowsHookEx error %ld\n", GetLastError());
6047
6048     PostThreadMessageA(tid, WM_QUIT, 0, 0);
6049     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
6050     CloseHandle(hthread);
6051     CloseHandle(hevent);
6052     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
6053     /****** end of MOUSE_LL hook test *************/
6054
6055     ok(DestroyWindow(hwnd), "failed to destroy window\n");
6056 }
6057
6058 static void test_set_hook(void)
6059 {
6060     BOOL ret;
6061     HHOOK hhook;
6062     HWINEVENTHOOK hwinevent_hook;
6063     HMODULE user32 = GetModuleHandleA("user32.dll");
6064     FARPROC pSetWinEventHook = GetProcAddress(user32, "SetWinEventHook");
6065     FARPROC pUnhookWinEvent = GetProcAddress(user32, "UnhookWinEvent");
6066
6067     hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
6068     ok(hhook != 0, "local hook does not require hModule set to 0\n");
6069     UnhookWindowsHookEx(hhook);
6070
6071 #if 0 /* this test doesn't pass under Win9x: BUG! */
6072     SetLastError(0xdeadbeef);
6073     hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
6074     ok(!hhook, "global hook requires hModule != 0\n");
6075     ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %ld\n", GetLastError());
6076 #endif
6077
6078     SetLastError(0xdeadbeef);
6079     hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
6080     ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
6081     ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
6082        GetLastError() == 0xdeadbeef, /* Win9x */
6083        "unexpected error %ld\n", GetLastError());
6084
6085     SetLastError(0xdeadbeef);
6086     ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
6087     ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
6088        GetLastError() == 0xdeadbeef, /* Win9x */
6089        "unexpected error %ld\n", GetLastError());
6090
6091     if (!pSetWinEventHook || !pUnhookWinEvent) return;
6092
6093     /* even process local incontext hooks require hmodule */
6094     SetLastError(0xdeadbeef);
6095     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
6096         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
6097     ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
6098     ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
6099        GetLastError() == 0xdeadbeef, /* Win9x */
6100        "unexpected error %ld\n", GetLastError());
6101
6102     /* even thread local incontext hooks require hmodule */
6103     SetLastError(0xdeadbeef);
6104     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
6105         0, win_event_proc, GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
6106     ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
6107     ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
6108        GetLastError() == 0xdeadbeef, /* Win9x */
6109        "unexpected error %ld\n", GetLastError());
6110
6111 #if 0 /* these 3 tests don't pass under Win9x */
6112     SetLastError(0xdeadbeef);
6113     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(1, 0,
6114         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
6115     ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
6116     ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %ld\n", GetLastError());
6117
6118     SetLastError(0xdeadbeef);
6119     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(-1, 1,
6120         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
6121     ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
6122     ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %ld\n", GetLastError());
6123
6124     SetLastError(0xdeadbeef);
6125     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
6126         0, win_event_proc, 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
6127     ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
6128     ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %ld\n", GetLastError());
6129 #endif
6130
6131     SetLastError(0xdeadbeef);
6132     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(0, 0,
6133         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
6134     ok(hwinevent_hook != 0, "SetWinEventHook error %ld\n", GetLastError());
6135     ok(GetLastError() == 0xdeadbeef, "unexpected error %ld\n", GetLastError());
6136     ret = pUnhookWinEvent(hwinevent_hook);
6137     ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
6138
6139 todo_wine {
6140     /* This call succeeds under win2k SP4, but fails under Wine.
6141        Does win2k test/use passed process id? */
6142     SetLastError(0xdeadbeef);
6143     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
6144         0, win_event_proc, 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
6145     ok(hwinevent_hook != 0, "SetWinEventHook error %ld\n", GetLastError());
6146     ok(GetLastError() == 0xdeadbeef, "unexpected error %ld\n", GetLastError());
6147     ret = pUnhookWinEvent(hwinevent_hook);
6148     ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
6149 }
6150
6151     SetLastError(0xdeadbeef);
6152     ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
6153     ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
6154         GetLastError() == 0xdeadbeef, /* Win9x */
6155         "unexpected error %ld\n", GetLastError());
6156 }
6157
6158 static const struct message ScrollWindowPaint1[] = {
6159     { WM_PAINT, sent },
6160     { WM_ERASEBKGND, sent|beginpaint },
6161     { 0 }
6162 };
6163
6164 static const struct message ScrollWindowPaint2[] = {
6165     { WM_PAINT, sent },
6166     { 0 }
6167 };
6168
6169 static void test_scrollwindowex(void)
6170 {
6171     HWND hwnd, hchild;
6172     RECT rect={0,0,130,130};
6173     MSG msg;
6174
6175     hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
6176             WS_VISIBLE|WS_OVERLAPPEDWINDOW,
6177             100, 100, 200, 200, 0, 0, 0, NULL);
6178     ok (hwnd != 0, "Failed to create overlapped window\n");
6179     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", 
6180             WS_VISIBLE|WS_CAPTION|WS_CHILD,
6181             10, 10, 150, 150, hwnd, 0, 0, NULL);
6182     ok (hchild != 0, "Failed to create child\n");
6183     UpdateWindow(hwnd);
6184     flush_events();
6185     flush_sequence();
6186
6187     /* scroll without the child window */
6188     trace("start scroll\n");
6189     ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
6190             SW_ERASE|SW_INVALIDATE);
6191     ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
6192     trace("end scroll\n");
6193     flush_sequence();
6194     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6195     ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
6196
6197     /* Now without the SW_ERASE flag */
6198     trace("start scroll\n");
6199     ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
6200     ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
6201     trace("end scroll\n");
6202     flush_sequence();
6203     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6204     ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", 0);
6205
6206     /* now scroll the child window as well */
6207     trace("start scroll\n");
6208     ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
6209             SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
6210     todo_wine { /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
6211                 /* windows sometimes a WM_MOVE */
6212         ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
6213     }
6214     trace("end scroll\n");
6215     flush_sequence();
6216     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6217     ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
6218
6219     /* now scroll with ScrollWindow() */
6220     trace("start scroll with ScrollWindow\n");
6221     ScrollWindow( hwnd, 5, 5, NULL, NULL);
6222     trace("end scroll\n");
6223     flush_sequence();
6224     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6225     ok_sequence(ScrollWindowPaint1, "ScrollWindow", 0);
6226
6227     ok(DestroyWindow(hchild), "failed to destroy window\n");
6228     ok(DestroyWindow(hwnd), "failed to destroy window\n");
6229     flush_sequence();
6230 }
6231
6232 static const struct message destroy_window_with_children[] = {
6233     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
6234     { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
6235     { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
6236     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
6237     { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
6238     { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
6239     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
6240     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
6241     { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
6242     { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
6243     { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
6244     { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
6245     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
6246     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
6247     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
6248     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
6249     { 0 }
6250 };
6251
6252 static void test_DestroyWindow(void)
6253 {
6254     BOOL ret;
6255     HWND parent, child1, child2, child3, child4, test;
6256     UINT child_id = WND_CHILD_ID + 1;
6257
6258     parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
6259                              100, 100, 200, 200, 0, 0, 0, NULL);
6260     assert(parent != 0);
6261     child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
6262                              0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
6263     assert(child1 != 0);
6264     child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
6265                              0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
6266     assert(child2 != 0);
6267     child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
6268                              0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
6269     assert(child3 != 0);
6270     child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
6271                              0, 0, 50, 50, parent, 0, 0, NULL);
6272     assert(child4 != 0);
6273
6274     /* test owner/parent of child2 */
6275     test = GetParent(child2);
6276     ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
6277     ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
6278     if(pGetAncestor) {
6279         test = pGetAncestor(child2, GA_PARENT);
6280         ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
6281     }
6282     test = GetWindow(child2, GW_OWNER);
6283     ok(!test, "wrong owner %p\n", test);
6284
6285     test = SetParent(child2, parent);
6286     ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
6287
6288     /* test owner/parent of the parent */
6289     test = GetParent(parent);
6290     ok(!test, "wrong parent %p\n", test);
6291 todo_wine {
6292     ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
6293 }
6294     if(pGetAncestor) {
6295         test = pGetAncestor(parent, GA_PARENT);
6296         ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
6297     }
6298     test = GetWindow(parent, GW_OWNER);
6299     ok(!test, "wrong owner %p\n", test);
6300
6301     /* test owner/parent of child1 */
6302     test = GetParent(child1);
6303     ok(test == parent, "wrong parent %p\n", test);
6304     ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
6305     if(pGetAncestor) {
6306         test = pGetAncestor(child1, GA_PARENT);
6307         ok(test == parent, "wrong parent %p\n", test);
6308     }
6309     test = GetWindow(child1, GW_OWNER);
6310     ok(!test, "wrong owner %p\n", test);
6311
6312     /* test owner/parent of child2 */
6313     test = GetParent(child2);
6314     ok(test == parent, "wrong parent %p\n", test);
6315     ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
6316     if(pGetAncestor) {
6317         test = pGetAncestor(child2, GA_PARENT);
6318         ok(test == parent, "wrong parent %p\n", test);
6319     }
6320     test = GetWindow(child2, GW_OWNER);
6321     ok(!test, "wrong owner %p\n", test);
6322
6323     /* test owner/parent of child3 */
6324     test = GetParent(child3);
6325     ok(test == child1, "wrong parent %p\n", test);
6326     ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
6327     if(pGetAncestor) {
6328         test = pGetAncestor(child3, GA_PARENT);
6329         ok(test == child1, "wrong parent %p\n", test);
6330     }
6331     test = GetWindow(child3, GW_OWNER);
6332     ok(!test, "wrong owner %p\n", test);
6333
6334     /* test owner/parent of child4 */
6335     test = GetParent(child4);
6336     ok(test == parent, "wrong parent %p\n", test);
6337     ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
6338     if(pGetAncestor) {
6339         test = pGetAncestor(child4, GA_PARENT);
6340         ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
6341     }
6342     test = GetWindow(child4, GW_OWNER);
6343     ok(test == parent, "wrong owner %p\n", test);
6344
6345     flush_sequence();
6346
6347     trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
6348            parent, child1, child2, child3, child4);
6349
6350     SetCapture(child4);
6351     test = GetCapture();
6352     ok(test == child4, "wrong capture window %p\n", test);
6353
6354     test_DestroyWindow_flag = TRUE;
6355     ret = DestroyWindow(parent);
6356     ok( ret, "DestroyWindow() error %ld\n", GetLastError());
6357     test_DestroyWindow_flag = FALSE;
6358     ok_sequence(destroy_window_with_children, "destroy window with children", 0);
6359
6360     ok(!IsWindow(parent), "parent still exists\n");
6361     ok(!IsWindow(child1), "child1 still exists\n");
6362     ok(!IsWindow(child2), "child2 still exists\n");
6363     ok(!IsWindow(child3), "child3 still exists\n");
6364     ok(!IsWindow(child4), "child4 still exists\n");
6365
6366     test = GetCapture();
6367     ok(!test, "wrong capture window %p\n", test);
6368 }
6369
6370
6371 static const struct message WmDispatchPaint[] = {
6372     { WM_NCPAINT, sent },
6373     { WM_GETTEXT, sent|defwinproc|optional },
6374     { WM_GETTEXT, sent|defwinproc|optional },
6375     { WM_ERASEBKGND, sent },
6376     { 0 }
6377 };
6378
6379 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6380 {
6381     if (message == WM_PAINT) return 0;
6382     return MsgCheckProcA( hwnd, message, wParam, lParam );
6383 }
6384
6385 static void test_DispatchMessage(void)
6386 {
6387     RECT rect;
6388     MSG msg;
6389     int count;
6390     HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
6391                                100, 100, 200, 200, 0, 0, 0, NULL);
6392     ShowWindow( hwnd, SW_SHOW );
6393     UpdateWindow( hwnd );
6394     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6395     flush_sequence();
6396     SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
6397
6398     SetRect( &rect, -5, -5, 5, 5 );
6399     RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
6400     count = 0;
6401     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
6402     {
6403         if (msg.message != WM_PAINT) DispatchMessage( &msg );
6404         else
6405         {
6406             flush_sequence();
6407             DispatchMessage( &msg );
6408             /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
6409             if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
6410             else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
6411             if (++count > 10) break;
6412         }
6413     }
6414     ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
6415
6416     trace("now without DispatchMessage\n");
6417     flush_sequence();
6418     RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
6419     count = 0;
6420     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
6421     {
6422         if (msg.message != WM_PAINT) DispatchMessage( &msg );
6423         else
6424         {
6425             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
6426             flush_sequence();
6427             /* this will send WM_NCCPAINT just like DispatchMessage does */
6428             GetUpdateRgn( hwnd, hrgn, TRUE );
6429             ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
6430             DeleteObject( hrgn );
6431             GetClientRect( hwnd, &rect );
6432             ValidateRect( hwnd, &rect );  /* this will stop WM_PAINTs */
6433             ok( !count, "Got multiple WM_PAINTs\n" );
6434             if (++count > 10) break;
6435         }
6436     }
6437     DestroyWindow(hwnd);
6438 }
6439
6440
6441 static const struct message WmUser[] = {
6442     { WM_USER, sent },
6443     { 0 }
6444 };
6445
6446 struct sendmsg_info
6447 {
6448     HWND  hwnd;
6449     DWORD timeout;
6450     DWORD ret;
6451 };
6452
6453 static DWORD CALLBACK send_msg_thread( LPVOID arg )
6454 {
6455     struct sendmsg_info *info = arg;
6456     info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
6457     if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT, "unexpected error %ld\n", GetLastError());
6458     return 0;
6459 }
6460
6461 static void wait_for_thread( HANDLE thread )
6462 {
6463     while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
6464     {
6465         MSG msg;
6466         while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage(&msg);
6467     }
6468 }
6469
6470 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6471 {
6472     if (message == WM_USER) Sleep(200);
6473     return MsgCheckProcA( hwnd, message, wParam, lParam );
6474 }
6475
6476 static void test_SendMessageTimeout(void)
6477 {
6478     MSG msg;
6479     HANDLE thread;
6480     struct sendmsg_info info;
6481     DWORD tid;
6482
6483     info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
6484                                100, 100, 200, 200, 0, 0, 0, NULL);
6485     while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
6486     flush_sequence();
6487
6488     info.timeout = 1000;
6489     info.ret = 0xdeadbeef;
6490     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
6491     wait_for_thread( thread );
6492     CloseHandle( thread );
6493     ok( info.ret == 1, "SendMessageTimeout failed\n" );
6494     ok_sequence( WmUser, "WmUser", FALSE );
6495
6496     info.timeout = 1;
6497     info.ret = 0xdeadbeef;
6498     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
6499     Sleep(100);  /* SendMessageTimeout should timeout here */
6500     wait_for_thread( thread );
6501     CloseHandle( thread );
6502     ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
6503     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6504
6505     /* 0 means infinite timeout */
6506     info.timeout = 0;
6507     info.ret = 0xdeadbeef;
6508     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
6509     Sleep(100);
6510     wait_for_thread( thread );
6511     CloseHandle( thread );
6512     ok( info.ret == 1, "SendMessageTimeout failed\n" );
6513     ok_sequence( WmUser, "WmUser", FALSE );
6514
6515     /* timeout is treated as signed despite the prototype */
6516     info.timeout = 0x7fffffff;
6517     info.ret = 0xdeadbeef;
6518     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
6519     Sleep(100);
6520     wait_for_thread( thread );
6521     CloseHandle( thread );
6522     ok( info.ret == 1, "SendMessageTimeout failed\n" );
6523     ok_sequence( WmUser, "WmUser", FALSE );
6524
6525     info.timeout = 0x80000000;
6526     info.ret = 0xdeadbeef;
6527     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
6528     Sleep(100);
6529     wait_for_thread( thread );
6530     CloseHandle( thread );
6531     ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
6532     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
6533
6534     /* now check for timeout during message processing */
6535     SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
6536     info.timeout = 100;
6537     info.ret = 0xdeadbeef;
6538     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
6539     wait_for_thread( thread );
6540     CloseHandle( thread );
6541     /* we should timeout but still get the message */
6542     ok( info.ret == 0, "SendMessageTimeout failed\n" );
6543     ok_sequence( WmUser, "WmUser", FALSE );
6544
6545     DestroyWindow( info.hwnd );
6546 }
6547
6548
6549 /****************** edit message test *************************/
6550 #define ID_EDIT 0x1234
6551 static const struct message sl_edit_setfocus[] =
6552 {
6553     { HCBT_SETFOCUS, hook },
6554     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
6555     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
6556     { WM_SETFOCUS, sent|wparam, 0 },
6557     { WM_CTLCOLOREDIT, sent|parent },
6558     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6559     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6560     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
6561     { 0 }
6562 };
6563 static const struct message ml_edit_setfocus[] =
6564 {
6565     { HCBT_SETFOCUS, hook },
6566     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
6567     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
6568     { WM_SETFOCUS, sent|wparam, 0 },
6569     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6570     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6571     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6572     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
6573     { 0 }
6574 };
6575 static const struct message sl_edit_killfocus[] =
6576 {
6577     { HCBT_SETFOCUS, hook },
6578     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
6579     { WM_KILLFOCUS, sent|wparam, 0 },
6580     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6581     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6582     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
6583     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
6584     { 0 }
6585 };
6586 static const struct message sl_edit_lbutton_dblclk[] =
6587 {
6588     { WM_LBUTTONDBLCLK, sent },
6589     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6590     { 0 }
6591 };
6592 static const struct message sl_edit_lbutton_down[] =
6593 {
6594     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
6595     { HCBT_SETFOCUS, hook },
6596     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
6597     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
6598     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
6599     { WM_CTLCOLOREDIT, sent|parent },
6600     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6601     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6602     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6603     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
6604     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6605     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6606     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6607     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6608     { 0 }
6609 };
6610 static const struct message ml_edit_lbutton_down[] =
6611 {
6612     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
6613     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6614     { HCBT_SETFOCUS, hook },
6615     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
6616     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
6617     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
6618     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6619     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6620     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
6621     { 0 }
6622 };
6623 static const struct message sl_edit_lbutton_up[] =
6624 {
6625     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
6626     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6627     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
6628     { WM_CAPTURECHANGED, sent|defwinproc },
6629     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
6630     { 0 }
6631 };
6632 static const struct message ml_edit_lbutton_up[] =
6633 {
6634     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
6635     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
6636     { WM_CAPTURECHANGED, sent|defwinproc },
6637     { 0 }
6638 };
6639
6640 static WNDPROC old_edit_proc;
6641
6642 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6643 {
6644     static long defwndproc_counter = 0;
6645     LRESULT ret;
6646     struct message msg;
6647
6648     trace("edit: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);
6649
6650     /* explicitly ignore WM_GETICON message */
6651     if (message == WM_GETICON) return 0;
6652
6653     msg.message = message;
6654     msg.flags = sent|wparam|lparam;
6655     if (defwndproc_counter) msg.flags |= defwinproc;
6656     msg.wParam = wParam;
6657     msg.lParam = lParam;
6658     add_message(&msg);
6659
6660     defwndproc_counter++;
6661     ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
6662     defwndproc_counter--;
6663
6664     return ret;
6665 }
6666
6667 static void subclass_edit(void)
6668 {
6669     WNDCLASSA cls;
6670
6671     if (!GetClassInfoA(0, "edit", &cls)) assert(0);
6672
6673     old_edit_proc = cls.lpfnWndProc;
6674
6675     cls.hInstance = GetModuleHandle(0);
6676     cls.lpfnWndProc = edit_hook_proc;
6677     cls.lpszClassName = "my_edit_class";
6678     if (!RegisterClassA(&cls)) assert(0);
6679 }
6680
6681 static void test_edit_messages(void)
6682 {
6683     HWND hwnd, parent;
6684     DWORD dlg_code;
6685
6686     subclass_edit();
6687     log_all_parent_messages++;
6688
6689     parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6690                              100, 100, 200, 200, 0, 0, 0, NULL);
6691     ok (parent != 0, "Failed to create parent window\n");
6692
6693     /* test single line edit */
6694     hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
6695                            0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
6696     ok(hwnd != 0, "Failed to create edit window\n");
6697
6698     dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
6699     ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08lx\n", dlg_code);
6700
6701     ShowWindow(hwnd, SW_SHOW);
6702     UpdateWindow(hwnd);
6703     SetFocus(0);
6704     flush_sequence();
6705
6706     SetFocus(hwnd);
6707     ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
6708
6709     SetFocus(0);
6710     ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
6711
6712     SetFocus(0);
6713     ReleaseCapture();
6714     flush_sequence();
6715
6716     SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
6717     ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
6718
6719     SetFocus(0);
6720     ReleaseCapture();
6721     flush_sequence();
6722
6723     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
6724     ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
6725
6726     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
6727     ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
6728
6729     DestroyWindow(hwnd);
6730
6731     /* test multiline edit */
6732     hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
6733                            0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
6734     ok(hwnd != 0, "Failed to create edit window\n");
6735
6736     dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
6737     ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
6738        "wrong dlg_code %08lx\n", dlg_code);
6739
6740     ShowWindow(hwnd, SW_SHOW);
6741     UpdateWindow(hwnd);
6742     SetFocus(0);
6743     flush_sequence();
6744
6745     SetFocus(hwnd);
6746     ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
6747
6748     SetFocus(0);
6749     ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
6750
6751     SetFocus(0);
6752     ReleaseCapture();
6753     flush_sequence();
6754
6755     SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
6756     ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
6757
6758     SetFocus(0);
6759     ReleaseCapture();
6760     flush_sequence();
6761
6762     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
6763     ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
6764
6765     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
6766     ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
6767
6768     DestroyWindow(hwnd);
6769     DestroyWindow(parent);
6770
6771     log_all_parent_messages--;
6772 }
6773
6774 /**************************** End of Edit test ******************************/
6775
6776 static const struct message WmChar[] = {
6777     { WM_CHAR, sent|wparam, 'z' },
6778     { 0 }
6779 };
6780
6781 static const struct message WmKeyDownUp[] = {
6782     { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x00000001 },
6783     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6784     { 0 }
6785 };
6786
6787 static const struct message WmUserChar[] = {
6788     { WM_USER, sent },
6789     { WM_CHAR, sent|wparam, 'z' },
6790     { 0 }
6791 };
6792
6793 #define EV_START_STOP 0
6794 #define EV_SENDMSG 1
6795 #define EV_ACK 2
6796
6797 struct peekmsg_info
6798 {
6799     HWND  hwnd;
6800     HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
6801 };
6802
6803 static DWORD CALLBACK send_msg_thread_2(void *param)
6804 {
6805     DWORD ret;
6806     struct peekmsg_info *info = param;
6807
6808     trace("thread: waiting for start\n");
6809     WaitForSingleObject(info->hevent[EV_START_STOP], INFINITE);
6810     trace("thread: looping\n");
6811
6812     while (1)
6813     {
6814         ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
6815
6816         switch (ret)
6817         {
6818         case WAIT_OBJECT_0 + EV_START_STOP:
6819             trace("thread: exiting\n");
6820             return 0;
6821
6822         case WAIT_OBJECT_0 + EV_SENDMSG:
6823             trace("thread: sending message\n");
6824             SendNotifyMessageA(info->hwnd, WM_USER, 0, 0);
6825             SetEvent(info->hevent[EV_ACK]);
6826             break;
6827
6828         default:
6829             trace("unexpected return: %04lx\n", ret);
6830             assert(0);
6831             break;
6832         }
6833     }
6834     return 0;
6835 }
6836
6837 static void test_PeekMessage(void)
6838 {
6839     MSG msg;
6840     HANDLE hthread;
6841     DWORD tid, qstatus;
6842     UINT qs_all_input = QS_ALLINPUT;
6843     UINT qs_input = QS_INPUT;
6844     struct peekmsg_info info;
6845
6846     info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
6847                               100, 100, 200, 200, 0, 0, 0, NULL);
6848     ShowWindow(info.hwnd, SW_SHOW);
6849     UpdateWindow(info.hwnd);
6850
6851     info.hevent[EV_START_STOP] = CreateEventA(NULL, 0, 0, NULL);
6852     info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
6853     info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
6854
6855     hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
6856
6857     trace("signalling to start looping\n");
6858     SetEvent(info.hevent[EV_START_STOP]);
6859
6860     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6861     flush_sequence();
6862
6863     SetLastError(0xdeadbeef);
6864     qstatus = GetQueueStatus(qs_all_input);
6865     if (GetLastError() == ERROR_INVALID_FLAGS)
6866     {
6867         trace("QS_RAWINPUT not supported on this platform\n");
6868         qs_all_input &= ~QS_RAWINPUT;
6869         qs_input &= ~QS_RAWINPUT;
6870     }
6871     ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
6872
6873     trace("signalling to send message\n");
6874     SetEvent(info.hevent[EV_SENDMSG]);
6875     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
6876
6877     /* pass invalid QS_xxxx flags */
6878     SetLastError(0xdeadbeef);
6879     qstatus = GetQueueStatus(0xffffffff);
6880     ok(qstatus == 0, "GetQueueStatus should fail: %08lx\n", qstatus);
6881     ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %ld\n", GetLastError());
6882
6883     qstatus = GetQueueStatus(qs_all_input);
6884     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
6885        "wrong qstatus %08lx\n", qstatus);
6886
6887     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
6888     ok_sequence(WmUser, "WmUser", FALSE);
6889
6890     qstatus = GetQueueStatus(qs_all_input);
6891     ok(qstatus == 0, "wrong qstatus %08lx\n", qstatus);
6892
6893     keybd_event('N', 0, 0, 0);
6894     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6895     qstatus = GetQueueStatus(qs_all_input);
6896     ok(qstatus == MAKELONG(QS_KEY, QS_KEY),
6897        "wrong qstatus %08lx\n", qstatus);
6898
6899     PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
6900     qstatus = GetQueueStatus(qs_all_input);
6901     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
6902        "wrong qstatus %08lx\n", qstatus);
6903
6904     InvalidateRect(info.hwnd, NULL, FALSE);
6905     qstatus = GetQueueStatus(qs_all_input);
6906     ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
6907        "wrong qstatus %08lx\n", qstatus);
6908
6909     trace("signalling to send message\n");
6910     SetEvent(info.hevent[EV_SENDMSG]);
6911     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
6912
6913     qstatus = GetQueueStatus(qs_all_input);
6914     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
6915        "wrong qstatus %08lx\n", qstatus);
6916     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16))) DispatchMessageA(&msg);
6917     ok_sequence(WmUser, "WmUser", TRUE); /* todo_wine */
6918
6919     qstatus = GetQueueStatus(qs_all_input);
6920 todo_wine {
6921     ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
6922        "wrong qstatus %08lx\n", qstatus);
6923 }
6924
6925     trace("signalling to send message\n");
6926     SetEvent(info.hevent[EV_SENDMSG]);
6927     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
6928
6929     qstatus = GetQueueStatus(qs_all_input);
6930 todo_wine {
6931     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
6932        "wrong qstatus %08lx\n", qstatus);
6933 }
6934     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE)) DispatchMessageA(&msg);
6935     ok_sequence(WmUser, "WmUser", FALSE);
6936
6937     qstatus = GetQueueStatus(qs_all_input);
6938 todo_wine {
6939     ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
6940        "wrong qstatus %08lx\n", qstatus);
6941 }
6942
6943     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE)) DispatchMessageA(&msg);
6944     ok_sequence(WmChar, "WmChar", TRUE); /* todo_wine */
6945
6946     qstatus = GetQueueStatus(qs_all_input);
6947 todo_wine {
6948     ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
6949        "wrong qstatus %08lx\n", qstatus);
6950 }
6951
6952     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT)) DispatchMessageA(&msg);
6953     ok_sequence(WmPaint, "WmPaint", TRUE); /* todo_wine */
6954
6955     qstatus = GetQueueStatus(qs_all_input);
6956 todo_wine {
6957     ok(qstatus == MAKELONG(0, QS_KEY),
6958        "wrong qstatus %08lx\n", qstatus);
6959 }
6960
6961     trace("signalling to send message\n");
6962     SetEvent(info.hevent[EV_SENDMSG]);
6963     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
6964
6965     qstatus = GetQueueStatus(qs_all_input);
6966 todo_wine {
6967     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
6968        "wrong qstatus %08lx\n", qstatus);
6969 }
6970
6971     PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
6972
6973     qstatus = GetQueueStatus(qs_all_input);
6974 todo_wine {
6975     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
6976        "wrong qstatus %08lx\n", qstatus);
6977 }
6978
6979     while (PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE)) DispatchMessage(&msg);
6980     ok_sequence(WmUserChar, "WmUserChar", FALSE);
6981
6982     qstatus = GetQueueStatus(qs_all_input);
6983 todo_wine {
6984     ok(qstatus == MAKELONG(0, QS_KEY),
6985        "wrong qstatus %08lx\n", qstatus);
6986 }
6987
6988     PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
6989
6990     qstatus = GetQueueStatus(qs_all_input);
6991 todo_wine {
6992     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
6993        "wrong qstatus %08lx\n", qstatus);
6994 }
6995
6996     trace("signalling to send message\n");
6997     SetEvent(info.hevent[EV_SENDMSG]);
6998     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
6999
7000     qstatus = GetQueueStatus(qs_all_input);
7001 todo_wine {
7002     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
7003        "wrong qstatus %08lx\n", qstatus);
7004 }
7005
7006     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16))) DispatchMessage(&msg);
7007     ok_sequence(WmUser, "WmUser", TRUE); /* todo_wine */
7008
7009     qstatus = GetQueueStatus(qs_all_input);
7010 todo_wine {
7011     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
7012        "wrong qstatus %08lx\n", qstatus);
7013 }
7014
7015     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16))) DispatchMessage(&msg);
7016     ok_sequence(WmKeyDownUp, "WmKeyDownUp", TRUE); /* todo_wine */
7017
7018     qstatus = GetQueueStatus(qs_all_input);
7019 todo_wine {
7020     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
7021        "wrong qstatus %08lx\n", qstatus);
7022 }
7023
7024     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE)) DispatchMessage(&msg);
7025     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
7026
7027     qstatus = GetQueueStatus(qs_all_input);
7028 todo_wine {
7029     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
7030        "wrong qstatus %08lx\n", qstatus);
7031 }
7032
7033     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
7034     ok_sequence(WmChar, "WmChar", TRUE); /* todo_wine */
7035
7036     qstatus = GetQueueStatus(qs_all_input);
7037     ok(qstatus == 0,
7038        "wrong qstatus %08lx\n", qstatus);
7039
7040     trace("signalling to exit\n");
7041     SetEvent(info.hevent[EV_START_STOP]);
7042
7043     WaitForSingleObject(hthread, INFINITE);
7044
7045     CloseHandle(hthread);
7046     CloseHandle(info.hevent[0]);
7047     CloseHandle(info.hevent[1]);
7048     CloseHandle(info.hevent[2]);
7049
7050     DestroyWindow(info.hwnd);
7051 }
7052
7053
7054 static void test_quit_message(void)
7055 {
7056     MSG msg;
7057     BOOL ret;
7058
7059     /* test using PostQuitMessage */
7060     PostQuitMessage(0xbeef);
7061
7062     ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
7063     ok(ret, "PeekMessage failed with error %ld\n", GetLastError());
7064     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
7065     ok(msg.wParam == 0xbeef, "wParam was 0x%x instead of 0xbeef\n", msg.wParam);
7066
7067     ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
7068     ok(ret, "PostMessage failed with error %ld\n", GetLastError());
7069
7070     ret = GetMessage(&msg, NULL, 0, 0);
7071     ok(ret > 0, "GetMessage failed with error %ld\n", GetLastError());
7072     ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
7073
7074     /* note: WM_QUIT message received after WM_USER message */
7075     ret = GetMessage(&msg, NULL, 0, 0);
7076     ok(!ret, "GetMessage return %d with error %ld instead of FALSE\n", ret, GetLastError());
7077     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
7078     ok(msg.wParam == 0xbeef, "wParam was 0x%x instead of 0xbeef\n", msg.wParam);
7079
7080     ret = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
7081     ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
7082
7083     /* now test with PostThreadMessage - different behaviour! */
7084     PostThreadMessage(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
7085
7086     ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
7087     ok(ret, "PeekMessage failed with error %ld\n", GetLastError());
7088     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
7089     ok(msg.wParam == 0xdead, "wParam was 0x%x instead of 0xdead\n", msg.wParam);
7090
7091     ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
7092     ok(ret, "PostMessage failed with error %ld\n", GetLastError());
7093
7094     /* note: we receive the WM_QUIT message first this time */
7095     ret = GetMessage(&msg, NULL, 0, 0);
7096     ok(!ret, "GetMessage return %d with error %ld instead of FALSE\n", ret, GetLastError());
7097     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
7098     ok(msg.wParam == 0xdead, "wParam was 0x%x instead of 0xdead\n", msg.wParam);
7099
7100     ret = GetMessage(&msg, NULL, 0, 0);
7101     ok(ret > 0, "GetMessage failed with error %ld\n", GetLastError());
7102     ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
7103 }
7104
7105 START_TEST(msg)
7106 {
7107     BOOL ret;
7108     HMODULE user32 = GetModuleHandleA("user32.dll");
7109     FARPROC pSetWinEventHook = GetProcAddress(user32, "SetWinEventHook");
7110     FARPROC pUnhookWinEvent = GetProcAddress(user32, "UnhookWinEvent");
7111     FARPROC pIsWinEventHookInstalled = 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
7112     pGetAncestor = (void*) GetProcAddress(user32, "GetAncestor");
7113
7114     if (!RegisterWindowClasses()) assert(0);
7115
7116     if (pSetWinEventHook)
7117     {
7118         hEvent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
7119                                                       GetModuleHandleA(0),
7120                                                       win_event_proc,
7121                                                       0,
7122                                                       GetCurrentThreadId(),
7123                                                       WINEVENT_INCONTEXT);
7124         assert(hEvent_hook);
7125
7126         if (pIsWinEventHookInstalled)
7127         {
7128             UINT event;
7129             for (event = EVENT_MIN; event <= EVENT_MAX; event++)
7130                 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
7131         }
7132     }
7133
7134     cbt_hook_thread_id = GetCurrentThreadId();
7135     hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
7136     assert(hCBT_hook);
7137
7138     test_winevents();
7139
7140     /* Fix message sequences before removing 4 lines below */
7141 #if 1
7142     ret = pUnhookWinEvent(hEvent_hook);
7143     ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
7144     pUnhookWinEvent = 0;
7145     hEvent_hook = 0;
7146 #endif
7147
7148     test_PeekMessage();
7149     test_scrollwindowex();
7150     test_messages();
7151     test_mdi_messages();
7152     test_button_messages();
7153     test_paint_messages();
7154     test_interthread_messages();
7155     test_message_conversion();
7156     test_accelerators();
7157     test_timers();
7158     test_set_hook();
7159     test_DestroyWindow();
7160     test_DispatchMessage();
7161     test_SendMessageTimeout();
7162     test_edit_messages();
7163     test_quit_message();
7164
7165     UnhookWindowsHookEx(hCBT_hook);
7166     if (pUnhookWinEvent)
7167     {
7168         ret = pUnhookWinEvent(hEvent_hook);
7169         ok( ret, "UnhookWinEvent error %ld\n", GetLastError());
7170         SetLastError(0xdeadbeef);
7171         ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
7172         ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
7173            GetLastError() == 0xdeadbeef, /* Win9x */
7174            "unexpected error %ld\n", GetLastError());
7175     }
7176 }
WINE + custom patches