projects / wine / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
comctl32: We can now store binary files in the repository.
[wine] / dlls / user32 / 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 #define SWP_STATECHANGED        0x8000
43
44 #define SW_NORMALNA             0xCC    /* undoc. flag in MinMaximize */
45
46 #ifndef WM_SYSTIMER
47 #define WM_SYSTIMER         0x0118
48 #endif
49
50 #define WND_PARENT_ID           1
51 #define WND_POPUP_ID            2
52 #define WND_CHILD_ID            3
53
54 static BOOL test_DestroyWindow_flag;
55 static HWINEVENTHOOK hEvent_hook;
56
57 static void dump_winpos_flags(UINT flags);
58
59 static const WCHAR testWindowClassW[] =
60 { 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
61
62 /*
63 FIXME: add tests for these
64 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
65  WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
66  WS_THICKFRAME: thick border
67  WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
68  WS_BORDER (default for overlapped windows): single black border
69  none (default for child (and popup?) windows): no border
70 */
71
72 typedef enum {
73     sent=0x1,
74     posted=0x2,
75     parent=0x4,
76     wparam=0x8,
77     lparam=0x10,
78     defwinproc=0x20,
79     beginpaint=0x40,
80     optional=0x80,
81     hook=0x100,
82     winevent_hook=0x200
83 } msg_flags_t;
84
85 struct message {
86     UINT message;          /* the WM_* code */
87     msg_flags_t flags;     /* message props */
88     WPARAM wParam;         /* expected value of wParam */
89     LPARAM lParam;         /* expected value of lParam */
90 };
91
92 /* Empty message sequence */
93 static const struct message WmEmptySeq[] =
94 {
95     { 0 }
96 };
97 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
98 static const struct message WmCreateOverlappedSeq[] = {
99     { HCBT_CREATEWND, hook },
100     { WM_GETMINMAXINFO, sent },
101     { WM_NCCREATE, sent },
102     { WM_NCCALCSIZE, sent|wparam, 0 },
103     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
104     { WM_CREATE, sent },
105     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
106     { 0 }
107 };
108 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
109  * for a not visible overlapped window.
110  */
111 static const struct message WmSWP_ShowOverlappedSeq[] = {
112     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
113     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
114     { WM_NCPAINT, sent|wparam|optional, 1 },
115     { WM_GETTEXT, sent|defwinproc|optional },
116     { WM_ERASEBKGND, sent|optional },
117     { HCBT_ACTIVATE, hook },
118     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
119     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
120     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
121     { WM_ACTIVATEAPP, sent|wparam, 1 },
122     { WM_NCACTIVATE, sent|wparam, 1 },
123     { WM_GETTEXT, sent|defwinproc|optional },
124     { WM_ACTIVATE, sent|wparam, 1 },
125     { HCBT_SETFOCUS, hook },
126     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
127     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
128     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
129     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
130     { WM_NCPAINT, sent|wparam|optional, 1 },
131     { WM_GETTEXT, sent|defwinproc|optional },
132     { WM_ERASEBKGND, sent|optional },
133     /* Win9x adds SWP_NOZORDER below */
134     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
135     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
136     { WM_NCPAINT, sent|wparam|optional, 1 },
137     { WM_ERASEBKGND, sent|optional },
138     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
139     { 0 }
140 };
141 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
142  * for a visible overlapped window.
143  */
144 static const struct message WmSWP_HideOverlappedSeq[] = {
145     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
146     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
147     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
148     { 0 }
149 };
150
151 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
152  * for a visible overlapped window.
153  */
154 static const struct message WmSWP_ResizeSeq[] = {
155     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
156     { WM_GETMINMAXINFO, sent|defwinproc },
157     { WM_NCCALCSIZE, sent|wparam, TRUE },
158     { WM_NCPAINT, sent|optional },
159     { WM_GETTEXT, sent|defwinproc|optional },
160     { WM_ERASEBKGND, sent|optional },
161     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
162     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
163     { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
164     { WM_NCPAINT, sent|optional },
165     { WM_GETTEXT, sent|defwinproc|optional },
166     { WM_ERASEBKGND, sent|optional },
167     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
168     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
169     { 0 }
170 };
171
172 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
173  * for a visible popup window.
174  */
175 static const struct message WmSWP_ResizePopupSeq[] = {
176     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
177     { WM_GETMINMAXINFO, sent|defwinproc|optional }, /* Win9x */
178     { WM_NCCALCSIZE, sent|wparam, TRUE },
179     { WM_NCPAINT, sent|optional },
180     { WM_GETTEXT, sent|defwinproc|optional },
181     { WM_ERASEBKGND, sent|optional },
182     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
183     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
184     { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
185     { WM_NCPAINT, sent|optional },
186     { WM_GETTEXT, sent|defwinproc|optional },
187     { WM_ERASEBKGND, sent|optional },
188     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
189     { 0 }
190 };
191
192 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
193  * for a visible overlapped window.
194  */
195 static const struct message WmSWP_MoveSeq[] = {
196     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE },
197     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
198     { WM_MOVE, sent|defwinproc|wparam, 0 },
199     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
200     { 0 }
201 };
202 /* Resize with SetWindowPos(SWP_NOZORDER)
203  * for a visible overlapped window
204  * SWP_NOZORDER is stripped by the logging code
205  */
206 static const struct message WmSWP_ResizeNoZOrder[] = {
207     { WM_WINDOWPOSCHANGING, sent|wparam, 0/*SWP_NOZORDER*/ },
208     { WM_GETMINMAXINFO, sent|defwinproc },
209     { WM_NCCALCSIZE, sent|wparam, 1 },
210     { WM_NCPAINT, sent },
211     { WM_GETTEXT, sent|defwinproc|optional },
212     { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
213     { WM_WINDOWPOSCHANGED, sent|wparam, /*SWP_NOZORDER|*/SWP_NOMOVE|SWP_NOCLIENTMOVE },
214     { WM_SIZE, sent|defwinproc|wparam, 0 },
215     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
216     { WM_NCPAINT, sent|optional }, /* Win9x doesn't send it */
217     { WM_GETTEXT, sent|defwinproc|optional }, /* Win9x doesn't send it */
218     { WM_ERASEBKGND, sent|optional }, /* Win9x doesn't send it */
219     { 0 }
220 };
221
222 /* Switch visible mdi children */
223 static const struct message WmSwitchChild[] = {
224     /* Switch MDI child */
225     { WM_MDIACTIVATE, sent },/* in the MDI client */
226     { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 1st MDI child */
227     { WM_CHILDACTIVATE, sent },/* in the 1st MDI child */
228     /* Deactivate 2nd MDI child */
229     { WM_NCACTIVATE, sent|defwinproc|optional },/* in the 2nd MDI child */
230     { WM_MDIACTIVATE, sent|defwinproc|optional },/* in the 2nd MDI child */
231     { WM_CREATE, hook },
232     /* Preparing for maximize and maximaze the 1st MDI child */
233     { WM_GETMINMAXINFO, sent|defwinproc|optional },/* in the 1st MDI child */
234     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_FRAMECHANGED|SWP_STATECHANGED },/* in the 1st MDI child */
235     { WM_GETMINMAXINFO, sent|defwinproc|optional },/* in the 1st MDI child */
236     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },/* in the 1st MDI child */
237     { WM_CHILDACTIVATE, sent|defwinproc|optional },/* in the 1st MDI child */
238     { WM_WINDOWPOSCHANGED, sent|defwinproc|optional },/* in the 1st MDI child */
239     { WM_MOVE, sent|defwinproc|optional },/* in the 1st MDI child */
240     { WM_SIZE, sent|defwinproc|optional },/* in the 1st MDI child */
241     /* Lock redraw 2nd MDI child */
242     { WM_SETREDRAW, sent|defwinproc|optional },/* in the 2nd MDI child */
243     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },/* in the 2nd MDI child */
244     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },/* in the 2nd MDI child */
245     { WM_WINDOWPOSCHANGED, sent|defwinproc|optional },/* in the 2nd MDI child */
246     { WM_CREATE, hook },
247     /* Restore 2nd MDI child */
248     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED  },/* in the 2nd MDI child */
249     { WM_GETMINMAXINFO, sent|defwinproc|optional },/* in the 2nd MDI child */
250     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },/* in the 2nd MDI child */
251     { WM_WINDOWPOSCHANGED, sent|defwinproc|optional },/* in the 2nd MDI child */
252     { WM_MOVE, sent|defwinproc|optional },/* in the 2nd MDI child */
253     { WM_SIZE, sent|defwinproc|optional },/* in the 2nd MDI child */
254     /* Redraw 2nd MDI child */
255     { WM_SETREDRAW, sent|defwinproc|optional },/* in the 2nd MDI child */
256     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_FRAMECHANGED|SWP_NOMOVE },/* in the 1st MDI child */
257     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },/* in the 1st MDI child */
258     { WM_WINDOWPOSCHANGED, sent|defwinproc|optional},/* in the 1st MDI child */
259     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_FRAMECHANGED|SWP_NOMOVE },/* in the MDI frame */
260     { WM_NCCALCSIZE, sent|wparam, 1 },/* in the MDI frame */
261     { WM_WINDOWPOSCHANGED, sent},/* in the MDI frame */
262     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },/* in the 1st MDI child */
263     { WM_NCACTIVATE, sent|defwinproc|optional },/* in the 1st MDI child */
264     { WM_SETVISIBLE, hook },
265     { WM_KILLFOCUS, sent|defwinproc|optional },/* in the 2nd MDI child */
266     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
267     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
268     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
269     { WM_SETFOCUS, sent },/* in the MDI client */
270     { WM_SETVISIBLE, hook},
271     { WM_KILLFOCUS, sent },/* in the MDI client */
272     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
273     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
274     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
275     { WM_SETFOCUS, sent|defwinproc|optional },/* in the 1st MDI child */
276     { WM_MDIACTIVATE, sent|defwinproc|optional },/* in the 1st MDI child */
277     { WM_WINDOWPOSCHANGED, sent },/* in the 1st MDI child */
278     { 0 }
279 };
280
281 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
282                 SWP_NOZORDER|SWP_FRAMECHANGED)
283  * for a visible overlapped window with WS_CLIPCHILDREN style set.
284  */
285 static const struct message WmSWP_FrameChanged_clip[] = {
286     { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
287     { WM_NCCALCSIZE, sent|wparam|parent, 1 },
288     { WM_NCPAINT, sent|parent }, /* wparam != 1 */
289     { WM_GETTEXT, sent|parent|defwinproc|optional },
290     { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
291     { WM_NCPAINT, sent }, /* wparam != 1 */
292     { WM_ERASEBKGND, sent },
293     { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
294     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
295     { WM_PAINT, sent },
296     { 0 }
297 };
298 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
299                 SWP_NOZORDER|SWP_FRAMECHANGED)
300  * for a visible overlapped window.
301  */
302 static const struct message WmSWP_FrameChangedDeferErase[] = {
303     { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
304     { WM_NCCALCSIZE, sent|wparam|parent, 1 },
305     { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
306     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
307     { WM_PAINT, sent|parent },
308     { WM_NCPAINT, sent|beginpaint|parent }, /* wparam != 1 */
309     { WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
310     { WM_PAINT, sent },
311     { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
312     { WM_ERASEBKGND, sent|beginpaint },
313     { 0 }
314 };
315
316 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
317                 SWP_NOZORDER|SWP_FRAMECHANGED)
318  * for a visible overlapped window without WS_CLIPCHILDREN style set.
319  */
320 static const struct message WmSWP_FrameChanged_noclip[] = {
321     { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
322     { WM_NCCALCSIZE, sent|wparam|parent, 1 },
323     { WM_NCPAINT, sent|parent }, /* wparam != 1 */
324     { WM_GETTEXT, sent|parent|defwinproc|optional },
325     { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
326     { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
327     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
328     { WM_PAINT, sent },
329     { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
330     { WM_ERASEBKGND, sent|beginpaint },
331     { 0 }
332 };
333
334 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
335 static const struct message WmShowOverlappedSeq[] = {
336     { WM_SHOWWINDOW, sent|wparam, 1 },
337     { WM_NCPAINT, sent|wparam|optional, 1 },
338     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
339     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
340     { WM_NCPAINT, sent|wparam|optional, 1 },
341     { WM_GETTEXT, sent|defwinproc|optional },
342     { WM_ERASEBKGND, sent|optional },
343     { HCBT_ACTIVATE, hook },
344     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
345     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
346     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
347     { WM_NCPAINT, sent|wparam|optional, 1 },
348     { WM_ACTIVATEAPP, sent|wparam, 1 },
349     { WM_NCACTIVATE, sent|wparam, 1 },
350     { WM_GETTEXT, sent|defwinproc|optional },
351     { WM_ACTIVATE, sent|wparam, 1 },
352     { HCBT_SETFOCUS, hook },
353     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
354     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
355     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
356     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
357     { WM_NCPAINT, sent|wparam|optional, 1 },
358     { WM_GETTEXT, sent|defwinproc|optional },
359     { WM_ERASEBKGND, sent|optional },
360     /* Win9x adds SWP_NOZORDER below */
361     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
362     { WM_NCCALCSIZE, sent|optional },
363     { WM_NCPAINT, sent|optional },
364     { WM_ERASEBKGND, sent|optional },
365 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
366        * messages. Does that mean that CreateWindow doesn't set initial
367        * window dimensions for overlapped windows?
368        */
369     { WM_SIZE, sent },
370     { WM_MOVE, sent },
371 #endif
372     { 0 }
373 };
374 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
375 static const struct message WmShowMaxOverlappedSeq[] = {
376     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
377     { WM_GETMINMAXINFO, sent },
378     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
379     { WM_GETMINMAXINFO, sent|defwinproc },
380     { WM_NCCALCSIZE, sent|wparam, TRUE },
381     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
382     { HCBT_ACTIVATE, hook },
383     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
384     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
385     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
386     { WM_ACTIVATEAPP, sent|wparam, 1 },
387     { WM_NCACTIVATE, sent|wparam, 1 },
388     { WM_GETTEXT, sent|defwinproc|optional },
389     { WM_ACTIVATE, sent|wparam, 1 },
390     { HCBT_SETFOCUS, hook },
391     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
392     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
393     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
394     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
395     { WM_NCPAINT, sent|wparam|optional, 1 },
396     { WM_GETTEXT, sent|defwinproc|optional },
397     { WM_ERASEBKGND, sent|optional },
398     /* Win9x adds SWP_NOZORDER below */
399     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
400     { WM_MOVE, sent|defwinproc },
401     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
402     { WM_NCCALCSIZE, sent|optional },
403     { WM_NCPAINT, sent|optional },
404     { WM_ERASEBKGND, sent|optional },
405     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
406     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
407     { 0 }
408 };
409 /* ShowWindow(SW_SHOWMINIMIZED) for a not visible overlapped window */
410 static const struct message WmShowMinOverlappedSeq[] = {
411     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
412     { HCBT_SETFOCUS, hook },
413     { WM_KILLFOCUS, sent },
414     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
415     { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
416     { WM_GETTEXT, sent|optional },
417     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCOPYBITS|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
418     { WM_GETMINMAXINFO, sent|defwinproc },
419     { WM_NCCALCSIZE, sent|wparam, TRUE },
420     { WM_NCPAINT, sent },
421     { WM_GETTEXT, sent|defwinproc|optional },
422     { WM_WINDOWPOSCHANGED, sent },
423     { WM_MOVE, sent|defwinproc },
424     { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
425     { WM_NCCALCSIZE, sent|optional },
426     { WM_NCACTIVATE, sent|wparam, 0 },
427     { WM_GETTEXT, sent|defwinproc|optional },
428     { WM_ACTIVATE, sent },
429     { WM_ACTIVATEAPP, sent|wparam, 0 },
430     { 0 }
431 };
432 /* ShowWindow(SW_HIDE) for a visible overlapped window */
433 static const struct message WmHideOverlappedSeq[] = {
434     { WM_SHOWWINDOW, sent|wparam, 0 },
435     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
436     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
437     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
438     { WM_SIZE, sent|optional }, /* XP doesn't send it */
439     { WM_MOVE, sent|optional }, /* XP doesn't send it */
440     { WM_NCACTIVATE, sent|wparam, 0 },
441     { WM_ACTIVATE, sent|wparam, 0 },
442     { WM_ACTIVATEAPP, sent|wparam, 0 },
443     { WM_KILLFOCUS, sent|wparam, 0 },
444     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
445     { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
446     { 0 }
447 };
448 /* DestroyWindow for a visible overlapped window */
449 static const struct message WmDestroyOverlappedSeq[] = {
450     { HCBT_DESTROYWND, hook },
451     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
452     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
453     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
454     { WM_NCACTIVATE, sent|wparam, 0 },
455     { WM_ACTIVATE, sent|wparam, 0 },
456     { WM_ACTIVATEAPP, sent|wparam, 0 },
457     { WM_KILLFOCUS, sent|wparam, 0 },
458     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
459     { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
460     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
461     { WM_DESTROY, sent },
462     { WM_NCDESTROY, sent },
463     { 0 }
464 };
465 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
466 static const struct message WmCreateMaxPopupSeq[] = {
467     { HCBT_CREATEWND, hook },
468     { WM_NCCREATE, sent },
469     { WM_NCCALCSIZE, sent|wparam, 0 },
470     { WM_CREATE, sent },
471     { WM_SIZE, sent|wparam, SIZE_RESTORED },
472     { WM_MOVE, sent },
473     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
474     { WM_GETMINMAXINFO, sent },
475     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000 },
476     { WM_NCCALCSIZE, sent|wparam, TRUE },
477     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|0x8000 },
478     { WM_MOVE, sent|defwinproc },
479     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
480     { WM_SHOWWINDOW, sent|wparam, 1 },
481     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
482     { HCBT_ACTIVATE, hook },
483     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
484     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
485     { WM_ACTIVATEAPP, sent|wparam, 1 },
486     { WM_NCACTIVATE, sent|wparam, 1 },
487     { WM_ACTIVATE, sent|wparam, 1 },
488     { HCBT_SETFOCUS, hook },
489     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
490     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
491     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
492     { WM_SYNCPAINT, sent|wparam|optional, 4 },
493     { WM_NCPAINT, sent|wparam|optional, 1 },
494     { WM_ERASEBKGND, sent|optional },
495     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
496     { 0 }
497 };
498 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
499 static const struct message WmCreateInvisibleMaxPopupSeq[] = {
500     { HCBT_CREATEWND, hook },
501     { WM_NCCREATE, sent },
502     { WM_NCCALCSIZE, sent|wparam, 0 },
503     { WM_CREATE, sent },
504     { WM_SIZE, sent|wparam, SIZE_RESTORED },
505     { WM_MOVE, sent },
506     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
507     { WM_GETMINMAXINFO, sent },
508     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000 },
509     { WM_NCCALCSIZE, sent|wparam, TRUE },
510     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|0x8000 },
511     { WM_MOVE, sent|defwinproc },
512     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
513     { 0 }
514 };
515 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
516 static const struct message WmShowMaxPopupResizedSeq[] = {
517     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
518     { WM_GETMINMAXINFO, sent },
519     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
520     { WM_NCCALCSIZE, sent|wparam, TRUE },
521     { HCBT_ACTIVATE, hook },
522     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
523     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
524     { WM_ACTIVATEAPP, sent|wparam, 1 },
525     { WM_NCACTIVATE, sent|wparam, 1 },
526     { WM_ACTIVATE, sent|wparam, 1 },
527     { HCBT_SETFOCUS, hook },
528     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
529     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
530     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
531     { WM_NCPAINT, sent|wparam|optional, 1 },
532     { WM_ERASEBKGND, sent|optional },
533     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE },
534     /* WinNT4.0 sends WM_MOVE */
535     { WM_MOVE, sent|defwinproc|optional },
536     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
537     { 0 }
538 };
539 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
540 static const struct message WmShowMaxPopupSeq[] = {
541     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
542     { WM_GETMINMAXINFO, sent },
543     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
544     { WM_NCCALCSIZE, sent|wparam, TRUE },
545     { HCBT_ACTIVATE, hook },
546     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
547     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
548     { WM_ACTIVATEAPP, sent|wparam, 1 },
549     { WM_NCACTIVATE, sent|wparam, 1 },
550     { WM_ACTIVATE, sent|wparam, 1 },
551     { HCBT_SETFOCUS, hook },
552     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
553     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
554     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
555     { WM_SYNCPAINT, sent|wparam|optional, 4 },
556     { WM_NCPAINT, sent|wparam|optional, 1 },
557     { WM_ERASEBKGND, sent|optional },
558     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE },
559     { 0 }
560 };
561 /* CreateWindow(WS_VISIBLE) for popup window */
562 static const struct message WmCreatePopupSeq[] = {
563     { HCBT_CREATEWND, hook },
564     { WM_NCCREATE, sent },
565     { WM_NCCALCSIZE, sent|wparam, 0 },
566     { WM_CREATE, sent },
567     { WM_SIZE, sent|wparam, SIZE_RESTORED },
568     { WM_MOVE, sent },
569     { WM_SHOWWINDOW, sent|wparam, 1 },
570     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
571     { HCBT_ACTIVATE, hook },
572     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
573     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
574     { WM_NCPAINT, sent|wparam|optional, 1 },
575     { WM_ERASEBKGND, sent|optional },
576     { WM_ACTIVATEAPP, sent|wparam, 1 },
577     { WM_NCACTIVATE, sent|wparam, 1 },
578     { WM_ACTIVATE, sent|wparam, 1 },
579     { HCBT_SETFOCUS, hook },
580     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
581     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
582     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
583     { WM_SYNCPAINT, sent|wparam|optional, 4 },
584     { WM_NCPAINT, sent|wparam|optional, 1 },
585     { WM_ERASEBKGND, sent|optional },
586     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
587     { 0 }
588 };
589 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
590 static const struct message WmShowVisMaxPopupSeq[] = {
591     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
592     { WM_GETMINMAXINFO, sent },
593     { WM_GETTEXT, sent|optional },
594     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
595     { WM_NCCALCSIZE, sent|wparam, TRUE },
596     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
597     { WM_NCPAINT, sent|wparam|optional, 1 },
598     { WM_ERASEBKGND, sent|optional },
599     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|0x8000 },
600     { WM_MOVE, sent|defwinproc },
601     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
602     { 0 }
603 };
604 /* CreateWindow (for a child popup window, not initially visible) */
605 static const struct message WmCreateChildPopupSeq[] = {
606     { HCBT_CREATEWND, hook },
607     { WM_NCCREATE, sent }, 
608     { WM_NCCALCSIZE, sent|wparam, 0 },
609     { WM_CREATE, sent },
610     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
611     { WM_SIZE, sent|wparam, SIZE_RESTORED },
612     { WM_MOVE, sent },
613     { 0 }
614 };
615 /* CreateWindow (for a popup window, not initially visible,
616  * which sets WS_VISIBLE in WM_CREATE handler)
617  */
618 static const struct message WmCreateInvisiblePopupSeq[] = {
619     { HCBT_CREATEWND, hook },
620     { WM_NCCREATE, sent }, 
621     { WM_NCCALCSIZE, sent|wparam, 0 },
622     { WM_CREATE, sent },
623     { WM_STYLECHANGING, sent },
624     { WM_STYLECHANGED, sent },
625     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
626     { WM_SIZE, sent|wparam, SIZE_RESTORED },
627     { WM_MOVE, sent },
628     { 0 }
629 };
630 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
631  * for a popup window with WS_VISIBLE style set
632  */
633 static const struct message WmShowVisiblePopupSeq_2[] = {
634     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
635     { 0 }
636 };
637 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
638  * for a popup window with WS_VISIBLE style set
639  */
640 static const struct message WmShowVisiblePopupSeq_3[] = {
641     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
642     { HCBT_ACTIVATE, hook },
643     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
644     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
645     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
646     { WM_NCACTIVATE, sent|wparam, 1 },
647     { WM_ACTIVATE, sent|wparam, 1 },
648     { HCBT_SETFOCUS, hook },
649     { WM_KILLFOCUS, sent|parent },
650     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
651     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
652     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
653     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
654     { WM_SETFOCUS, sent|defwinproc },
655     { 0 }
656 };
657 /* CreateWindow (for child window, not initially visible) */
658 static const struct message WmCreateChildSeq[] = {
659     { HCBT_CREATEWND, hook },
660     { WM_NCCREATE, sent }, 
661     /* child is inserted into parent's child list after WM_NCCREATE returns */
662     { WM_NCCALCSIZE, sent|wparam, 0 },
663     { WM_CREATE, sent },
664     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
665     { WM_SIZE, sent|wparam, SIZE_RESTORED },
666     { WM_MOVE, sent },
667     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
668     { 0 }
669 };
670 /* CreateWindow (for maximized child window, not initially visible) */
671 static const struct message WmCreateMaximizedChildSeq[] = {
672     { HCBT_CREATEWND, hook },
673     { WM_NCCREATE, sent }, 
674     { WM_NCCALCSIZE, sent|wparam, 0 },
675     { WM_CREATE, sent },
676     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
677     { WM_SIZE, sent|wparam, SIZE_RESTORED },
678     { WM_MOVE, sent },
679     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
680     { WM_GETMINMAXINFO, sent },
681     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
682     { WM_NCCALCSIZE, sent|wparam, 1 },
683     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|0x8000 },
684     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
685     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
686     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
687     { 0 }
688 };
689 /* CreateWindow (for a child window, initially visible) */
690 static const struct message WmCreateVisibleChildSeq[] = {
691     { HCBT_CREATEWND, hook },
692     { WM_NCCREATE, sent }, 
693     /* child is inserted into parent's child list after WM_NCCREATE returns */
694     { WM_NCCALCSIZE, sent|wparam, 0 },
695     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
696     { WM_CREATE, sent },
697     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
698     { WM_SIZE, sent|wparam, SIZE_RESTORED },
699     { WM_MOVE, sent },
700     { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
701     { WM_SHOWWINDOW, sent|wparam, 1 },
702     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
703     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
704     { WM_ERASEBKGND, sent|parent|optional },
705     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
706     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
707     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
708     { 0 }
709 };
710 /* ShowWindow(SW_SHOW) for a not visible child window */
711 static const struct message WmShowChildSeq[] = {
712     { WM_SHOWWINDOW, sent|wparam, 1 },
713     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
714     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
715     { WM_ERASEBKGND, sent|parent|optional },
716     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
717     { 0 }
718 };
719 /* ShowWindow(SW_HIDE) for a visible child window */
720 static const struct message WmHideChildSeq[] = {
721     { WM_SHOWWINDOW, sent|wparam, 0 },
722     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
723     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
724     { WM_ERASEBKGND, sent|parent|optional },
725     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
726     { 0 }
727 };
728 /* ShowWindow(SW_HIDE) for a visible child window checking all parent events*/
729 static const struct message WmHideChildSeq2[] = {
730     { WM_SHOWWINDOW, sent|wparam, 0 },
731     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
732     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
733     { WM_ERASEBKGND, sent|parent },
734     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
735     { 0 }
736 };
737 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
738  * for a not visible child window
739  */
740 static const struct message WmShowChildSeq_2[] = {
741     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
742     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
743     { WM_CHILDACTIVATE, sent },
744     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
745     { 0 }
746 };
747 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
748  * for a not visible child window
749  */
750 static const struct message WmShowChildSeq_3[] = {
751     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
752     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
753     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
754     { 0 }
755 };
756 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
757  * for a visible child window with a caption
758  */
759 static const struct message WmShowChildSeq_4[] = {
760     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
761     { WM_CHILDACTIVATE, sent },
762     { 0 }
763 };
764 /* ShowWindow(SW_MINIMIZE) for child with invisible parent */
765 static const struct message WmShowChildInvisibleParentSeq_1[] = {
766     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
767     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|0x8000 },
768     { WM_NCCALCSIZE, sent|wparam, 1 },
769     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|0x8000 },
770     { WM_MOVE, sent|defwinproc },
771     { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
772     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
773     /* FIXME: Wine creates an icon/title window while Windows doesn't */
774     { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
775     { WM_GETTEXT, sent|optional },
776     { 0 }
777 };
778 /* repeated ShowWindow(SW_MINIMIZE) for child with invisible parent */
779 static const struct message WmShowChildInvisibleParentSeq_1r[] = {
780     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
781     { 0 }
782 };
783 /* ShowWindow(SW_MAXIMIZE) for child with invisible parent */
784 static const struct message WmShowChildInvisibleParentSeq_2[] = {
785     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
786     { WM_GETMINMAXINFO, sent },
787     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
788     { WM_NCCALCSIZE, sent|wparam, 1 },
789     { WM_CHILDACTIVATE, sent },
790     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|0x8000 },
791     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
792     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
793     { 0 }
794 };
795 /* repeated ShowWindow(SW_MAXIMIZE) for child with invisible parent */
796 static const struct message WmShowChildInvisibleParentSeq_2r[] = {
797     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
798     { 0 }
799 };
800 /* ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
801 static const struct message WmShowChildInvisibleParentSeq_3[] = {
802     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
803     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
804     { WM_NCCALCSIZE, sent|wparam, 1 },
805     { WM_CHILDACTIVATE, sent },
806     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|0x8000 },
807     { WM_MOVE, sent|defwinproc },
808     { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
809     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
810     /* FIXME: Wine creates an icon/title window while Windows doesn't */
811     { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
812     { WM_GETTEXT, sent|optional },
813     { 0 }
814 };
815 /* repeated ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
816 static const struct message WmShowChildInvisibleParentSeq_3r[] = {
817     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
818     { 0 }
819 };
820 /* ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
821 static const struct message WmShowChildInvisibleParentSeq_4[] = {
822     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
823     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|0x8000 },
824     { WM_NCCALCSIZE, sent|wparam, 1 },
825     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|0x8000 },
826     { WM_MOVE, sent|defwinproc },
827     { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
828     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
829     /* FIXME: Wine creates an icon/title window while Windows doesn't */
830     { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
831     { WM_GETTEXT, sent|optional },
832     { 0 }
833 };
834 /* repeated ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
835 static const struct message WmShowChildInvisibleParentSeq_4r[] = {
836     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
837     { 0 }
838 };
839 /* ShowWindow(SW_SHOW) for child with invisible parent */
840 static const struct message WmShowChildInvisibleParentSeq_5[] = {
841     { WM_SHOWWINDOW, sent|wparam, 1 },
842     { 0 }
843 };
844 /* ShowWindow(SW_HIDE) for child with invisible parent */
845 static const struct message WmHideChildInvisibleParentSeq[] = {
846     { WM_SHOWWINDOW, sent|wparam, 0 },
847     { 0 }
848 };
849 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
850 static const struct message WmShowChildInvisibleParentSeq_6[] = {
851     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
852     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
853     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
854     { 0 }
855 };
856 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
857 static const struct message WmHideChildInvisibleParentSeq_2[] = {
858     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
859     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
860     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
861     { 0 }
862 };
863 /* DestroyWindow for a visible child window */
864 static const struct message WmDestroyChildSeq[] = {
865     { HCBT_DESTROYWND, hook },
866     { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
867     { WM_SHOWWINDOW, sent|wparam, 0 },
868     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
869     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
870     { WM_ERASEBKGND, sent|parent|optional },
871     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
872     { HCBT_SETFOCUS, hook }, /* set focus to a parent */
873     { WM_KILLFOCUS, sent },
874     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
875     { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
876     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
877     { WM_SETFOCUS, sent|parent },
878     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
879     { WM_DESTROY, sent },
880     { WM_DESTROY, sent|optional }, /* some other (IME?) window */
881     { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
882     { WM_NCDESTROY, sent },
883     { 0 }
884 };
885 /* DestroyWindow for a visible child window with invisible parent */
886 static const struct message WmDestroyInvisibleChildSeq[] = {
887     { HCBT_DESTROYWND, hook },
888     { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
889     { WM_SHOWWINDOW, sent|wparam, 0 },
890     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
891     { WM_DESTROY, sent },
892     { WM_NCDESTROY, sent },
893     { 0 }
894 };
895 /* Moving the mouse in nonclient area */
896 static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
897     { WM_NCHITTEST, sent },
898     { WM_SETCURSOR, sent },
899     { WM_NCMOUSEMOVE, posted },
900     { 0 }
901 };
902 /* Moving the mouse in client area */
903 static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
904     { WM_NCHITTEST, sent },
905     { WM_SETCURSOR, sent },
906     { WM_MOUSEMOVE, posted },
907     { 0 }
908 };
909 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
910 static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
911     { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
912     { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
913     { WM_GETMINMAXINFO, sent|defwinproc },
914     { WM_ENTERSIZEMOVE, sent|defwinproc },
915     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
916     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
917     { WM_MOVE, sent|defwinproc },
918     { WM_EXITSIZEMOVE, sent|defwinproc },
919     { 0 }
920 };
921 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
922 static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
923     { WM_NCLBUTTONDOWN, sent|wparam, 0xd },
924     { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 },
925     { WM_GETMINMAXINFO, sent|defwinproc },
926     { WM_ENTERSIZEMOVE, sent|defwinproc },
927     { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */
928     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
929     { WM_GETMINMAXINFO, sent|defwinproc },
930     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
931     { WM_NCPAINT, sent|defwinproc|wparam, 1 },
932     { WM_GETTEXT, sent|defwinproc },
933     { WM_ERASEBKGND, sent|defwinproc },
934     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
935     { WM_MOVE, sent|defwinproc },
936     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
937     { WM_EXITSIZEMOVE, sent|defwinproc },
938     { 0 }
939 };
940 /* Resizing child window with MoveWindow (32) */
941 static const struct message WmResizingChildWithMoveWindowSeq[] = {
942     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
943     { WM_NCCALCSIZE, sent|wparam, 1 },
944     { WM_ERASEBKGND, sent|parent|optional },
945     { WM_ERASEBKGND, sent|optional },
946     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE },
947     { WM_MOVE, sent|defwinproc },
948     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
949     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
950     { 0 }
951 };
952 /* Clicking on inactive button */
953 static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
954     { WM_NCHITTEST, sent },
955     { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN },
956     { WM_MOUSEACTIVATE, sent },
957     { WM_MOUSEACTIVATE, sent|parent|defwinproc },
958     { WM_SETCURSOR, sent },
959     { WM_SETCURSOR, sent|parent|defwinproc },
960     { WM_LBUTTONDOWN, posted },
961     { WM_KILLFOCUS, posted|parent },
962     { WM_SETFOCUS, posted },
963     { WM_CTLCOLORBTN, posted|parent },
964     { BM_SETSTATE, posted },
965     { WM_CTLCOLORBTN, posted|parent },
966     { WM_LBUTTONUP, posted },
967     { BM_SETSTATE, posted },
968     { WM_CTLCOLORBTN, posted|parent },
969     { WM_COMMAND, posted|parent },
970     { 0 }
971 };
972 /* Reparenting a button (16/32) */
973 /* The last child (button) reparented gets topmost for its new parent. */
974 static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
975     { WM_SHOWWINDOW, sent|wparam, 0 },
976     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
977     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
978     { WM_ERASEBKGND, sent|parent },
979     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
980     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
981     { WM_CHILDACTIVATE, sent },
982     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW },
983     { WM_MOVE, sent|defwinproc },
984     { WM_SHOWWINDOW, sent|wparam, 1 },
985     { 0 }
986 };
987 /* Creation of a custom dialog (32) */
988 static const struct message WmCreateCustomDialogSeq[] = {
989     { HCBT_CREATEWND, hook },
990     { WM_GETMINMAXINFO, sent },
991     { WM_NCCREATE, sent },
992     { WM_NCCALCSIZE, sent|wparam, 0 },
993     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
994     { WM_CREATE, sent },
995     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
996     { WM_SHOWWINDOW, sent|wparam, 1 },
997     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
998     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
999     { HCBT_ACTIVATE, hook },
1000     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1001
1002
1003     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1004
1005     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1006
1007     { WM_NCACTIVATE, sent|wparam, 1 },
1008     { WM_GETTEXT, sent|optional|defwinproc },
1009     { WM_GETTEXT, sent|optional|defwinproc },
1010     { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
1011     { WM_ACTIVATE, sent|wparam, 1 },
1012     { WM_KILLFOCUS, sent|parent },
1013     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1014     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1015     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1016     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1017     { WM_SETFOCUS, sent },
1018     { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1019     { WM_NCPAINT, sent|wparam, 1 },
1020     { WM_GETTEXT, sent|optional|defwinproc },
1021     { WM_GETTEXT, sent|optional|defwinproc },
1022     { WM_ERASEBKGND, sent },
1023     { WM_CTLCOLORDLG, sent|defwinproc },
1024     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1025     { WM_GETTEXT, sent|optional },
1026     { WM_GETTEXT, sent|optional },
1027     { WM_NCCALCSIZE, sent|optional },
1028     { WM_NCPAINT, sent|optional },
1029     { WM_GETTEXT, sent|optional|defwinproc },
1030     { WM_GETTEXT, sent|optional|defwinproc },
1031     { WM_ERASEBKGND, sent|optional },
1032     { WM_CTLCOLORDLG, sent|optional|defwinproc },
1033     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1034     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1035     { WM_MOVE, sent },
1036     { 0 }
1037 };
1038 /* Calling EndDialog for a custom dialog (32) */
1039 static const struct message WmEndCustomDialogSeq[] = {
1040     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1041     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1042     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1043     { WM_GETTEXT, sent|optional },
1044     { HCBT_ACTIVATE, hook },
1045     { WM_NCACTIVATE, sent|wparam, 0 },
1046     { WM_GETTEXT, sent|optional|defwinproc },
1047     { WM_GETTEXT, sent|optional|defwinproc },
1048     { WM_ACTIVATE, sent|wparam, 0 },
1049     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1050     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1051     { HCBT_SETFOCUS, hook },
1052     { WM_KILLFOCUS, sent },
1053     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1054     { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1055     { WM_IME_NOTIFY, sent|wparam|optional, 1 },
1056     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1057     { WM_SETFOCUS, sent|parent|defwinproc },
1058     { 0 }
1059 };
1060 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
1061 static const struct message WmShowCustomDialogSeq[] = {
1062     { WM_SHOWWINDOW, sent|wparam, 1 },
1063     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1064     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1065     { HCBT_ACTIVATE, hook },
1066     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1067
1068     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1069
1070     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1071     { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
1072     { WM_NCACTIVATE, sent|wparam, 1 },
1073     { WM_ACTIVATE, sent|wparam, 1 },
1074
1075     { WM_KILLFOCUS, sent|parent },
1076     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1077     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1078     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1079     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1080     { WM_SETFOCUS, sent },
1081     { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1082     { WM_NCPAINT, sent|wparam, 1 },
1083     { WM_ERASEBKGND, sent },
1084     { WM_CTLCOLORDLG, sent|defwinproc },
1085     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1086     { 0 }
1087 };
1088 /* Creation and destruction of a modal dialog (32) */
1089 static const struct message WmModalDialogSeq[] = {
1090     { WM_CANCELMODE, sent|parent },
1091     { HCBT_SETFOCUS, hook },
1092     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1093     { WM_KILLFOCUS, sent|parent },
1094     { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1095     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1096     { WM_ENABLE, sent|parent|wparam, 0 },
1097     { HCBT_CREATEWND, hook },
1098     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1099     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1100     { WM_SETFONT, sent },
1101     { WM_INITDIALOG, sent },
1102     { WM_CHANGEUISTATE, sent|optional },
1103     { WM_UPDATEUISTATE, sent|optional },
1104     { WM_SHOWWINDOW, sent },
1105     { HCBT_ACTIVATE, hook },
1106     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1107     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1108     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1109     { WM_NCACTIVATE, sent|wparam, 1 },
1110     { WM_GETTEXT, sent|optional },
1111     { WM_ACTIVATE, sent|wparam, 1 },
1112     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1113     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1114     { WM_NCPAINT, sent },
1115     { WM_GETTEXT, sent|optional },
1116     { WM_ERASEBKGND, sent },
1117     { WM_CTLCOLORDLG, sent },
1118     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1119     { WM_GETTEXT, sent|optional },
1120     { WM_NCCALCSIZE, sent|optional },
1121     { WM_NCPAINT, sent|optional },
1122     { WM_GETTEXT, sent|optional },
1123     { WM_ERASEBKGND, sent|optional },
1124     { WM_CTLCOLORDLG, sent|optional },
1125     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1126     { WM_PAINT, sent|optional },
1127     { WM_CTLCOLORBTN, sent },
1128     { WM_ENTERIDLE, sent|parent|optional },
1129     { WM_ENTERIDLE, sent|parent|optional },
1130     { WM_ENTERIDLE, sent|parent|optional },
1131     { WM_ENTERIDLE, sent|parent|optional },
1132     { WM_ENTERIDLE, sent|parent|optional },
1133     { WM_ENTERIDLE, sent|parent|optional },
1134     { WM_ENTERIDLE, sent|parent|optional },
1135     { WM_ENTERIDLE, sent|parent|optional },
1136     { WM_ENTERIDLE, sent|parent|optional },
1137     { WM_ENTERIDLE, sent|parent|optional },
1138     { WM_ENTERIDLE, sent|parent|optional },
1139     { WM_ENTERIDLE, sent|parent|optional },
1140     { WM_ENTERIDLE, sent|parent|optional },
1141     { WM_ENTERIDLE, sent|parent|optional },
1142     { WM_ENTERIDLE, sent|parent|optional },
1143     { WM_ENTERIDLE, sent|parent|optional },
1144     { WM_ENTERIDLE, sent|parent|optional },
1145     { WM_ENTERIDLE, sent|parent|optional },
1146     { WM_ENTERIDLE, sent|parent|optional },
1147     { WM_ENTERIDLE, sent|parent|optional },
1148     { WM_TIMER, sent },
1149     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1150     { WM_ENABLE, sent|parent|wparam, 1 },
1151     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1152     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1153     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1154     { WM_GETTEXT, sent|optional },
1155     { HCBT_ACTIVATE, hook },
1156     { WM_NCACTIVATE, sent|wparam, 0 },
1157     { WM_GETTEXT, sent|optional },
1158     { WM_ACTIVATE, sent|wparam, 0 },
1159     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1160     { WM_WINDOWPOSCHANGING, sent|optional },
1161     { HCBT_SETFOCUS, hook },
1162     { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1163     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1164     { WM_SETFOCUS, sent|parent|defwinproc },
1165     { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
1166     { HCBT_DESTROYWND, hook },
1167     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1168     { WM_DESTROY, sent },
1169     { WM_NCDESTROY, sent },
1170     { 0 }
1171 };
1172 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
1173 static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
1174     /* (inside dialog proc, handling WM_INITDIALOG) */
1175     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1176     { WM_NCCALCSIZE, sent },
1177     { WM_NCACTIVATE, sent|parent|wparam, 0 },
1178     { WM_GETTEXT, sent|defwinproc },
1179     { WM_ACTIVATE, sent|parent|wparam, 0 },
1180     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1181     { WM_WINDOWPOSCHANGING, sent|parent },
1182     { WM_NCACTIVATE, sent|wparam, 1 },
1183     { WM_ACTIVATE, sent|wparam, 1 },
1184     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1185     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1186     /* (setting focus) */
1187     { WM_SHOWWINDOW, sent|wparam, 1 },
1188     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1189     { WM_NCPAINT, sent },
1190     { WM_GETTEXT, sent|defwinproc },
1191     { WM_ERASEBKGND, sent },
1192     { WM_CTLCOLORDLG, sent|defwinproc },
1193     { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1194     { WM_PAINT, sent },
1195     /* (bunch of WM_CTLCOLOR* for each control) */
1196     { WM_PAINT, sent|parent },
1197     { WM_ENTERIDLE, sent|parent|wparam, 0 },
1198     { WM_SETCURSOR, sent|parent },
1199     { 0 }
1200 };
1201 /* SetMenu for NonVisible windows with size change*/
1202 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
1203     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1204     { WM_NCCALCSIZE, sent|wparam, 1 },
1205     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1206     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
1207     { WM_MOVE, sent|defwinproc },
1208     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1209     { WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
1210     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1211     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1212     { WM_GETTEXT, sent|optional },
1213     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1214     { 0 }
1215 };
1216 /* SetMenu for NonVisible windows with no size change */
1217 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
1218     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1219     { WM_NCCALCSIZE, sent|wparam, 1 },
1220     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1221     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1222     { 0 }
1223 };
1224 /* SetMenu for Visible windows with size change */
1225 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
1226     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1227     { WM_NCCALCSIZE, sent|wparam, 1 },
1228     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1229     { WM_NCPAINT, sent }, /* wparam != 1 */
1230     { WM_GETTEXT, sent|defwinproc|optional },
1231     { WM_ERASEBKGND, sent|optional },
1232     { WM_ACTIVATE, sent|optional },
1233     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1234     { WM_MOVE, sent|defwinproc },
1235     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1236     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1237     { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1238     { WM_ERASEBKGND, sent|optional },
1239     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1240     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1241     { 0 }
1242 };
1243 /* SetMenu for Visible windows with no size change */
1244 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
1245     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1246     { WM_NCCALCSIZE, sent|wparam, 1 },
1247     { WM_NCPAINT, sent }, /* wparam != 1 */
1248     { WM_GETTEXT, sent|defwinproc|optional },
1249     { WM_ERASEBKGND, sent|optional },
1250     { WM_ACTIVATE, sent|optional },
1251     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1252     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1253     { 0 }
1254 };
1255 /* DrawMenuBar for a visible window */
1256 static const struct message WmDrawMenuBarSeq[] =
1257 {
1258     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1259     { WM_NCCALCSIZE, sent|wparam, 1 },
1260     { WM_NCPAINT, sent }, /* wparam != 1 */
1261     { WM_GETTEXT, sent|defwinproc|optional },
1262     { WM_ERASEBKGND, sent|optional },
1263     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1264     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1265     { 0 }
1266 };
1267
1268 static const struct message WmSetRedrawFalseSeq[] =
1269 {
1270     { WM_SETREDRAW, sent|wparam, 0 },
1271     { 0 }
1272 };
1273
1274 static const struct message WmSetRedrawTrueSeq[] =
1275 {
1276     { WM_SETREDRAW, sent|wparam, 1 },
1277     { 0 }
1278 };
1279
1280 static const struct message WmEnableWindowSeq_1[] =
1281 {
1282     { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1283     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1284     { WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
1285     { 0 }
1286 };
1287
1288 static const struct message WmEnableWindowSeq_2[] =
1289 {
1290     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1291     { WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
1292     { 0 }
1293 };
1294
1295 static const struct message WmGetScrollRangeSeq[] =
1296 {
1297     { SBM_GETRANGE, sent },
1298     { 0 }
1299 };
1300 static const struct message WmGetScrollInfoSeq[] =
1301 {
1302     { SBM_GETSCROLLINFO, sent },
1303     { 0 }
1304 };
1305 static const struct message WmSetScrollRangeSeq[] =
1306 {
1307     /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
1308        sends SBM_SETSCROLLINFO.
1309      */
1310     { SBM_SETSCROLLINFO, sent },
1311     { 0 }
1312 };
1313 /* SetScrollRange for a window without a non-client area */
1314 static const struct message WmSetScrollRangeHSeq_empty[] =
1315 {
1316     { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
1317     { 0 }
1318 };
1319 static const struct message WmSetScrollRangeVSeq_empty[] =
1320 {
1321     { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
1322     { 0 }
1323 };
1324 static const struct message WmSetScrollRangeHVSeq[] =
1325 {
1326     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1327     { WM_NCCALCSIZE, sent|wparam, 1 },
1328     { WM_GETTEXT, sent|defwinproc|optional },
1329     { WM_ERASEBKGND, sent|optional },
1330     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1331     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1332     { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1333     { 0 }
1334 };
1335 /* SetScrollRange for a window with a non-client area */
1336 static const struct message WmSetScrollRangeHV_NC_Seq[] =
1337 {
1338     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1339     { WM_NCCALCSIZE, sent|wparam, 1 },
1340     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1341     { WM_NCPAINT, sent|optional },
1342     { WM_GETTEXT, sent|defwinproc|optional },
1343     { WM_GETTEXT, sent|defwinproc|optional },
1344     { WM_ERASEBKGND, sent|optional },
1345     { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
1346     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTMOVE },
1347     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1348     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1349     { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1350     { WM_GETTEXT, sent|optional },
1351     { WM_GETTEXT, sent|optional },
1352     { WM_GETTEXT, sent|optional },
1353     { WM_GETTEXT, sent|optional },
1354     { 0 }
1355 };
1356 /* test if we receive the right sequence of messages */
1357 /* after calling ShowWindow( SW_SHOWNA) */
1358 static const struct message WmSHOWNAChildInvisParInvis[] = {
1359     { WM_SHOWWINDOW, sent|wparam, 1 },
1360     { 0 }
1361 };
1362 static const struct message WmSHOWNAChildVisParInvis[] = {
1363     { WM_SHOWWINDOW, sent|wparam, 1 },
1364     { 0 }
1365 };
1366 static const struct message WmSHOWNAChildVisParVis[] = {
1367     { WM_SHOWWINDOW, sent|wparam, 1 },
1368     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1369     { 0 }
1370 };
1371 static const struct message WmSHOWNAChildInvisParVis[] = {
1372     { WM_SHOWWINDOW, sent|wparam, 1 },
1373     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1374     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1375     { WM_ERASEBKGND, sent|optional },
1376     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOCLIENTMOVE },
1377     { 0 }
1378 };
1379 static const struct message WmSHOWNATopVisible[] = {
1380     { WM_SHOWWINDOW, sent|wparam, 1 },
1381     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1382     { 0 }
1383 };
1384 static const struct message WmSHOWNATopInvisible[] = {
1385     { WM_SHOWWINDOW, sent|wparam, 1 },
1386     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1387     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1388     { WM_NCPAINT, sent|wparam, 1 },
1389     { WM_GETTEXT, sent|defwinproc|optional },
1390     { WM_ERASEBKGND, sent|optional },
1391     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1392     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1393     { WM_NCPAINT, sent|wparam|optional, 1 },
1394     { WM_ERASEBKGND, sent|optional },
1395     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1396     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1397     { WM_MOVE, sent },
1398     { 0 }
1399 };
1400
1401 static int after_end_dialog, test_def_id;
1402 static int sequence_cnt, sequence_size;
1403 static struct message* sequence;
1404 static int log_all_parent_messages;
1405
1406 /* user32 functions */
1407 static HWND (WINAPI *pGetAncestor)(HWND,UINT);
1408 static void (WINAPI *pNotifyWinEvent)(DWORD, HWND, LONG, LONG);
1409 static HWINEVENTHOOK (WINAPI *pSetWinEventHook)(DWORD, DWORD, HMODULE, WINEVENTPROC, DWORD, DWORD, DWORD);
1410 static BOOL (WINAPI *pTrackMouseEvent)(TRACKMOUSEEVENT*);
1411 static BOOL (WINAPI *pUnhookWinEvent)(HWINEVENTHOOK);
1412 /* kernel32 functions */
1413 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
1414
1415 static void init_procs(void)
1416 {
1417     HMODULE user32 = GetModuleHandleA("user32.dll");
1418     HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
1419
1420 #define GET_PROC(dll, func) \
1421     p ## func = (void*)GetProcAddress(dll, #func); \
1422     if(!p ## func) { \
1423       trace("GetProcAddress(%s) failed\n", #func); \
1424     }
1425
1426     GET_PROC(user32, GetAncestor)
1427     GET_PROC(user32, NotifyWinEvent)
1428     GET_PROC(user32, SetWinEventHook)
1429     GET_PROC(user32, TrackMouseEvent)
1430     GET_PROC(user32, UnhookWinEvent)
1431
1432     GET_PROC(kernel32, GetCPInfoExA)
1433
1434 #undef GET_PROC
1435 }
1436
1437 static void add_message(const struct message *msg)
1438 {
1439     if (!sequence) 
1440     {
1441         sequence_size = 10;
1442         sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) );
1443     }
1444     if (sequence_cnt == sequence_size) 
1445     {
1446         sequence_size *= 2;
1447         sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) );
1448     }
1449     assert(sequence);
1450
1451     sequence[sequence_cnt].message = msg->message;
1452     sequence[sequence_cnt].flags = msg->flags;
1453     sequence[sequence_cnt].wParam = msg->wParam;
1454     sequence[sequence_cnt].lParam = msg->lParam;
1455
1456     sequence_cnt++;
1457 }
1458
1459 /* try to make sure pending X events have been processed before continuing */
1460 static void flush_events(void)
1461 {
1462     MSG msg;
1463     int diff = 100;
1464     DWORD time = GetTickCount() + diff;
1465
1466     while (diff > 0)
1467     {
1468         if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min(10,diff), QS_ALLINPUT ) == WAIT_TIMEOUT) break;
1469         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
1470         diff = time - GetTickCount();
1471     }
1472 }
1473
1474 static void flush_sequence(void)
1475 {
1476     HeapFree(GetProcessHeap(), 0, sequence);
1477     sequence = 0;
1478     sequence_cnt = sequence_size = 0;
1479 }
1480
1481 #define ok_sequence( exp, contx, todo) \
1482         ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
1483
1484
1485 static void ok_sequence_(const struct message *expected, const char *context, int todo,
1486         const char *file, int line)
1487 {
1488     static const struct message end_of_sequence = { 0, 0, 0, 0 };
1489     const struct message *actual;
1490     int failcount = 0;
1491     
1492     add_message(&end_of_sequence);
1493
1494     actual = sequence;
1495
1496     while (expected->message && actual->message)
1497     {
1498         trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
1499
1500         if (expected->message == actual->message)
1501         {
1502             if (expected->flags & wparam)
1503             {
1504                 if (expected->wParam != actual->wParam && todo)
1505                 {
1506                     todo_wine {
1507                         failcount ++;
1508                         ok_( file, line) (FALSE,
1509                             "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
1510                             context, expected->message, expected->wParam, actual->wParam);
1511                     }
1512                 }
1513                 else
1514                 ok_( file, line) (expected->wParam == actual->wParam,
1515                      "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
1516                      context, expected->message, expected->wParam, actual->wParam);
1517             }
1518             if (expected->flags & lparam)
1519             {
1520                 if (expected->lParam != actual->lParam && todo)
1521                 {
1522                     todo_wine {
1523                         failcount ++;
1524                         ok_( file, line) (FALSE,
1525                             "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1526                             context, expected->message, expected->lParam, actual->lParam);
1527                     }
1528                 }
1529                 else
1530                  ok_( file, line) (expected->lParam == actual->lParam,
1531                      "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1532                      context, expected->message, expected->lParam, actual->lParam);
1533             }
1534             if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
1535             {
1536                     todo_wine {
1537                         failcount ++;
1538                         ok_( file, line) (FALSE,
1539                             "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1540                             context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1541                     }
1542             }
1543             else
1544                 ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
1545                     "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1546                     context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1547             ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
1548                 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
1549                 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
1550             ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
1551                 "%s: the msg 0x%04x should have been %s\n",
1552                 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
1553             ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
1554                 "%s: the msg 0x%04x was expected in %s\n",
1555                 context, expected->message, (expected->flags & parent) ? "parent" : "child");
1556             ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
1557                 "%s: the msg 0x%04x should have been sent by a hook\n",
1558                 context, expected->message);
1559             ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
1560                 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
1561                 context, expected->message);
1562             expected++;
1563             actual++;
1564         }
1565         /* silently drop winevent messages if there is no support for them */
1566         else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
1567             expected++;
1568         else if (todo)
1569         {
1570             failcount++;
1571             todo_wine {
1572                 ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1573                     context, expected->message, actual->message);
1574             }
1575             flush_sequence();
1576             return;
1577         }
1578         else
1579         {
1580             ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1581                 context, expected->message, actual->message);
1582             expected++;
1583             actual++;
1584         }
1585     }
1586
1587     /* skip all optional trailing messages */
1588     while (expected->message && ((expected->flags & optional) ||
1589             ((expected->flags & winevent_hook) && !hEvent_hook)))
1590         expected++;
1591
1592     if (todo)
1593     {
1594         todo_wine {
1595             if (expected->message || actual->message) {
1596                 failcount++;
1597                 ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1598                     context, expected->message, actual->message);
1599             }
1600         }
1601     }
1602     else
1603     {
1604         if (expected->message || actual->message)
1605             ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1606                 context, expected->message, actual->message);
1607     }
1608     if( todo && !failcount) /* succeeded yet marked todo */
1609         todo_wine {
1610             ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
1611         }
1612
1613     flush_sequence();
1614 }
1615
1616 /******************************** MDI test **********************************/
1617
1618 /* CreateWindow for MDI frame window, initially visible */
1619 static const struct message WmCreateMDIframeSeq[] = {
1620     { HCBT_CREATEWND, hook },
1621     { WM_GETMINMAXINFO, sent },
1622     { WM_NCCREATE, sent },
1623     { WM_NCCALCSIZE, sent|wparam, 0 },
1624     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1625     { WM_CREATE, sent },
1626     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1627     { WM_SHOWWINDOW, sent|wparam, 1 },
1628     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1629     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1630     { HCBT_ACTIVATE, hook },
1631     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1632     { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1633     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* XP */
1634     { WM_ACTIVATEAPP, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
1635     { WM_NCACTIVATE, sent|wparam, 1 },
1636     { WM_GETTEXT, sent|defwinproc|optional },
1637     { WM_ACTIVATE, sent|wparam, 1 },
1638     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x */
1639     { HCBT_SETFOCUS, hook },
1640     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1641     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1642     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1643     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
1644     /* Win9x adds SWP_NOZORDER below */
1645     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1646     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
1647     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1648     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1649     { WM_MOVE, sent },
1650     { 0 }
1651 };
1652 /* DestroyWindow for MDI frame window, initially visible */
1653 static const struct message WmDestroyMDIframeSeq[] = {
1654     { HCBT_DESTROYWND, hook },
1655     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1656     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1657     { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
1658     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1659     { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* XP */
1660     { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
1661     { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
1662     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
1663     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1664     { WM_DESTROY, sent },
1665     { WM_NCDESTROY, sent },
1666     { 0 }
1667 };
1668 /* CreateWindow for MDI client window, initially visible */
1669 static const struct message WmCreateMDIclientSeq[] = {
1670     { HCBT_CREATEWND, hook },
1671     { WM_NCCREATE, sent },
1672     { WM_NCCALCSIZE, sent|wparam, 0 },
1673     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1674     { WM_CREATE, sent },
1675     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1676     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1677     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1678     { WM_MOVE, sent },
1679     { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
1680     { WM_SHOWWINDOW, sent|wparam, 1 },
1681     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1682     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1683     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1684     { 0 }
1685 };
1686 /* ShowWindow(SW_SHOW) for MDI client window */
1687 static const struct message WmShowMDIclientSeq[] = {
1688     { WM_SHOWWINDOW, sent|wparam, 1 },
1689     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1690     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1691     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1692     { 0 }
1693 };
1694 /* ShowWindow(SW_HIDE) for MDI client window */
1695 static const struct message WmHideMDIclientSeq[] = {
1696     { WM_SHOWWINDOW, sent|wparam, 0 },
1697     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1698     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* win2000 */
1699     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP */
1700     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1701     { 0 }
1702 };
1703 /* DestroyWindow for MDI client window, initially visible */
1704 static const struct message WmDestroyMDIclientSeq[] = {
1705     { HCBT_DESTROYWND, hook },
1706     { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
1707     { WM_SHOWWINDOW, sent|wparam, 0 },
1708     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1709     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1710     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1711     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1712     { WM_DESTROY, sent },
1713     { WM_NCDESTROY, sent },
1714     { 0 }
1715 };
1716 /* CreateWindow for MDI child window, initially visible */
1717 static const struct message WmCreateMDIchildVisibleSeq[] = {
1718     { HCBT_CREATEWND, hook },
1719     { WM_NCCREATE, sent }, 
1720     { WM_NCCALCSIZE, sent|wparam, 0 },
1721     { WM_CREATE, sent },
1722     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1723     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1724     { WM_MOVE, sent },
1725     /* Win2k sends wparam set to
1726      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1727      * while Win9x doesn't bother to set child window id according to
1728      * CLIENTCREATESTRUCT.idFirstChild
1729      */
1730     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1731     { WM_SHOWWINDOW, sent|wparam, 1 },
1732     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1733     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1734     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1735     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1736     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1737     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1738     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1739
1740     /* Win9x: message sequence terminates here. */
1741
1742     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1743     { HCBT_SETFOCUS, hook }, /* in MDI client */
1744     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1745     { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
1746     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1747     { WM_SETFOCUS, sent }, /* in MDI client */
1748     { HCBT_SETFOCUS, hook },
1749     { WM_KILLFOCUS, sent }, /* in MDI client */
1750     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1751     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1752     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1753     { WM_SETFOCUS, sent|defwinproc },
1754     { WM_MDIACTIVATE, sent|defwinproc },
1755     { 0 }
1756 };
1757 /* CreateWindow for MDI child window with invisible parent */
1758 static const struct message WmCreateMDIchildInvisibleParentSeq[] = {
1759     { HCBT_CREATEWND, hook },
1760     { WM_GETMINMAXINFO, sent },
1761     { WM_NCCREATE, sent }, 
1762     { WM_NCCALCSIZE, sent|wparam, 0 },
1763     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1764     { WM_CREATE, sent },
1765     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1766     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1767     { WM_MOVE, sent },
1768     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1769     { WM_SHOWWINDOW, sent|wparam, 1 },
1770     { WM_MDIREFRESHMENU, sent }, /* in MDI client */
1771     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1772     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1773     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1774
1775     /* Win9x: message sequence terminates here. */
1776
1777     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1778     { HCBT_SETFOCUS, hook }, /* in MDI client */
1779     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1780     { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
1781     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1782     { WM_SETFOCUS, sent }, /* in MDI client */
1783     { HCBT_SETFOCUS, hook },
1784     { WM_KILLFOCUS, sent }, /* in MDI client */
1785     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1786     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1787     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1788     { WM_SETFOCUS, sent|defwinproc },
1789     { WM_MDIACTIVATE, sent|defwinproc },
1790     { 0 }
1791 };
1792 /* DestroyWindow for MDI child window, initially visible */
1793 static const struct message WmDestroyMDIchildVisibleSeq[] = {
1794     { HCBT_DESTROYWND, hook },
1795     /* Win2k sends wparam set to
1796      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1797      * while Win9x doesn't bother to set child window id according to
1798      * CLIENTCREATESTRUCT.idFirstChild
1799      */
1800     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1801     { WM_SHOWWINDOW, sent|wparam, 0 },
1802     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1803     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1804     { WM_ERASEBKGND, sent|parent|optional },
1805     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1806
1807     /* { WM_DESTROY, sent }
1808      * Win9x: message sequence terminates here.
1809      */
1810
1811     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1812     { WM_KILLFOCUS, sent },
1813     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1814     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1815     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1816     { WM_SETFOCUS, sent }, /* in MDI client */
1817
1818     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1819     { WM_KILLFOCUS, sent }, /* in MDI client */
1820     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1821     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1822     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1823     { WM_SETFOCUS, sent }, /* in MDI client */
1824
1825     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1826
1827     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1828     { WM_KILLFOCUS, sent },
1829     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1830     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1831     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1832     { WM_SETFOCUS, sent }, /* in MDI client */
1833
1834     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1835     { WM_KILLFOCUS, sent }, /* in MDI client */
1836     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1837     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1838     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1839     { WM_SETFOCUS, sent }, /* in MDI client */
1840
1841     { WM_DESTROY, sent },
1842
1843     { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
1844     { WM_KILLFOCUS, sent },
1845     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1846     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1847     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1848     { WM_SETFOCUS, sent }, /* in MDI client */
1849
1850     { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
1851     { WM_KILLFOCUS, sent }, /* in MDI client */
1852     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1853     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1854     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1855     { WM_SETFOCUS, sent }, /* in MDI client */
1856
1857     { WM_NCDESTROY, sent },
1858     { 0 }
1859 };
1860 /* CreateWindow for MDI child window, initially invisible */
1861 static const struct message WmCreateMDIchildInvisibleSeq[] = {
1862     { HCBT_CREATEWND, hook },
1863     { WM_NCCREATE, sent }, 
1864     { WM_NCCALCSIZE, sent|wparam, 0 },
1865     { WM_CREATE, sent },
1866     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1867     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1868     { WM_MOVE, sent },
1869     /* Win2k sends wparam set to
1870      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1871      * while Win9x doesn't bother to set child window id according to
1872      * CLIENTCREATESTRUCT.idFirstChild
1873      */
1874     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1875     { 0 }
1876 };
1877 /* DestroyWindow for MDI child window, initially invisible */
1878 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
1879     { HCBT_DESTROYWND, hook },
1880     /* Win2k sends wparam set to
1881      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1882      * while Win9x doesn't bother to set child window id according to
1883      * CLIENTCREATESTRUCT.idFirstChild
1884      */
1885     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1886     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1887     { WM_DESTROY, sent },
1888     { WM_NCDESTROY, sent },
1889     /* FIXME: Wine destroys an icon/title window while Windows doesn't */
1890     { WM_PARENTNOTIFY, sent|wparam|optional, WM_DESTROY }, /* MDI client */
1891     { 0 }
1892 };
1893 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
1894 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
1895     { HCBT_CREATEWND, hook },
1896     { WM_NCCREATE, sent }, 
1897     { WM_NCCALCSIZE, sent|wparam, 0 },
1898     { WM_CREATE, sent },
1899     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1900     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1901     { WM_MOVE, sent },
1902     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1903     { WM_GETMINMAXINFO, sent },
1904     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1905     { WM_NCCALCSIZE, sent|wparam, 1 },
1906     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1907     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
1908      /* in MDI frame */
1909     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1910     { WM_NCCALCSIZE, sent|wparam, 1 },
1911     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1912     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1913     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1914     /* Win2k sends wparam set to
1915      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1916      * while Win9x doesn't bother to set child window id according to
1917      * CLIENTCREATESTRUCT.idFirstChild
1918      */
1919     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1920     { WM_SHOWWINDOW, sent|wparam, 1 },
1921     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1922     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1923     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1924     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1925     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1926     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1927     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1928
1929     /* Win9x: message sequence terminates here. */
1930
1931     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1932     { HCBT_SETFOCUS, hook }, /* in MDI client */
1933     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1934     { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
1935     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1936     { WM_SETFOCUS, sent }, /* in MDI client */
1937     { HCBT_SETFOCUS, hook },
1938     { WM_KILLFOCUS, sent }, /* in MDI client */
1939     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1940     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1941     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1942     { WM_SETFOCUS, sent|defwinproc },
1943     { WM_MDIACTIVATE, sent|defwinproc },
1944      /* in MDI frame */
1945     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1946     { WM_NCCALCSIZE, sent|wparam, 1 },
1947     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1948     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1949     { 0 }
1950 };
1951 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
1952 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
1953     /* restore the 1st MDI child */
1954     { WM_SETREDRAW, sent|wparam, 0 },
1955     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
1956     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
1957     { WM_NCCALCSIZE, sent|wparam, 1 },
1958     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1959     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1960     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1961      /* in MDI frame */
1962     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1963     { WM_NCCALCSIZE, sent|wparam, 1 },
1964     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1965     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1966     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1967     { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
1968     /* create the 2nd MDI child */
1969     { HCBT_CREATEWND, hook },
1970     { WM_NCCREATE, sent }, 
1971     { WM_NCCALCSIZE, sent|wparam, 0 },
1972     { WM_CREATE, sent },
1973     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1974     { WM_SIZE, sent|wparam, SIZE_RESTORED },
1975     { WM_MOVE, sent },
1976     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
1977     { WM_GETMINMAXINFO, sent },
1978     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
1979     { WM_NCCALCSIZE, sent|wparam, 1 },
1980     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1981     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
1982     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
1983      /* in MDI frame */
1984     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1985     { WM_NCCALCSIZE, sent|wparam, 1 },
1986     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1987     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
1988     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
1989     /* Win2k sends wparam set to
1990      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1991      * while Win9x doesn't bother to set child window id according to
1992      * CLIENTCREATESTRUCT.idFirstChild
1993      */
1994     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1995     { WM_SHOWWINDOW, sent|wparam, 1 },
1996     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1997     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1998     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1999     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2000     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2001     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2002
2003     { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2004     { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2005
2006     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2007
2008     /* Win9x: message sequence terminates here. */
2009
2010     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2011     { HCBT_SETFOCUS, hook },
2012     { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
2013     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
2014     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2015     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2016     { WM_SETFOCUS, sent }, /* in MDI client */
2017     { HCBT_SETFOCUS, hook },
2018     { WM_KILLFOCUS, sent }, /* in MDI client */
2019     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2020     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2021     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2022     { WM_SETFOCUS, sent|defwinproc },
2023
2024     { WM_MDIACTIVATE, sent|defwinproc },
2025      /* in MDI frame */
2026     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2027     { WM_NCCALCSIZE, sent|wparam, 1 },
2028     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2029     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2030     { 0 }
2031 };
2032 /* WM_MDICREATE MDI child window, initially visible and maximized */
2033 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
2034     { WM_MDICREATE, sent },
2035     { HCBT_CREATEWND, hook },
2036     { WM_NCCREATE, sent }, 
2037     { WM_NCCALCSIZE, sent|wparam, 0 },
2038     { WM_CREATE, sent },
2039     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2040     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2041     { WM_MOVE, sent },
2042     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2043     { WM_GETMINMAXINFO, sent },
2044     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
2045     { WM_NCCALCSIZE, sent|wparam, 1 },
2046     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2047     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2048
2049      /* in MDI frame */
2050     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2051     { WM_NCCALCSIZE, sent|wparam, 1 },
2052     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2053     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2054     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2055
2056     /* Win2k sends wparam set to
2057      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2058      * while Win9x doesn't bother to set child window id according to
2059      * CLIENTCREATESTRUCT.idFirstChild
2060      */
2061     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2062     { WM_SHOWWINDOW, sent|wparam, 1 },
2063     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2064
2065     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2066
2067     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2068     { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2069     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2070
2071     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2072     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2073
2074     /* Win9x: message sequence terminates here. */
2075
2076     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2077     { WM_SETFOCUS, sent|optional }, /* in MDI client */
2078     { HCBT_SETFOCUS, hook }, /* in MDI client */
2079     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2080     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
2081     { WM_SETFOCUS, sent|optional }, /* in MDI client */
2082     { HCBT_SETFOCUS, hook|optional },
2083     { WM_KILLFOCUS, sent }, /* in MDI client */
2084     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2085     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2086     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2087     { WM_SETFOCUS, sent|defwinproc },
2088
2089     { WM_MDIACTIVATE, sent|defwinproc },
2090
2091      /* in MDI child */
2092     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2093     { WM_NCCALCSIZE, sent|wparam, 1 },
2094     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2095     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2096
2097      /* in MDI frame */
2098     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2099     { WM_NCCALCSIZE, sent|wparam, 1 },
2100     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2101     { WM_MOVE, sent|defwinproc },
2102     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2103
2104      /* in MDI client */
2105     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2106     { WM_NCCALCSIZE, sent|wparam, 1 },
2107     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2108     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2109
2110      /* in MDI child */
2111     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2112     { WM_NCCALCSIZE, sent|wparam, 1 },
2113     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2114     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2115
2116     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2117     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2118     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
2119     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2120     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2121
2122     { 0 }
2123 };
2124 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
2125 static const struct message WmCreateMDIchildInvisibleMaxSeq4[] = {
2126     { HCBT_CREATEWND, hook },
2127     { WM_GETMINMAXINFO, sent },
2128     { WM_NCCREATE, sent }, 
2129     { WM_NCCALCSIZE, sent|wparam, 0 },
2130     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2131     { WM_CREATE, sent },
2132     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2133     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2134     { WM_MOVE, sent },
2135     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2136     { WM_GETMINMAXINFO, sent },
2137     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|0x8000 },
2138     { WM_GETMINMAXINFO, sent|defwinproc },
2139     { WM_NCCALCSIZE, sent|wparam, 1 },
2140     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|0x8000 },
2141     { WM_MOVE, sent|defwinproc },
2142     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2143      /* in MDI frame */
2144     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2145     { WM_NCCALCSIZE, sent|wparam, 1 },
2146     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2147     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2148     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI child */
2149     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2150     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2151     /* Win2k sends wparam set to
2152      * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2153      * while Win9x doesn't bother to set child window id according to
2154      * CLIENTCREATESTRUCT.idFirstChild
2155      */
2156     { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2157     { 0 }
2158 };
2159 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
2160 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
2161     { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
2162     { HCBT_SYSCOMMAND, hook },
2163     { WM_CLOSE, sent|defwinproc },
2164     { WM_MDIDESTROY, sent }, /* in MDI client */
2165
2166     /* bring the 1st MDI child to top */
2167     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
2168     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
2169
2170     { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2171
2172     { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
2173     { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2174     { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2175
2176     /* maximize the 1st MDI child */
2177     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2178     { WM_GETMINMAXINFO, sent|defwinproc },
2179     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|0x8000 },
2180     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2181     { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
2182     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2183     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2184
2185     /* restore the 2nd MDI child */
2186     { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
2187     { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
2188     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|0x8000 },
2189     { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2190
2191     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2192
2193     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2194     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2195
2196     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2197
2198     { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
2199      /* in MDI frame */
2200     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2201     { WM_NCCALCSIZE, sent|wparam, 1 },
2202     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2203     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2204     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2205
2206     /* bring the 1st MDI child to top */
2207     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2208     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2209     { HCBT_SETFOCUS, hook },
2210     { WM_KILLFOCUS, sent|defwinproc },
2211     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
2212     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2213     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2214     { WM_SETFOCUS, sent }, /* in MDI client */
2215     { HCBT_SETFOCUS, hook },
2216     { WM_KILLFOCUS, sent }, /* in MDI client */
2217     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2218     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2219     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2220     { WM_SETFOCUS, sent|defwinproc },
2221     { WM_MDIACTIVATE, sent|defwinproc },
2222     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2223
2224     /* apparently ShowWindow(SW_SHOW) on an MDI client */
2225     { WM_SHOWWINDOW, sent|wparam, 1 },
2226     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2227     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2228     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2229     { WM_MDIREFRESHMENU, sent },
2230
2231     { HCBT_DESTROYWND, hook },
2232     /* Win2k sends wparam set to
2233      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2234      * while Win9x doesn't bother to set child window id according to
2235      * CLIENTCREATESTRUCT.idFirstChild
2236      */
2237     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2238     { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
2239     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2240     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2241     { WM_ERASEBKGND, sent|parent|optional },
2242     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2243
2244     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2245     { WM_DESTROY, sent|defwinproc },
2246     { WM_NCDESTROY, sent|defwinproc },
2247     { 0 }
2248 };
2249 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
2250 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
2251     { WM_MDIDESTROY, sent }, /* in MDI client */
2252     { WM_SHOWWINDOW, sent|wparam, 0 },
2253     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2254     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2255     { WM_ERASEBKGND, sent|parent|optional },
2256     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2257
2258     { HCBT_SETFOCUS, hook },
2259     { WM_KILLFOCUS, sent },
2260     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2261     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2262     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2263     { WM_SETFOCUS, sent }, /* in MDI client */
2264     { HCBT_SETFOCUS, hook },
2265     { WM_KILLFOCUS, sent }, /* in MDI client */
2266     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2267     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2268     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2269     { WM_SETFOCUS, sent },
2270
2271      /* in MDI child */
2272     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2273     { WM_NCCALCSIZE, sent|wparam, 1 },
2274     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2275     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2276
2277      /* in MDI frame */
2278     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2279     { WM_NCCALCSIZE, sent|wparam, 1 },
2280     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2281     { WM_MOVE, sent|defwinproc },
2282     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2283
2284      /* in MDI client */
2285     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2286     { WM_NCCALCSIZE, sent|wparam, 1 },
2287     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2288     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2289
2290      /* in MDI child */
2291     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2292     { WM_NCCALCSIZE, sent|wparam, 1 },
2293     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2294     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2295
2296      /* in MDI child */
2297     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2298     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2299     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2300     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2301
2302      /* in MDI frame */
2303     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2304     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2305     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2306     { WM_MOVE, sent|defwinproc },
2307     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2308
2309      /* in MDI client */
2310     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2311     { WM_NCCALCSIZE, sent|wparam, 1 },
2312     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2313     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2314
2315      /* in MDI child */
2316     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2317     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2318     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2319     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2320     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2321     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2322
2323     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
2324
2325     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2326     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2327     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2328     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2329     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2330
2331      /* in MDI frame */
2332     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2333     { WM_NCCALCSIZE, sent|wparam, 1 },
2334     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2335     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2336
2337     { WM_NCACTIVATE, sent|wparam, 0 },
2338     { WM_MDIACTIVATE, sent },
2339
2340     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2341     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|0x8000 },
2342     { WM_NCCALCSIZE, sent|wparam, 1 },
2343
2344     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2345
2346     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2347     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOCLIENTMOVE|0x8000 },
2348     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2349
2350      /* in MDI child */
2351     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2352     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2353     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2354     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2355
2356      /* in MDI frame */
2357     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2358     { WM_NCCALCSIZE, sent|wparam, 1 },
2359     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2360     { WM_MOVE, sent|defwinproc },
2361     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2362
2363      /* in MDI client */
2364     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2365     { WM_NCCALCSIZE, sent|wparam, 1 },
2366     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2367     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2368     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2369     { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2370     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2371     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2372     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2373
2374     { HCBT_SETFOCUS, hook },
2375     { WM_KILLFOCUS, sent },
2376     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2377     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2378     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2379     { WM_SETFOCUS, sent }, /* in MDI client */
2380
2381     { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2382
2383     { HCBT_DESTROYWND, hook },
2384     /* Win2k sends wparam set to
2385      * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2386      * while Win9x doesn't bother to set child window id according to
2387      * CLIENTCREATESTRUCT.idFirstChild
2388      */
2389     { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2390
2391     { WM_SHOWWINDOW, sent|wparam, 0 },
2392     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2393     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2394     { WM_ERASEBKGND, sent|parent|optional },
2395     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2396
2397     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2398     { WM_DESTROY, sent },
2399     { WM_NCDESTROY, sent },
2400     { 0 }
2401 };
2402 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
2403 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
2404     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2405     { WM_GETMINMAXINFO, sent },
2406     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
2407     { WM_NCCALCSIZE, sent|wparam, 1 },
2408     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2409     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2410
2411     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2412     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2413     { HCBT_SETFOCUS, hook },
2414     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2415     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2416     { WM_SETFOCUS, sent }, /* in MDI client */
2417     { HCBT_SETFOCUS, hook },
2418     { WM_KILLFOCUS, sent }, /* in MDI client */
2419     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2420     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2421     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2422     { WM_SETFOCUS, sent|defwinproc },
2423     { WM_MDIACTIVATE, sent|defwinproc },
2424     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2425     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2426      /* in MDI frame */
2427     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2428     { WM_NCCALCSIZE, sent|wparam, 1 },
2429     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2430     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2431     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2432     { 0 }
2433 };
2434 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
2435 static const struct message WmMaximizeMDIchildInvisibleSeq2[] = {
2436     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2437     { WM_GETMINMAXINFO, sent },
2438     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
2439     { WM_GETMINMAXINFO, sent|defwinproc },
2440     { WM_NCCALCSIZE, sent|wparam, 1 },
2441     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2442     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2443
2444     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2445     { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2446     { HCBT_SETFOCUS, hook },
2447     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2448     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2449     { WM_SETFOCUS, sent }, /* in MDI client */
2450     { HCBT_SETFOCUS, hook },
2451     { WM_KILLFOCUS, sent }, /* in MDI client */
2452     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2453     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2454     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2455     { WM_SETFOCUS, sent|defwinproc },
2456     { WM_MDIACTIVATE, sent|defwinproc },
2457     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2458     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2459     { 0 }
2460 };
2461 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
2462 static const struct message WmMaximizeMDIchildInvisibleParentSeq[] = {
2463     { WM_MDIMAXIMIZE, sent }, /* in MDI client */
2464     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2465     { WM_GETMINMAXINFO, sent },
2466     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
2467     { WM_GETMINMAXINFO, sent|defwinproc },
2468     { WM_NCCALCSIZE, sent|wparam, 1 },
2469     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP doesn't send it */
2470     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2471     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOREDRAW|0x8000 },
2472     { WM_MOVE, sent|defwinproc },
2473     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2474
2475     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2476     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2477     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2478     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
2479     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2480     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
2481      /* in MDI frame */
2482     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2483     { WM_NCCALCSIZE, sent|wparam, 1 },
2484     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2485     { WM_MOVE, sent|defwinproc },
2486     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2487     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame win2000 */
2488      /* in MDI client */
2489     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2490     { WM_NCCALCSIZE, sent|wparam, 1 },
2491     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2492     { WM_SIZE, sent|wparam, SIZE_RESTORED },
2493      /* in MDI child */
2494     { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2495     { WM_GETMINMAXINFO, sent|defwinproc },
2496     { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2497     { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2498     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2499     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child win2000 */
2500     { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
2501     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2502     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2503     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
2504      /* in MDI frame */
2505     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2506     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
2507     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
2508     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2509     { 0 }
2510 };
2511 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
2512 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
2513     { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2514     { WM_GETMINMAXINFO, sent },
2515     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
2516     { WM_NCCALCSIZE, sent|wparam, 1 },
2517     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2518     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2519     { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2520      /* in MDI frame */
2521     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2522     { WM_NCCALCSIZE, sent|wparam, 1 },
2523     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2524     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2525     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2526     { 0 }
2527 };
2528 /* ShowWindow(SW_RESTORE) for a visible maximized MDI child window */
2529 static const struct message WmRestoreMDIchildVisibleSeq[] = {
2530     { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
2531     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
2532     { WM_NCCALCSIZE, sent|wparam, 1 },
2533     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2534     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2535     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2536      /* in MDI frame */
2537     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2538     { WM_NCCALCSIZE, sent|wparam, 1 },
2539     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2540     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2541     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2542     { 0 }
2543 };
2544 /* ShowWindow(SW_RESTORE) for a visible minimized MDI child window */
2545 static const struct message WmRestoreMDIchildVisibleSeq_2[] = {
2546     { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
2547     { WM_QUERYOPEN, sent|wparam|lparam, 0, 0 },
2548     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
2549     { WM_NCCALCSIZE, sent|wparam, 1 },
2550     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2551     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_NOCLIENTSIZE|0x8000 },
2552     { WM_MOVE, sent|defwinproc },
2553     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2554     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2555     { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2556     { HCBT_SETFOCUS, hook },
2557     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2558     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
2559     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2560     { WM_SETFOCUS, sent },
2561     { 0 }
2562 };
2563 /* ShowWindow(SW_MINIMIZE) for a visible restored MDI child window */
2564 static const struct message WmMinimizeMDIchildVisibleSeq[] = {
2565     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
2566     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|0x8000 },
2567     { WM_NCCALCSIZE, sent|wparam, 1 },
2568     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOCLIENTSIZE|0x8000 },
2569     { WM_MOVE, sent|defwinproc },
2570     { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
2571     { WM_CHILDACTIVATE, sent|wparam|lparam|defwinproc, 0, 0 },
2572     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2573     { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2574     /* FIXME: Wine creates an icon/title window while Windows doesn't */
2575     { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE }, /* MDI client */
2576     { 0 }
2577 };
2578 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
2579 static const struct message WmRestoreMDIchildInisibleSeq[] = {
2580     { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
2581     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|0x8000 },
2582     { WM_NCCALCSIZE, sent|wparam, 1 },
2583     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2584     { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2585     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|0x8000 },
2586     { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2587      /* in MDI frame */
2588     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2589     { WM_NCCALCSIZE, sent|wparam, 1 },
2590     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2591     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2592     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2593     { 0 }
2594 };
2595
2596 static HWND mdi_client;
2597 static WNDPROC old_mdi_client_proc;
2598
2599 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2600 {
2601     struct message msg;
2602
2603     /* do not log painting messages */
2604     if (message != WM_PAINT &&
2605         message != WM_NCPAINT &&
2606         message != WM_SYNCPAINT &&
2607         message != WM_ERASEBKGND &&
2608         message != WM_NCPAINT &&
2609         message != WM_NCHITTEST &&
2610         message != WM_GETTEXT &&
2611         message != WM_MDIGETACTIVE &&
2612         message != WM_GETICON &&
2613         message != WM_DEVICECHANGE)
2614     {
2615         trace("mdi client: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
2616
2617         switch (message)
2618         {
2619             case WM_WINDOWPOSCHANGING:
2620             case WM_WINDOWPOSCHANGED:
2621             {
2622                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2623
2624                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2625                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2626                       winpos->hwnd, winpos->hwndInsertAfter,
2627                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2628                 dump_winpos_flags(winpos->flags);
2629
2630                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2631                  * in the high word for internal purposes
2632                  */
2633                 wParam = winpos->flags & 0xffff;
2634                 /* We are not interested in the flags that don't match under XP and Win9x */
2635                 wParam &= ~(SWP_NOZORDER);
2636                 break;
2637             }
2638         }
2639
2640         msg.message = message;
2641         msg.flags = sent|wparam|lparam;
2642         msg.wParam = wParam;
2643         msg.lParam = lParam;
2644         add_message(&msg);
2645     }
2646
2647     return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
2648 }
2649
2650 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2651 {
2652     static long defwndproc_counter = 0;
2653     LRESULT ret;
2654     struct message msg;
2655
2656     /* do not log painting messages */
2657     if (message != WM_PAINT &&
2658         message != WM_NCPAINT &&
2659         message != WM_SYNCPAINT &&
2660         message != WM_ERASEBKGND &&
2661         message != WM_NCPAINT &&
2662         message != WM_NCHITTEST &&
2663         message != WM_GETTEXT &&
2664         message != WM_GETICON &&
2665         message != WM_DEVICECHANGE)
2666     {
2667         trace("mdi child: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
2668
2669         switch (message)
2670         {
2671             case WM_WINDOWPOSCHANGING:
2672             case WM_WINDOWPOSCHANGED:
2673             {
2674                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2675
2676                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2677                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2678                       winpos->hwnd, winpos->hwndInsertAfter,
2679                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2680                 dump_winpos_flags(winpos->flags);
2681
2682                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2683                  * in the high word for internal purposes
2684                  */
2685                 wParam = winpos->flags & 0xffff;
2686                 /* We are not interested in the flags that don't match under XP and Win9x */
2687                 wParam &= ~(SWP_NOZORDER);
2688                 break;
2689             }
2690
2691             case WM_MDIACTIVATE:
2692             {
2693                 HWND active, client = GetParent(hwnd);
2694
2695                 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
2696
2697                 if (hwnd == (HWND)lParam) /* if we are being activated */
2698                     ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
2699                 else
2700                     ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
2701                 break;
2702             }
2703         }
2704
2705         msg.message = message;
2706         msg.flags = sent|wparam|lparam;
2707         if (defwndproc_counter) msg.flags |= defwinproc;
2708         msg.wParam = wParam;
2709         msg.lParam = lParam;
2710         add_message(&msg);
2711     }
2712
2713     defwndproc_counter++;
2714     ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
2715     defwndproc_counter--;
2716
2717     return ret;
2718 }
2719
2720 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2721 {
2722     static long defwndproc_counter = 0;
2723     LRESULT ret;
2724     struct message msg;
2725
2726     /* do not log painting messages */
2727     if (message != WM_PAINT &&
2728         message != WM_NCPAINT &&
2729         message != WM_SYNCPAINT &&
2730         message != WM_ERASEBKGND &&
2731         message != WM_NCPAINT &&
2732         message != WM_NCHITTEST &&
2733         message != WM_GETTEXT &&
2734         message != WM_GETICON &&
2735         message != WM_DEVICECHANGE)
2736     {
2737         trace("mdi frame: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
2738
2739         switch (message)
2740         {
2741             case WM_WINDOWPOSCHANGING:
2742             case WM_WINDOWPOSCHANGED:
2743             {
2744                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2745
2746                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2747                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
2748                       winpos->hwnd, winpos->hwndInsertAfter,
2749                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2750                 dump_winpos_flags(winpos->flags);
2751
2752                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2753                  * in the high word for internal purposes
2754                  */
2755                 wParam = winpos->flags & 0xffff;
2756                 /* We are not interested in the flags that don't match under XP and Win9x */
2757                 wParam &= ~(SWP_NOZORDER);
2758                 break;
2759             }
2760         }
2761
2762         msg.message = message;
2763         msg.flags = sent|wparam|lparam;
2764         if (defwndproc_counter) msg.flags |= defwinproc;
2765         msg.wParam = wParam;
2766         msg.lParam = lParam;
2767         add_message(&msg);
2768     }
2769
2770     defwndproc_counter++;
2771     ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
2772     defwndproc_counter--;
2773
2774     return ret;
2775 }
2776
2777 static BOOL mdi_RegisterWindowClasses(void)
2778 {
2779     WNDCLASSA cls;
2780
2781     cls.style = 0;
2782     cls.lpfnWndProc = mdi_frame_wnd_proc;
2783     cls.cbClsExtra = 0;
2784     cls.cbWndExtra = 0;
2785     cls.hInstance = GetModuleHandleA(0);
2786     cls.hIcon = 0;
2787     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
2788     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
2789     cls.lpszMenuName = NULL;
2790     cls.lpszClassName = "MDI_frame_class";
2791     if (!RegisterClassA(&cls)) return FALSE;
2792
2793     cls.lpfnWndProc = mdi_child_wnd_proc;
2794     cls.lpszClassName = "MDI_child_class";
2795     if (!RegisterClassA(&cls)) return FALSE;
2796
2797     if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
2798     old_mdi_client_proc = cls.lpfnWndProc;
2799     cls.hInstance = GetModuleHandleA(0);
2800     cls.lpfnWndProc = mdi_client_hook_proc;
2801     cls.lpszClassName = "MDI_client_class";
2802     if (!RegisterClassA(&cls)) assert(0);
2803
2804     return TRUE;
2805 }
2806
2807 static void test_mdi_messages(void)
2808 {
2809     MDICREATESTRUCTA mdi_cs;
2810     CLIENTCREATESTRUCT client_cs;
2811     HWND mdi_frame, mdi_child, mdi_child2, active_child;
2812     BOOL zoomed;
2813     HMENU hMenu = CreateMenu();
2814
2815     assert(mdi_RegisterWindowClasses());
2816
2817     flush_sequence();
2818
2819     trace("creating MDI frame window\n");
2820     mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
2821                                 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
2822                                 WS_MAXIMIZEBOX | WS_VISIBLE,
2823                                 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
2824                                 GetDesktopWindow(), hMenu,
2825                                 GetModuleHandleA(0), NULL);
2826     assert(mdi_frame);
2827     ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
2828
2829     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2830     ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
2831
2832     trace("creating MDI client window\n");
2833     client_cs.hWindowMenu = 0;
2834     client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
2835     mdi_client = CreateWindowExA(0, "MDI_client_class",
2836                                  NULL,
2837                                  WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
2838                                  0, 0, 0, 0,
2839                                  mdi_frame, 0, GetModuleHandleA(0), &client_cs);
2840     assert(mdi_client);
2841     ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
2842
2843     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2844     ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
2845
2846     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2847     ok(!active_child, "wrong active MDI child %p\n", active_child);
2848     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2849
2850     SetFocus(0);
2851     flush_sequence();
2852
2853     trace("creating invisible MDI child window\n");
2854     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2855                                 WS_CHILD,
2856                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2857                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2858     assert(mdi_child);
2859
2860     flush_sequence();
2861     ShowWindow(mdi_child, SW_SHOWNORMAL);
2862     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
2863
2864     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2865     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2866
2867     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2868     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2869
2870     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2871     ok(!active_child, "wrong active MDI child %p\n", active_child);
2872     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2873
2874     ShowWindow(mdi_child, SW_HIDE);
2875     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
2876     flush_sequence();
2877
2878     ShowWindow(mdi_child, SW_SHOW);
2879     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
2880
2881     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2882     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2883
2884     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2885     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2886
2887     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2888     ok(!active_child, "wrong active MDI child %p\n", active_child);
2889     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2890
2891     DestroyWindow(mdi_child);
2892     flush_sequence();
2893
2894     trace("creating visible MDI child window\n");
2895     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2896                                 WS_CHILD | WS_VISIBLE,
2897                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2898                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2899     assert(mdi_child);
2900     ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
2901
2902     ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2903     ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
2904
2905     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2906     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
2907
2908     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2909     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
2910     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2911     flush_sequence();
2912
2913     DestroyWindow(mdi_child);
2914     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
2915
2916     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2917     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2918
2919     /* Win2k: MDI client still returns a just destroyed child as active
2920      * Win9x: MDI client returns 0
2921      */
2922     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2923     ok(active_child == mdi_child || /* win2k */
2924        !active_child, /* win9x */
2925        "wrong active MDI child %p\n", active_child);
2926     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2927
2928     flush_sequence();
2929
2930     trace("creating invisible MDI child window\n");
2931     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
2932                                 WS_CHILD,
2933                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
2934                                 mdi_client, 0, GetModuleHandleA(0), NULL);
2935     assert(mdi_child2);
2936     ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
2937
2938     ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
2939     ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
2940
2941     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2942     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2943
2944     /* Win2k: MDI client still returns a just destroyed child as active
2945      * Win9x: MDI client returns mdi_child2
2946      */
2947     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2948     ok(active_child == mdi_child || /* win2k */
2949        active_child == mdi_child2, /* win9x */
2950        "wrong active MDI child %p\n", active_child);
2951     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2952     flush_sequence();
2953
2954     ShowWindow(mdi_child2, SW_MAXIMIZE);
2955     ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
2956
2957     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2958     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
2959
2960     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2961     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2962     ok(zoomed, "wrong zoomed state %d\n", zoomed);
2963     flush_sequence();
2964
2965     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2966     ok(GetFocus() == mdi_child2 || /* win2k */
2967        GetFocus() == 0, /* win9x */
2968        "wrong focus window %p\n", GetFocus());
2969
2970     SetFocus(0);
2971     flush_sequence();
2972
2973     ShowWindow(mdi_child2, SW_HIDE);
2974     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2975
2976     ShowWindow(mdi_child2, SW_RESTORE);
2977     ok_sequence(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
2978     flush_sequence();
2979
2980     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
2981     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
2982
2983     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
2984     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
2985     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
2986     flush_sequence();
2987
2988     SetFocus(0);
2989     flush_sequence();
2990
2991     ShowWindow(mdi_child2, SW_HIDE);
2992     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
2993
2994     ShowWindow(mdi_child2, SW_SHOW);
2995     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
2996
2997     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
2998     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
2999
3000     ShowWindow(mdi_child2, SW_MAXIMIZE);
3001     ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
3002
3003     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3004     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3005
3006     ShowWindow(mdi_child2, SW_RESTORE);
3007     ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
3008
3009     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3010     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3011
3012     ShowWindow(mdi_child2, SW_MINIMIZE);
3013     ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", TRUE);
3014
3015     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3016     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3017
3018     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3019     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3020     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3021     flush_sequence();
3022
3023     ShowWindow(mdi_child2, SW_RESTORE);
3024     ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", TRUE);
3025
3026     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3027     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3028
3029     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3030     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3031     ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3032     flush_sequence();
3033
3034     SetFocus(0);
3035     flush_sequence();
3036
3037     ShowWindow(mdi_child2, SW_HIDE);
3038     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3039
3040     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3041     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3042
3043     DestroyWindow(mdi_child2);
3044     ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
3045
3046     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3047     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3048
3049     /* test for maximized MDI children */
3050     trace("creating maximized visible MDI child window 1\n");
3051     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3052                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3053                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3054                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3055     assert(mdi_child);
3056     ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
3057     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3058
3059     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3060     ok(GetFocus() == mdi_child || /* win2k */
3061        GetFocus() == 0, /* win9x */
3062        "wrong focus window %p\n", GetFocus());
3063
3064     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3065     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3066     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3067     flush_sequence();
3068
3069     trace("creating maximized visible MDI child window 2\n");
3070     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3071                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3072                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3073                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3074     assert(mdi_child2);
3075     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3076     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3077     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3078
3079     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3080     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3081
3082     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3083     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3084     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3085     flush_sequence();
3086
3087     trace("destroying maximized visible MDI child window 2\n");
3088     DestroyWindow(mdi_child2);
3089     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3090
3091     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3092
3093     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3094     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3095
3096     /* Win2k: MDI client still returns a just destroyed child as active
3097      * Win9x: MDI client returns 0
3098      */
3099     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3100     ok(active_child == mdi_child2 || /* win2k */
3101        !active_child, /* win9x */
3102        "wrong active MDI child %p\n", active_child);
3103     flush_sequence();
3104
3105     ShowWindow(mdi_child, SW_MAXIMIZE);
3106     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3107     flush_sequence();
3108
3109     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3110     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3111
3112     trace("re-creating maximized visible MDI child window 2\n");
3113     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3114                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3115                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3116                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3117     assert(mdi_child2);
3118     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3119     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3120     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3121
3122     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3123     ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3124
3125     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3126     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3127     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3128     flush_sequence();
3129
3130     SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
3131     ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
3132     ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
3133
3134     ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3135     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3136     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3137
3138     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3139     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3140     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3141     flush_sequence();
3142
3143     DestroyWindow(mdi_child);
3144     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3145
3146     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3147     ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3148
3149     /* Win2k: MDI client still returns a just destroyed child as active
3150      * Win9x: MDI client returns 0
3151      */
3152     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3153     ok(active_child == mdi_child || /* win2k */
3154        !active_child, /* win9x */
3155        "wrong active MDI child %p\n", active_child);
3156     flush_sequence();
3157
3158     trace("creating maximized invisible MDI child window\n");
3159     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3160                                 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
3161                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3162                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3163     assert(mdi_child2);
3164     ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", TRUE);
3165     ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3166     ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
3167     ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
3168
3169     /* Win2k: MDI client still returns a just destroyed child as active
3170      * Win9x: MDI client returns 0
3171      */
3172     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3173     ok(active_child == mdi_child || /* win2k */
3174        !active_child, /* win9x */
3175        "wrong active MDI child %p\n", active_child);
3176     flush_sequence();
3177
3178     trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
3179     ShowWindow(mdi_child2, SW_MAXIMIZE);
3180     ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
3181     ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3182     ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3183     ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3184
3185     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3186     ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3187     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3188     flush_sequence();
3189
3190     SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3191     flush_sequence();
3192
3193     /* end of test for maximized MDI children */
3194
3195     mdi_cs.szClass = "MDI_child_Class";
3196     mdi_cs.szTitle = "MDI child";
3197     mdi_cs.hOwner = GetModuleHandleA(0);
3198     mdi_cs.x = 0;
3199     mdi_cs.y = 0;
3200     mdi_cs.cx = CW_USEDEFAULT;
3201     mdi_cs.cy = CW_USEDEFAULT;
3202     mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
3203     mdi_cs.lParam = 0;
3204     mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
3205     ok(mdi_child != 0, "MDI child creation failed\n");
3206     ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
3207
3208     ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
3209
3210     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3211     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3212
3213     ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
3214     ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3215     ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3216
3217     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3218     ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3219     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3220     flush_sequence();
3221
3222     SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3223     ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
3224
3225     ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
3226     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3227     ok(!active_child, "wrong active MDI child %p\n", active_child);
3228
3229     SetFocus(0);
3230     flush_sequence();
3231
3232     DestroyWindow(mdi_client);
3233     ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3234
3235     /* test maximization of MDI child with invisible parent */
3236     client_cs.hWindowMenu = 0;
3237     mdi_client = CreateWindow("MDI_client_class",
3238                                  NULL,
3239                                  WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
3240                                  0, 0, 660, 430,
3241                                  mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3242     ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
3243
3244     ShowWindow(mdi_client, SW_HIDE);
3245     ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
3246
3247     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3248                                 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
3249                                 0, 0, 650, 440,
3250                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3251     ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
3252
3253     SendMessage(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
3254     ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
3255     zoomed = IsZoomed(mdi_child);
3256     ok(zoomed, "wrong zoomed state %d\n", zoomed);
3257     
3258     ShowWindow(mdi_client, SW_SHOW);
3259     ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
3260
3261     DestroyWindow(mdi_child);
3262     ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
3263
3264     /* end of test for maximization of MDI child with invisible parent */
3265
3266     /* test for switch maximized MDI children */
3267     trace("creating maximized visible MDI child window 1(Switch test)\n");
3268     mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3269                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3270                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3271                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3272     assert(mdi_child);
3273     ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
3274     ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
3275
3276     ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3277     ok(GetFocus() == mdi_child || /* win2k */
3278        GetFocus() == 0, /* win9x */
3279        "wrong focus window %p(Switch test)\n", GetFocus());
3280
3281     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3282     ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3283     ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3284     flush_sequence();
3285
3286     trace("creating maximized visible MDI child window 2(Switch test)\n");
3287     mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3288                                 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3289                                 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3290                                 mdi_client, 0, GetModuleHandleA(0), NULL);
3291     assert(mdi_child2);
3292     ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window(Switch test)\n", TRUE);
3293     ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
3294     ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
3295
3296     ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3297     ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
3298
3299     active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3300     ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
3301     ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3302     flush_sequence();
3303
3304     trace("Switch child window.\n");
3305     SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
3306     ok_sequence(WmSwitchChild,"Child not switch correctly\n",TRUE);
3307     
3308     trace("end of test for switch maximized MDI children\n");
3309
3310     SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3311     flush_sequence();
3312
3313     SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3314     flush_sequence();
3315
3316     /* end of test for switch maximized MDI children */
3317
3318     DestroyWindow(mdi_client);
3319     ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3320
3321     DestroyWindow(mdi_frame);
3322     ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
3323 }
3324 /************************* End of MDI test **********************************/
3325
3326 static void test_WM_SETREDRAW(HWND hwnd)
3327 {
3328     DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
3329
3330     flush_sequence();
3331
3332     SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3333     ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
3334
3335     ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
3336     ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
3337
3338     flush_sequence();
3339     SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
3340     ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
3341
3342     ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3343     ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
3344
3345     /* restore original WS_VISIBLE state */
3346     SetWindowLongA(hwnd, GWL_STYLE, style);
3347
3348     flush_sequence();
3349 }
3350
3351 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3352 {
3353     struct message msg;
3354
3355     trace("dialog: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
3356
3357     /* explicitly ignore WM_GETICON message */
3358     if (message == WM_GETICON) return 0;
3359
3360     switch (message)
3361     {
3362         /* ignore */
3363         case WM_MOUSEMOVE:
3364         case WM_SETCURSOR:
3365         case WM_DEVICECHANGE:
3366             return 0;
3367         case WM_NCHITTEST:
3368             return HTCLIENT;
3369
3370         case WM_WINDOWPOSCHANGING:
3371         case WM_WINDOWPOSCHANGED:
3372         {
3373             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
3374
3375             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
3376             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
3377                   winpos->hwnd, winpos->hwndInsertAfter,
3378                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
3379             dump_winpos_flags(winpos->flags);
3380
3381             /* Log only documented flags, win2k uses 0x1000 and 0x2000
3382              * in the high word for internal purposes
3383              */
3384             wParam = winpos->flags & 0xffff;
3385             /* We are not interested in the flags that don't match under XP and Win9x */
3386             wParam &= ~(SWP_NOZORDER);
3387             break;
3388         }
3389     }
3390
3391     msg.message = message;
3392     msg.flags = sent|wparam|lparam;
3393     msg.wParam = wParam;
3394     msg.lParam = lParam;
3395     add_message(&msg);
3396
3397     if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
3398     if (message == WM_TIMER) EndDialog( hwnd, 0 );
3399     return 0;
3400 }
3401
3402 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
3403 {
3404     DWORD style, exstyle;
3405     INT xmin, xmax;
3406     BOOL ret;
3407
3408     exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
3409     style = GetWindowLongA(hwnd, GWL_STYLE);
3410     /* do not be confused by WS_DLGFRAME set */
3411     if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
3412
3413     if (clear) ok(style & clear, "style %08x should be set\n", clear);
3414     if (set) ok(!(style & set), "style %08x should not be set\n", set);
3415
3416     ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
3417     ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
3418     if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
3419         ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
3420     else
3421         ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
3422
3423     style = GetWindowLongA(hwnd, GWL_STYLE);
3424     if (set) ok(style & set, "style %08x should be set\n", set);
3425     if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
3426
3427     /* a subsequent call should do nothing */
3428     ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
3429     ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
3430     ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3431
3432     xmin = 0xdeadbeef;
3433     xmax = 0xdeadbeef;
3434     trace("Ignore GetScrollRange error below if you are on Win9x\n");
3435     ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
3436     ok( ret, "GetScrollRange(%d) error %d\n", ctl, GetLastError());
3437     ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3438     ok(xmin == min, "unexpected min scroll value %d\n", xmin);
3439     ok(xmax == max, "unexpected max scroll value %d\n", xmax);
3440 }
3441
3442 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
3443 {
3444     DWORD style, exstyle;
3445     SCROLLINFO si;
3446     BOOL ret;
3447
3448     exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
3449     style = GetWindowLongA(hwnd, GWL_STYLE);
3450     /* do not be confused by WS_DLGFRAME set */
3451     if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
3452
3453     if (clear) ok(style & clear, "style %08x should be set\n", clear);
3454     if (set) ok(!(style & set), "style %08x should not be set\n", set);
3455
3456     si.cbSize = sizeof(si);
3457     si.fMask = SIF_RANGE;
3458     si.nMin = min;
3459     si.nMax = max;
3460     SetScrollInfo(hwnd, ctl, &si, TRUE);
3461     if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
3462         ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
3463     else
3464         ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
3465
3466     style = GetWindowLongA(hwnd, GWL_STYLE);
3467     if (set) ok(style & set, "style %08x should be set\n", set);
3468     if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
3469
3470     /* a subsequent call should do nothing */
3471     SetScrollInfo(hwnd, ctl, &si, TRUE);
3472     if (style & WS_HSCROLL)
3473         ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3474     else if (style & WS_VSCROLL)
3475         ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3476     else
3477         ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3478
3479     si.fMask = SIF_PAGE;
3480     si.nPage = 5;
3481     SetScrollInfo(hwnd, ctl, &si, FALSE);
3482     ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3483
3484     si.fMask = SIF_POS;
3485     si.nPos = max - 1;
3486     SetScrollInfo(hwnd, ctl, &si, FALSE);
3487     ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3488
3489     si.fMask = SIF_RANGE;
3490     si.nMin = 0xdeadbeef;
3491     si.nMax = 0xdeadbeef;
3492     ret = GetScrollInfo(hwnd, ctl, &si);
3493     ok( ret, "GetScrollInfo error %d\n", GetLastError());
3494     ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3495     ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
3496     ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
3497 }
3498
3499 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
3500 static void test_scroll_messages(HWND hwnd)
3501 {
3502     SCROLLINFO si;
3503     INT min, max;
3504     BOOL ret;
3505
3506     min = 0xdeadbeef;
3507     max = 0xdeadbeef;
3508     ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
3509     ok( ret, "GetScrollRange error %d\n", GetLastError());
3510     if (sequence->message != WmGetScrollRangeSeq[0].message)
3511         trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3512     /* values of min and max are undefined */
3513     flush_sequence();
3514
3515     ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
3516     ok( ret, "SetScrollRange error %d\n", GetLastError());
3517     if (sequence->message != WmSetScrollRangeSeq[0].message)
3518         trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3519     flush_sequence();
3520
3521     min = 0xdeadbeef;
3522     max = 0xdeadbeef;
3523     ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
3524     ok( ret, "GetScrollRange error %d\n", GetLastError());
3525     if (sequence->message != WmGetScrollRangeSeq[0].message)
3526         trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3527     /* values of min and max are undefined */
3528     flush_sequence();
3529
3530     si.cbSize = sizeof(si);
3531     si.fMask = SIF_RANGE;
3532     si.nMin = 20;
3533     si.nMax = 160;
3534     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
3535     if (sequence->message != WmSetScrollRangeSeq[0].message)
3536         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3537     flush_sequence();
3538
3539     si.fMask = SIF_PAGE;
3540     si.nPage = 10;
3541     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
3542     if (sequence->message != WmSetScrollRangeSeq[0].message)
3543         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3544     flush_sequence();
3545
3546     si.fMask = SIF_POS;
3547     si.nPos = 20;
3548     SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
3549     if (sequence->message != WmSetScrollRangeSeq[0].message)
3550         trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3551     flush_sequence();
3552
3553     si.fMask = SIF_RANGE;
3554     si.nMin = 0xdeadbeef;
3555     si.nMax = 0xdeadbeef;
3556     ret = GetScrollInfo(hwnd, SB_CTL, &si);
3557     ok( ret, "GetScrollInfo error %d\n", GetLastError());
3558     if (sequence->message != WmGetScrollInfoSeq[0].message)
3559         trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3560     /* values of min and max are undefined */
3561     flush_sequence();
3562
3563     /* set WS_HSCROLL */
3564     test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
3565     /* clear WS_HSCROLL */
3566     test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
3567
3568     /* set WS_HSCROLL */
3569     test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
3570     /* clear WS_HSCROLL */
3571     test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
3572
3573     /* set WS_VSCROLL */
3574     test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
3575     /* clear WS_VSCROLL */
3576     test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
3577
3578     /* set WS_VSCROLL */
3579     test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
3580     /* clear WS_VSCROLL */
3581     test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
3582 }
3583
3584 static void test_showwindow(void)
3585 {
3586     HWND hwnd, hchild;
3587     RECT rc;
3588
3589     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3590                            100, 100, 200, 200, 0, 0, 0, NULL);
3591     ok (hwnd != 0, "Failed to create overlapped window\n");
3592     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
3593                              0, 0, 10, 10, hwnd, 0, 0, NULL);
3594     ok (hchild != 0, "Failed to create child\n");
3595     flush_sequence();
3596
3597     /* ShowWindow( SW_SHOWNA) for invisible top level window */
3598     trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
3599     ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3600     ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", TRUE);
3601     trace("done\n");
3602
3603     /* ShowWindow( SW_SHOWNA) for now visible top level window */
3604     trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
3605     ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3606     ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
3607     trace("done\n");
3608     /* back to invisible */
3609     ShowWindow(hchild, SW_HIDE);
3610     ShowWindow(hwnd, SW_HIDE);
3611     flush_sequence();
3612     /* ShowWindow(SW_SHOWNA) with child and parent invisible */ 
3613     trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
3614     ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3615     ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
3616     trace("done\n");
3617     /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */ 
3618     ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
3619     flush_sequence();
3620     trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
3621     ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3622     ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
3623     trace("done\n");
3624     /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
3625     ShowWindow( hwnd, SW_SHOW);
3626     flush_sequence();
3627     trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
3628     ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3629     ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
3630     trace("done\n");
3631
3632     /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
3633     ShowWindow( hchild, SW_HIDE);
3634     flush_sequence();
3635     trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
3636     ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3637     ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
3638     trace("done\n");
3639
3640     SetCapture(hchild);
3641     ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
3642     DestroyWindow(hchild);
3643     ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
3644
3645     DestroyWindow(hwnd);
3646     flush_sequence();
3647
3648     /* Popup windows */
3649     /* Test 1:
3650      * 1. Create invisible maximized popup window.
3651      * 2. Move and resize it.
3652      * 3. Show it maximized.
3653      */
3654     trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3655     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
3656                            100, 100, 200, 200, 0, 0, 0, NULL);
3657     ok (hwnd != 0, "Failed to create popup window\n");
3658     ok(IsZoomed(hwnd), "window should be maximized\n");
3659     ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3660     trace("done\n");
3661
3662     GetWindowRect(hwnd, &rc);
3663     ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
3664         rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
3665         "Invalid maximized size before ShowWindow (%d,%d)-(%d,%d)\n",
3666         rc.left, rc.top, rc.right, rc.bottom);
3667     /* Reset window's size & position */
3668     SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
3669     ok(IsZoomed(hwnd), "window should be maximized\n");
3670     flush_sequence();
3671
3672     trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
3673     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3674     ok(IsZoomed(hwnd), "window should be maximized\n");
3675     ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE);
3676     trace("done\n");
3677
3678     GetWindowRect(hwnd, &rc);
3679     ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
3680         rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
3681         "Invalid maximized size after ShowWindow (%d,%d)-(%d,%d)\n",
3682         rc.left, rc.top, rc.right, rc.bottom);
3683     DestroyWindow(hwnd);
3684     flush_sequence();
3685
3686     /* Test 2:
3687      * 1. Create invisible maximized popup window.
3688      * 2. Show it maximized.
3689      */
3690     trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3691     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
3692                            100, 100, 200, 200, 0, 0, 0, NULL);
3693     ok (hwnd != 0, "Failed to create popup window\n");
3694     ok(IsZoomed(hwnd), "window should be maximized\n");
3695     ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3696     trace("done\n");
3697
3698     trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
3699     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3700     ok(IsZoomed(hwnd), "window should be maximized\n");
3701     ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE);
3702     trace("done\n");
3703     DestroyWindow(hwnd);
3704     flush_sequence();
3705
3706     /* Test 3:
3707      * 1. Create visible maximized popup window.
3708      */
3709     trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
3710     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
3711                            100, 100, 200, 200, 0, 0, 0, NULL);
3712     ok (hwnd != 0, "Failed to create popup window\n");
3713     ok(IsZoomed(hwnd), "window should be maximized\n");
3714     ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3715     trace("done\n");
3716     DestroyWindow(hwnd);
3717     flush_sequence();
3718
3719     /* Test 4:
3720      * 1. Create visible popup window.
3721      * 2. Maximize it.
3722      */
3723     trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
3724     hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
3725                            100, 100, 200, 200, 0, 0, 0, NULL);
3726     ok (hwnd != 0, "Failed to create popup window\n");
3727     ok(!IsZoomed(hwnd), "window should NOT be maximized\n");
3728     ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", FALSE);
3729     trace("done\n");
3730
3731     trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
3732     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3733     ok(IsZoomed(hwnd), "window should be maximized\n");
3734     ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
3735     trace("done\n");
3736     DestroyWindow(hwnd);
3737     flush_sequence();
3738 }
3739
3740 static void test_sys_menu(void)
3741 {
3742     HWND hwnd;
3743     HMENU hmenu;
3744     UINT state;
3745
3746     hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
3747                            100, 100, 200, 200, 0, 0, 0, NULL);
3748     ok (hwnd != 0, "Failed to create overlapped window\n");
3749
3750     flush_sequence();
3751
3752     /* test existing window without CS_NOCLOSE style */
3753     hmenu = GetSystemMenu(hwnd, FALSE);
3754     ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
3755
3756     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3757     ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3758     ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
3759
3760     EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
3761     ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
3762
3763     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3764     ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3765     ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
3766
3767     EnableMenuItem(hmenu, SC_CLOSE, 0);
3768     ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
3769
3770     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3771     ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3772     ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
3773
3774     /* test whether removing WS_SYSMENU destroys a system menu */
3775     SetWindowLongW(hwnd, GWL_STYLE, WS_POPUP);
3776     SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
3777     flush_sequence();
3778     hmenu = GetSystemMenu(hwnd, FALSE);
3779     ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
3780
3781     DestroyWindow(hwnd);
3782
3783     /* test new window with CS_NOCLOSE style */
3784     hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
3785                            100, 100, 200, 200, 0, 0, 0, NULL);
3786     ok (hwnd != 0, "Failed to create overlapped window\n");
3787
3788     hmenu = GetSystemMenu(hwnd, FALSE);
3789     ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
3790
3791     state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
3792     ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
3793
3794     DestroyWindow(hwnd);
3795
3796     /* test new window without WS_SYSMENU style */
3797     hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU,
3798                            100, 100, 200, 200, 0, 0, 0, NULL);
3799     ok(hwnd != 0, "Failed to create overlapped window\n");
3800
3801     hmenu = GetSystemMenu(hwnd, FALSE);
3802     ok(!hmenu, "GetSystemMenu error %d\n", GetLastError());
3803
3804     DestroyWindow(hwnd);
3805 }
3806
3807 /* For shown WS_OVERLAPPEDWINDOW */
3808 static const struct message WmSetIcon_1[] = {
3809     { WM_SETICON, sent },
3810     { 0x00AE, sent|defwinproc|optional }, /* XP */
3811     { WM_GETTEXT, sent|defwinproc|optional },
3812     { WM_GETTEXT, sent|defwinproc|optional }, /* XP sends a duplicate */
3813     { 0 }
3814 };
3815
3816 /* For WS_POPUP and hidden WS_OVERLAPPEDWINDOW */
3817 static const struct message WmSetIcon_2[] = {
3818     { WM_SETICON, sent },
3819     { 0 }
3820 };
3821
3822 static void test_MsgWaitForMultipleObjects(HWND hwnd)
3823 {
3824     DWORD ret;
3825     MSG msg;
3826
3827     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3828     ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
3829
3830     PostMessageA(hwnd, WM_USER, 0, 0);
3831
3832     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3833     ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
3834
3835     ok(PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
3836     ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
3837
3838     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3839     ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
3840
3841     PostMessageA(hwnd, WM_USER, 0, 0);
3842
3843     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3844     ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
3845
3846     ok(PeekMessageW( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
3847     ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
3848
3849     /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
3850     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3851     ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
3852
3853     PostMessageA(hwnd, WM_USER, 0, 0);
3854
3855     /* new incoming message causes it to become signaled again */
3856     ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
3857     ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
3858
3859     ok(PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
3860     ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
3861     ok(PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
3862     ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
3863 }
3864
3865 /* test if we receive the right sequence of messages */
3866 static void test_messages(void)
3867 {
3868     HWND hwnd, hparent, hchild;
3869     HWND hchild2, hbutton;
3870     HMENU hmenu;
3871     MSG msg;
3872
3873     flush_sequence();
3874
3875     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3876                            100, 100, 200, 200, 0, 0, 0, NULL);
3877     ok (hwnd != 0, "Failed to create overlapped window\n");
3878     ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
3879
3880     /* test ShowWindow(SW_HIDE) on a newly created invisible window */
3881     ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
3882     ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
3883
3884     /* test WM_SETREDRAW on a not visible top level window */
3885     test_WM_SETREDRAW(hwnd);
3886
3887     SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3888     ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
3889     ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
3890
3891     ok(GetActiveWindow() == hwnd, "window should be active\n");
3892     ok(GetFocus() == hwnd, "window should have input focus\n");
3893     ShowWindow(hwnd, SW_HIDE);
3894     ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", TRUE);
3895
3896     ShowWindow(hwnd, SW_SHOW);
3897     ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
3898
3899     ShowWindow(hwnd, SW_HIDE);
3900     ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
3901
3902     ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3903     ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
3904
3905     ShowWindow(hwnd, SW_RESTORE);
3906     /* FIXME: add ok_sequence() here */
3907     flush_sequence();
3908
3909     ShowWindow(hwnd, SW_MINIMIZE);
3910     ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", TRUE);
3911     flush_sequence();
3912
3913     ShowWindow(hwnd, SW_RESTORE);
3914     /* FIXME: add ok_sequence() here */
3915     flush_sequence();
3916
3917     ShowWindow(hwnd, SW_SHOW);
3918     ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
3919
3920     ok(GetActiveWindow() == hwnd, "window should be active\n");
3921     ok(GetFocus() == hwnd, "window should have input focus\n");
3922     SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3923     ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
3924     ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
3925     ok(GetActiveWindow() == hwnd, "window should still be active\n");
3926
3927     /* test WM_SETREDRAW on a visible top level window */
3928     ShowWindow(hwnd, SW_SHOW);
3929     test_WM_SETREDRAW(hwnd);
3930
3931     trace("testing scroll APIs on a visible top level window %p\n", hwnd);
3932     test_scroll_messages(hwnd);
3933
3934     /* test resizing and moving */
3935     SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
3936     ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
3937     flush_events();
3938     flush_sequence();
3939     SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
3940     ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
3941     flush_events();
3942     flush_sequence();
3943     SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER );
3944     ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
3945     flush_events();
3946     flush_sequence();
3947
3948     /* popups don't get WM_GETMINMAXINFO */
3949     SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
3950     SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
3951     flush_sequence();
3952     SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
3953     ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
3954
3955     DestroyWindow(hwnd);
3956     ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
3957
3958     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
3959                               100, 100, 200, 200, 0, 0, 0, NULL);
3960     ok (hparent != 0, "Failed to create parent window\n");
3961     flush_sequence();
3962
3963     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
3964                              0, 0, 10, 10, hparent, 0, 0, NULL);
3965     ok (hchild != 0, "Failed to create child window\n");
3966     ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
3967     DestroyWindow(hchild);
3968     flush_sequence();
3969
3970     /* visible child window with a caption */
3971     hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
3972                              WS_CHILD | WS_VISIBLE | WS_CAPTION,
3973                              0, 0, 10, 10, hparent, 0, 0, NULL);
3974     ok (hchild != 0, "Failed to create child window\n");
3975     ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
3976
3977     trace("testing scroll APIs on a visible child window %p\n", hchild);
3978     test_scroll_messages(hchild);
3979
3980     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
3981     ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
3982
3983     DestroyWindow(hchild);
3984     flush_sequence();
3985
3986     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
3987                              0, 0, 10, 10, hparent, 0, 0, NULL);
3988     ok (hchild != 0, "Failed to create child window\n");
3989     ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
3990     
3991     hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
3992                                100, 100, 50, 50, hparent, 0, 0, NULL);
3993     ok (hchild2 != 0, "Failed to create child2 window\n");
3994     flush_sequence();
3995
3996     hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
3997                               0, 100, 50, 50, hchild, 0, 0, NULL);
3998     ok (hbutton != 0, "Failed to create button window\n");
3999
4000     /* test WM_SETREDRAW on a not visible child window */
4001     test_WM_SETREDRAW(hchild);
4002
4003     ShowWindow(hchild, SW_SHOW);
4004     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4005
4006     /* check parent messages too */
4007     log_all_parent_messages++;
4008     ShowWindow(hchild, SW_HIDE);
4009     ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
4010     log_all_parent_messages--;
4011
4012     ShowWindow(hchild, SW_SHOW);
4013     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4014
4015     ShowWindow(hchild, SW_HIDE);
4016     ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
4017
4018     ShowWindow(hchild, SW_SHOW);
4019     ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4020
4021     /* test WM_SETREDRAW on a visible child window */
4022     test_WM_SETREDRAW(hchild);
4023
4024     log_all_parent_messages++;
4025     MoveWindow(hchild, 10, 10, 20, 20, TRUE);
4026     ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
4027     log_all_parent_messages--;
4028
4029     ShowWindow(hchild, SW_HIDE);
4030     flush_sequence();
4031     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4032     ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
4033
4034     ShowWindow(hchild, SW_HIDE);
4035     flush_sequence();
4036     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
4037     ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
4038
4039     /* DestroyWindow sequence below expects that a child has focus */
4040     SetFocus(hchild);
4041     flush_sequence();
4042
4043     DestroyWindow(hchild);
4044     ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
4045     DestroyWindow(hchild2);
4046     DestroyWindow(hbutton);
4047
4048     flush_sequence();
4049     hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
4050                              0, 0, 100, 100, hparent, 0, 0, NULL);
4051     ok (hchild != 0, "Failed to create child popup window\n");
4052     ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
4053     DestroyWindow(hchild);
4054
4055     /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
4056     flush_sequence();
4057     hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
4058                              0, 0, 100, 100, hparent, 0, 0, NULL);
4059     ok (hchild != 0, "Failed to create popup window\n");
4060     ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4061     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4062     ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4063     flush_sequence();
4064     ShowWindow(hchild, SW_SHOW);
4065     ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4066     flush_sequence();
4067     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4068     ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4069     flush_sequence();
4070     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4071     ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", TRUE);
4072     DestroyWindow(hchild);
4073
4074     /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
4075      * changes nothing in message sequences.
4076      */
4077     flush_sequence();
4078     hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
4079                              0, 0, 100, 100, hparent, 0, 0, NULL);
4080     ok (hchild != 0, "Failed to create popup window\n");
4081     ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4082     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4083     ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4084     flush_sequence();
4085     ShowWindow(hchild, SW_SHOW);
4086     ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4087     flush_sequence();
4088     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4089     ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4090     DestroyWindow(hchild);
4091
4092     flush_sequence();
4093     hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
4094                            0, 0, 100, 100, hparent, 0, 0, NULL);
4095     ok(hwnd != 0, "Failed to create custom dialog window\n");
4096     ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
4097
4098     /*
4099     trace("testing scroll APIs on a visible dialog %p\n", hwnd);
4100     test_scroll_messages(hwnd);
4101     */
4102
4103     flush_sequence();
4104
4105     test_def_id = 1;
4106     SendMessage(hwnd, WM_NULL, 0, 0);
4107
4108     flush_sequence();
4109     after_end_dialog = 1;
4110     EndDialog( hwnd, 0 );
4111     ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
4112
4113     DestroyWindow(hwnd);
4114     after_end_dialog = 0;
4115     test_def_id = 0;
4116
4117     hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP,
4118                            0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
4119     ok(hwnd != 0, "Failed to create custom dialog window\n");
4120     flush_sequence();
4121     trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
4122     ShowWindow(hwnd, SW_SHOW);
4123     ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
4124     DestroyWindow(hwnd);
4125
4126     flush_sequence();
4127     DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
4128     ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
4129
4130     DestroyWindow(hparent);
4131     flush_sequence();
4132
4133     /* Message sequence for SetMenu */
4134     ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
4135     ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
4136
4137     hmenu = CreateMenu();
4138     ok (hmenu != 0, "Failed to create menu\n");
4139     ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
4140     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4141                            100, 100, 200, 200, 0, hmenu, 0, NULL);
4142     ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4143     ok (SetMenu(hwnd, 0), "SetMenu\n");
4144     ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
4145     ok (SetMenu(hwnd, 0), "SetMenu\n");
4146     ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
4147     ShowWindow(hwnd, SW_SHOW);
4148     UpdateWindow( hwnd );
4149     flush_events();
4150     flush_sequence();
4151     ok (SetMenu(hwnd, 0), "SetMenu\n");
4152     ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
4153     ok (SetMenu(hwnd, hmenu), "SetMenu\n");
4154     ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
4155
4156     UpdateWindow( hwnd );
4157     flush_events();
4158     flush_sequence();
4159     ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
4160     flush_events();
4161     ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
4162
4163     DestroyWindow(hwnd);
4164     flush_sequence();
4165
4166     /* Message sequence for EnableWindow */
4167     hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4168                               100, 100, 200, 200, 0, 0, 0, NULL);
4169     ok (hparent != 0, "Failed to create parent window\n");
4170     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
4171                              0, 0, 10, 10, hparent, 0, 0, NULL);
4172     ok (hchild != 0, "Failed to create child window\n");
4173
4174     SetFocus(hchild);
4175     flush_events();
4176     flush_sequence();
4177
4178     EnableWindow(hparent, FALSE);
4179     ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
4180
4181     EnableWindow(hparent, TRUE);
4182     ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
4183
4184     flush_events();
4185     flush_sequence();
4186
4187     test_MsgWaitForMultipleObjects(hparent);
4188
4189     /* the following test causes an exception in user.exe under win9x */
4190     if (!PostMessageW( hparent, WM_USER, 0, 0 ))
4191     {
4192         DestroyWindow(hparent);
4193         flush_sequence();
4194         return;
4195     }
4196     PostMessageW( hparent, WM_USER+1, 0, 0 );
4197     /* PeekMessage(NULL) fails, but still removes the message */
4198     SetLastError(0xdeadbeef);
4199     ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
4200     ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
4201         GetLastError() == 0xdeadbeef, /* NT4 */
4202         "last error is %d\n", GetLastError() );
4203     ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
4204     ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
4205
4206     DestroyWindow(hchild);
4207     DestroyWindow(hparent);
4208     flush_sequence();
4209
4210     /* Message sequences for WM_SETICON */
4211     trace("testing WM_SETICON\n");
4212     hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4213                            CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4214                            NULL, NULL, 0);
4215     ShowWindow(hwnd, SW_SHOW);
4216     UpdateWindow(hwnd);
4217     flush_events();
4218     flush_sequence();
4219     SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4220     ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
4221
4222     ShowWindow(hwnd, SW_HIDE);
4223     flush_events();
4224     flush_sequence();
4225     SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4226     ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
4227     DestroyWindow(hwnd);
4228     flush_sequence();
4229
4230     hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
4231                            CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4232                            NULL, NULL, 0);
4233     ShowWindow(hwnd, SW_SHOW);
4234     UpdateWindow(hwnd);
4235     flush_events();
4236     flush_sequence();
4237     SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4238     ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
4239
4240     ShowWindow(hwnd, SW_HIDE);
4241     flush_events();
4242     flush_sequence();
4243     SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4244     ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
4245     DestroyWindow(hwnd);
4246     flush_sequence();
4247 }
4248
4249 static void invisible_parent_tests(void)
4250 {
4251     HWND hparent, hchild;
4252
4253     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
4254                               100, 100, 200, 200, 0, 0, 0, NULL);
4255     ok (hparent != 0, "Failed to create parent window\n");
4256     flush_sequence();
4257
4258     /* test showing child with hidden parent */
4259
4260     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4261                              0, 0, 10, 10, hparent, 0, 0, NULL);
4262     ok (hchild != 0, "Failed to create child window\n");
4263     ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4264
4265     ShowWindow( hchild, SW_MINIMIZE );
4266     ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
4267     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4268     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4269
4270     /* repeat */
4271     flush_events();
4272     flush_sequence();
4273     ShowWindow( hchild, SW_MINIMIZE );
4274     ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
4275
4276     DestroyWindow(hchild);
4277     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4278                              0, 0, 10, 10, hparent, 0, 0, NULL);
4279     flush_sequence();
4280
4281     ShowWindow( hchild, SW_MAXIMIZE );
4282     ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
4283     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4284     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4285
4286     /* repeat */
4287     flush_events();
4288     flush_sequence();
4289     ShowWindow( hchild, SW_MAXIMIZE );
4290     ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
4291
4292     DestroyWindow(hchild);
4293     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4294                              0, 0, 10, 10, hparent, 0, 0, NULL);
4295     flush_sequence();
4296
4297     ShowWindow( hchild, SW_RESTORE );
4298     ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
4299     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4300     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4301
4302     DestroyWindow(hchild);
4303     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4304                              0, 0, 10, 10, hparent, 0, 0, NULL);
4305     flush_sequence();
4306
4307     ShowWindow( hchild, SW_SHOWMINIMIZED );
4308     ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
4309     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4310     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4311
4312     /* repeat */
4313     flush_events();
4314     flush_sequence();
4315     ShowWindow( hchild, SW_SHOWMINIMIZED );
4316     ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
4317
4318     DestroyWindow(hchild);
4319     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4320                              0, 0, 10, 10, hparent, 0, 0, NULL);
4321     flush_sequence();
4322
4323     /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
4324     ShowWindow( hchild, SW_SHOWMAXIMIZED );
4325     ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
4326     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4327     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4328
4329     DestroyWindow(hchild);
4330     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4331                              0, 0, 10, 10, hparent, 0, 0, NULL);
4332     flush_sequence();
4333
4334     ShowWindow( hchild, SW_SHOWMINNOACTIVE );
4335     ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
4336     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4337     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4338
4339     /* repeat */
4340     flush_events();
4341     flush_sequence();
4342     ShowWindow( hchild, SW_SHOWMINNOACTIVE );
4343     ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
4344
4345     DestroyWindow(hchild);
4346     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4347                              0, 0, 10, 10, hparent, 0, 0, NULL);
4348     flush_sequence();
4349
4350     /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
4351     ShowWindow( hchild, SW_FORCEMINIMIZE );
4352     ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
4353 todo_wine {
4354     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
4355 }
4356     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4357
4358     DestroyWindow(hchild);
4359     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4360                              0, 0, 10, 10, hparent, 0, 0, NULL);
4361     flush_sequence();
4362
4363     ShowWindow( hchild, SW_SHOWNA );
4364     ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
4365     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4366     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4367
4368     /* repeat */
4369     flush_events();
4370     flush_sequence();
4371     ShowWindow( hchild, SW_SHOWNA );
4372     ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
4373
4374     DestroyWindow(hchild);
4375     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4376                              0, 0, 10, 10, hparent, 0, 0, NULL);
4377     flush_sequence();
4378
4379     ShowWindow( hchild, SW_SHOW );
4380     ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
4381     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4382     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4383
4384     /* repeat */
4385     flush_events();
4386     flush_sequence();
4387     ShowWindow( hchild, SW_SHOW );
4388     ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
4389
4390     ShowWindow( hchild, SW_HIDE );
4391     ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
4392     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
4393     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4394
4395     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4396     ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
4397     ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4398     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4399
4400     SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4401     ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
4402     ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
4403     ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4404
4405     SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4406     flush_sequence();
4407     DestroyWindow(hchild);
4408     ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
4409
4410     DestroyWindow(hparent);
4411     flush_sequence();
4412 }
4413
4414 /****************** button message test *************************/
4415 static const struct message WmSetFocusButtonSeq[] =
4416 {
4417     { HCBT_SETFOCUS, hook },
4418     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
4419     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4420     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4421     { WM_SETFOCUS, sent|wparam, 0 },
4422     { WM_CTLCOLORBTN, sent|defwinproc },
4423     { 0 }
4424 };
4425 static const struct message WmKillFocusButtonSeq[] =
4426 {
4427     { HCBT_SETFOCUS, hook },
4428     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4429     { WM_KILLFOCUS, sent|wparam, 0 },
4430     { WM_CTLCOLORBTN, sent|defwinproc },
4431     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
4432     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
4433     { 0 }
4434 };
4435 static const struct message WmSetFocusStaticSeq[] =
4436 {
4437     { HCBT_SETFOCUS, hook },
4438     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
4439     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4440     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4441     { WM_SETFOCUS, sent|wparam, 0 },
4442     { WM_CTLCOLORSTATIC, sent|defwinproc },
4443     { 0 }
4444 };
4445 static const struct message WmKillFocusStaticSeq[] =
4446 {
4447     { HCBT_SETFOCUS, hook },
4448     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4449     { WM_KILLFOCUS, sent|wparam, 0 },
4450     { WM_CTLCOLORSTATIC, sent|defwinproc },
4451     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
4452     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
4453     { 0 }
4454 };
4455 static const struct message WmLButtonDownSeq[] =
4456 {
4457     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
4458     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
4459     { HCBT_SETFOCUS, hook },
4460     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
4461     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4462     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4463     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
4464     { WM_CTLCOLORBTN, sent|defwinproc },
4465     { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
4466     { WM_CTLCOLORBTN, sent|defwinproc },
4467     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4468     { 0 }
4469 };
4470 static const struct message WmLButtonUpSeq[] =
4471 {
4472     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
4473     { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
4474     { WM_CTLCOLORBTN, sent|defwinproc },
4475     { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4476     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
4477     { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
4478     { 0 }
4479 };
4480 static const struct message WmSetFontButtonSeq[] =
4481 {
4482     { WM_SETFONT, sent },
4483     { WM_PAINT, sent },
4484     { WM_ERASEBKGND, sent|defwinproc|optional },
4485     { WM_CTLCOLORBTN, sent|defwinproc },
4486     { 0 }
4487 };
4488
4489 static WNDPROC old_button_proc;
4490
4491 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4492 {
4493     static long defwndproc_counter = 0;
4494     LRESULT ret;
4495     struct message msg;
4496
4497     trace("button: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
4498
4499     /* explicitly ignore WM_GETICON message */
4500     if (message == WM_GETICON) return 0;
4501
4502     msg.message = message;
4503     msg.flags = sent|wparam|lparam;
4504     if (defwndproc_counter) msg.flags |= defwinproc;
4505     msg.wParam = wParam;
4506     msg.lParam = lParam;
4507     add_message(&msg);
4508
4509     if (message == BM_SETSTATE)
4510         ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
4511
4512     defwndproc_counter++;
4513     ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
4514     defwndproc_counter--;
4515
4516     return ret;
4517 }
4518
4519 static void subclass_button(void)
4520 {
4521     WNDCLASSA cls;
4522
4523     if (!GetClassInfoA(0, "button", &cls)) assert(0);
4524
4525     old_button_proc = cls.lpfnWndProc;
4526
4527     cls.hInstance = GetModuleHandle(0);
4528     cls.lpfnWndProc = button_hook_proc;
4529     cls.lpszClassName = "my_button_class";
4530     UnregisterClass(cls.lpszClassName, cls.hInstance);
4531     if (!RegisterClassA(&cls)) assert(0);
4532 }
4533
4534 static void test_button_messages(void)
4535 {
4536     static const struct
4537     {
4538         DWORD style;
4539         DWORD dlg_code;
4540         const struct message *setfocus;
4541         const struct message *killfocus;
4542     } button[] = {
4543         { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
4544           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
4545         { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
4546           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
4547         { BS_CHECKBOX, DLGC_BUTTON,
4548           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4549         { BS_AUTOCHECKBOX, DLGC_BUTTON,
4550           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4551         { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
4552           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4553         { BS_3STATE, DLGC_BUTTON,
4554           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4555         { BS_AUTO3STATE, DLGC_BUTTON,
4556           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4557         { BS_GROUPBOX, DLGC_STATIC,
4558           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4559         { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
4560           WmSetFocusButtonSeq, WmKillFocusButtonSeq },
4561         { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
4562           WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4563         { BS_OWNERDRAW, DLGC_BUTTON,
4564           WmSetFocusButtonSeq, WmKillFocusButtonSeq }
4565     };
4566     unsigned int i;
4567     HWND hwnd;
4568     DWORD dlg_code;
4569     HFONT zfont;
4570
4571     subclass_button();
4572
4573     for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
4574     {
4575         hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
4576                                0, 0, 50, 14, 0, 0, 0, NULL);
4577         ok(hwnd != 0, "Failed to create button window\n");
4578
4579         dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
4580         ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
4581
4582         ShowWindow(hwnd, SW_SHOW);
4583         UpdateWindow(hwnd);
4584         SetFocus(0);
4585         flush_sequence();
4586
4587         trace("button style %08x\n", button[i].style);
4588         SetFocus(hwnd);
4589         ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
4590
4591         SetFocus(0);
4592         ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
4593
4594         DestroyWindow(hwnd);
4595     }
4596
4597     hwnd = CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON | WS_POPUP | WS_VISIBLE,
4598                            0, 0, 50, 14, 0, 0, 0, NULL);
4599     ok(hwnd != 0, "Failed to create button window\n");
4600
4601     SetFocus(0);
4602     flush_events();
4603     flush_sequence();
4604
4605     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
4606     ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
4607
4608     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
4609     ok_sequence(WmLButtonUpSeq, "WM_LBUTTONUP on a button", FALSE);
4610
4611     flush_sequence();
4612     zfont = (HFONT)GetStockObject(SYSTEM_FONT);
4613     SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
4614     UpdateWindow(hwnd);
4615     ok_sequence(WmSetFontButtonSeq, "WM_SETFONT on a button", FALSE);
4616
4617     DestroyWindow(hwnd);
4618 }
4619
4620 /****************** static message test *************************/
4621 static const struct message WmSetFontStaticSeq[] =
4622 {
4623     { WM_SETFONT, sent },
4624     { WM_PAINT, sent|defwinproc },
4625     { WM_ERASEBKGND, sent|defwinproc|optional },
4626     { WM_CTLCOLORSTATIC, sent|defwinproc },
4627     { 0 }
4628 };
4629
4630 static WNDPROC old_static_proc;
4631
4632 static LRESULT CALLBACK static_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4633 {
4634     static long defwndproc_counter = 0;
4635     LRESULT ret;
4636     struct message msg;
4637
4638     trace("static: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
4639
4640     /* explicitly ignore WM_GETICON message */
4641     if (message == WM_GETICON) return 0;
4642
4643     msg.message = message;
4644     msg.flags = sent|wparam|lparam;
4645     if (defwndproc_counter) msg.flags |= defwinproc;
4646     msg.wParam = wParam;
4647     msg.lParam = lParam;
4648     add_message(&msg);
4649
4650
4651     defwndproc_counter++;
4652     ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
4653     defwndproc_counter--;
4654
4655     return ret;
4656 }
4657
4658 static void subclass_static(void)
4659 {
4660     WNDCLASSA cls;
4661
4662     if (!GetClassInfoA(0, "static", &cls)) assert(0);
4663
4664     old_static_proc = cls.lpfnWndProc;
4665
4666     cls.hInstance = GetModuleHandle(0);
4667     cls.lpfnWndProc = static_hook_proc;
4668     cls.lpszClassName = "my_static_class";
4669     UnregisterClass(cls.lpszClassName, cls.hInstance);
4670     if (!RegisterClassA(&cls)) assert(0);
4671 }
4672
4673 static void test_static_messages(void)
4674 {
4675     /* FIXME: make as comprehensive as the button message test */
4676     static const struct
4677     {
4678         DWORD style;
4679         DWORD dlg_code;
4680         const struct message *setfont;
4681     } static_ctrl[] = {
4682         { SS_LEFT, DLGC_STATIC,
4683           WmSetFontStaticSeq }
4684     };
4685     unsigned int i;
4686     HWND hwnd;
4687     DWORD dlg_code;
4688
4689     subclass_static();
4690
4691     for (i = 0; i < sizeof(static_ctrl)/sizeof(static_ctrl[0]); i++)
4692     {
4693         hwnd = CreateWindowExA(0, "my_static_class", "test", static_ctrl[i].style | WS_POPUP,
4694                                0, 0, 50, 14, 0, 0, 0, NULL);
4695         ok(hwnd != 0, "Failed to create static window\n");
4696
4697         dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
4698         ok(dlg_code == static_ctrl[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
4699
4700         ShowWindow(hwnd, SW_SHOW);
4701         UpdateWindow(hwnd);
4702         SetFocus(0);
4703         flush_sequence();
4704
4705         trace("static style %08x\n", static_ctrl[i].style);
4706         SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
4707         ok_sequence(static_ctrl[i].setfont, "WM_SETFONT on a static", FALSE);
4708
4709         DestroyWindow(hwnd);
4710     }
4711 }
4712
4713 /************* painting message test ********************/
4714
4715 void dump_region(HRGN hrgn)
4716 {
4717     DWORD i, size;
4718     RGNDATA *data = NULL;
4719     RECT *rect;
4720
4721     if (!hrgn)
4722     {
4723         printf( "null region\n" );
4724         return;
4725     }
4726     if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
4727     if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
4728     GetRegionData( hrgn, size, data );
4729     printf("%d rects:", data->rdh.nCount );
4730     for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
4731         printf( " (%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
4732     printf("\n");
4733     HeapFree( GetProcessHeap(), 0, data );
4734 }
4735
4736 static void check_update_rgn( HWND hwnd, HRGN hrgn )
4737 {
4738     INT ret;
4739     RECT r1, r2;
4740     HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
4741     HRGN update = CreateRectRgn( 0, 0, 0, 0 );
4742
4743     ret = GetUpdateRgn( hwnd, update, FALSE );
4744     ok( ret != ERROR, "GetUpdateRgn failed\n" );
4745     if (ret == NULLREGION)
4746     {
4747         ok( !hrgn, "Update region shouldn't be empty\n" );
4748     }
4749     else
4750     {
4751         if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
4752         {
4753             ok( 0, "Regions are different\n" );
4754             if (winetest_debug > 0)
4755             {
4756                 printf( "Update region: " );
4757                 dump_region( update );
4758                 printf( "Wanted region: " );
4759                 dump_region( hrgn );
4760             }
4761         }
4762     }
4763     GetRgnBox( update, &r1 );
4764     GetUpdateRect( hwnd, &r2, FALSE );
4765     ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
4766         "Rectangles are different: %d,%d-%d,%d / %d,%d-%d,%d\n",
4767         r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
4768
4769     DeleteObject( tmp );
4770     DeleteObject( update );
4771 }
4772
4773 static const struct message WmInvalidateRgn[] = {
4774     { WM_NCPAINT, sent },
4775     { WM_GETTEXT, sent|defwinproc|optional },
4776     { 0 }
4777 };
4778
4779 static const struct message WmGetUpdateRect[] = {
4780     { WM_NCPAINT, sent },
4781     { WM_GETTEXT, sent|defwinproc|optional },
4782     { WM_PAINT, sent },
4783     { 0 }
4784 };
4785
4786 static const struct message WmInvalidateFull[] = {
4787     { WM_NCPAINT, sent|wparam, 1 },
4788     { WM_GETTEXT, sent|defwinproc|optional },
4789     { 0 }
4790 };
4791
4792 static const struct message WmInvalidateErase[] = {
4793     { WM_NCPAINT, sent|wparam, 1 },
4794     { WM_GETTEXT, sent|defwinproc|optional },
4795     { WM_ERASEBKGND, sent },
4796     { 0 }
4797 };
4798
4799 static const struct message WmInvalidatePaint[] = {
4800     { WM_PAINT, sent },
4801     { WM_NCPAINT, sent|wparam|beginpaint, 1 },
4802     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4803     { 0 }
4804 };
4805
4806 static const struct message WmInvalidateErasePaint[] = {
4807     { WM_PAINT, sent },
4808     { WM_NCPAINT, sent|wparam|beginpaint, 1 },
4809     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4810     { WM_ERASEBKGND, sent|beginpaint },
4811     { 0 }
4812 };
4813
4814 static const struct message WmInvalidateErasePaint2[] = {
4815     { WM_PAINT, sent },
4816     { WM_NCPAINT, sent|beginpaint },
4817     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4818     { WM_ERASEBKGND, sent|beginpaint },
4819     { 0 }
4820 };
4821
4822 static const struct message WmErase[] = {
4823     { WM_ERASEBKGND, sent },
4824     { 0 }
4825 };
4826
4827 static const struct message WmPaint[] = {
4828     { WM_PAINT, sent },
4829     { 0 }
4830 };
4831
4832 static const struct message WmParentOnlyPaint[] = {
4833     { WM_PAINT, sent|parent },
4834     { 0 }
4835 };
4836
4837 static const struct message WmInvalidateParent[] = {
4838     { WM_NCPAINT, sent|parent },
4839     { WM_GETTEXT, sent|defwinproc|parent|optional },
4840     { WM_ERASEBKGND, sent|parent },
4841     { 0 }
4842 };
4843
4844 static const struct message WmInvalidateParentChild[] = {
4845     { WM_NCPAINT, sent|parent },
4846     { WM_GETTEXT, sent|defwinproc|parent|optional },
4847     { WM_ERASEBKGND, sent|parent },
4848     { WM_NCPAINT, sent },
4849     { WM_GETTEXT, sent|defwinproc|optional },
4850     { WM_ERASEBKGND, sent },
4851     { 0 }
4852 };
4853
4854 static const struct message WmInvalidateParentChild2[] = {
4855     { WM_ERASEBKGND, sent|parent },
4856     { WM_NCPAINT, sent },
4857     { WM_GETTEXT, sent|defwinproc|optional },
4858     { WM_ERASEBKGND, sent },
4859     { 0 }
4860 };
4861
4862 static const struct message WmParentPaint[] = {
4863     { WM_PAINT, sent|parent },
4864     { WM_PAINT, sent },
4865     { 0 }
4866 };
4867
4868 static const struct message WmParentPaintNc[] = {
4869     { WM_PAINT, sent|parent },
4870     { WM_PAINT, sent },
4871     { WM_NCPAINT, sent|beginpaint },
4872     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4873     { WM_ERASEBKGND, sent|beginpaint },
4874     { 0 }
4875 };
4876
4877 static const struct message WmChildPaintNc[] = {
4878     { WM_PAINT, sent },
4879     { WM_NCPAINT, sent|beginpaint },
4880     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4881     { WM_ERASEBKGND, sent|beginpaint },
4882     { 0 }
4883 };
4884
4885 static const struct message WmParentErasePaint[] = {
4886     { WM_PAINT, sent|parent },
4887     { WM_NCPAINT, sent|parent|beginpaint },
4888     { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
4889     { WM_ERASEBKGND, sent|parent|beginpaint },
4890     { WM_PAINT, sent },
4891     { WM_NCPAINT, sent|beginpaint },
4892     { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
4893     { WM_ERASEBKGND, sent|beginpaint },
4894     { 0 }
4895 };
4896
4897 static const struct message WmParentOnlyNcPaint[] = {
4898     { WM_PAINT, sent|parent },
4899     { WM_NCPAINT, sent|parent|beginpaint },
4900     { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
4901     { 0 }
4902 };
4903
4904 static const struct message WmSetParentStyle[] = {
4905     { WM_STYLECHANGING, sent|parent },
4906     { WM_STYLECHANGED, sent|parent },
4907     { 0 }
4908 };
4909
4910 static void test_paint_messages(void)
4911 {
4912     BOOL ret;
4913     RECT rect;
4914     POINT pt;
4915     MSG msg;
4916     HWND hparent, hchild;
4917     HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
4918     HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
4919     HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4920                                 100, 100, 200, 200, 0, 0, 0, NULL);
4921     ok (hwnd != 0, "Failed to create overlapped window\n");
4922
4923     ShowWindow( hwnd, SW_SHOW );
4924     UpdateWindow( hwnd );
4925     flush_events();
4926     flush_sequence();
4927
4928     check_update_rgn( hwnd, 0 );
4929     SetRectRgn( hrgn, 10, 10, 20, 20 );
4930     ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
4931     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
4932     check_update_rgn( hwnd, hrgn );
4933     SetRectRgn( hrgn2, 20, 20, 30, 30 );
4934     ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
4935     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
4936     CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
4937     check_update_rgn( hwnd, hrgn );
4938     /* validate everything */
4939     ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
4940     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
4941     check_update_rgn( hwnd, 0 );
4942
4943     /* test empty region */
4944     SetRectRgn( hrgn, 10, 10, 10, 15 );
4945     ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
4946     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
4947     check_update_rgn( hwnd, 0 );
4948     /* test empty rect */
4949     SetRect( &rect, 10, 10, 10, 15 );
4950     ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
4951     ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
4952     check_update_rgn( hwnd, 0 );
4953
4954     /* flush pending messages */
4955     flush_events();
4956     flush_sequence();
4957
4958     GetClientRect( hwnd, &rect );
4959     SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
4960     /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
4961      * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
4962      */
4963     trace("testing InvalidateRect(0, NULL, FALSE)\n");
4964     SetRectEmpty( &rect );
4965     ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
4966     check_update_rgn( hwnd, hrgn );
4967     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
4968     flush_events();
4969     ok_sequence( WmPaint, "Paint", FALSE );
4970     RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
4971     check_update_rgn( hwnd, 0 );
4972
4973     /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
4974      * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
4975      */
4976     trace("testing ValidateRect(0, NULL)\n");
4977     SetRectEmpty( &rect );
4978     ok(ValidateRect(0, &rect), "ValidateRect(0, &rc) should not fail\n");
4979     check_update_rgn( hwnd, hrgn );
4980     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
4981     flush_events();
4982     ok_sequence( WmPaint, "Paint", FALSE );
4983     RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
4984     check_update_rgn( hwnd, 0 );
4985
4986     trace("testing InvalidateRgn(0, NULL, FALSE)\n");
4987     SetLastError(0xdeadbeef);
4988     ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
4989     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %d\n", GetLastError());
4990     check_update_rgn( hwnd, 0 );
4991     flush_events();
4992     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
4993
4994     trace("testing ValidateRgn(0, NULL)\n");
4995     SetLastError(0xdeadbeef);
4996     ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
4997     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %d\n", GetLastError());
4998     check_update_rgn( hwnd, 0 );
4999     flush_events();
5000     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
5001
5002     /* now with frame */
5003     SetRectRgn( hrgn, -5, -5, 20, 20 );
5004
5005     /* flush pending messages */
5006     flush_events();
5007     flush_sequence();
5008     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5009     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
5010
5011     SetRectRgn( hrgn, 0, 0, 20, 20 );  /* GetUpdateRgn clips to client area */
5012     check_update_rgn( hwnd, hrgn );
5013
5014     flush_sequence();
5015     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
5016     ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
5017
5018     flush_sequence();
5019     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
5020     ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
5021
5022     GetClientRect( hwnd, &rect );
5023     SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
5024     check_update_rgn( hwnd, hrgn );
5025
5026     flush_sequence();
5027     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
5028     ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5029
5030     flush_sequence();
5031     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
5032     ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
5033     check_update_rgn( hwnd, 0 );
5034
5035     flush_sequence();
5036     RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
5037     ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
5038     check_update_rgn( hwnd, 0 );
5039
5040     flush_sequence();
5041     SetRectRgn( hrgn, 0, 0, 100, 100 );
5042     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5043     SetRectRgn( hrgn, 0, 0, 50, 100 );
5044     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
5045     SetRectRgn( hrgn, 50, 0, 100, 100 );
5046     check_update_rgn( hwnd, hrgn );
5047     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
5048     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );  /* must not generate messages, everything is valid */
5049     check_update_rgn( hwnd, 0 );
5050
5051     flush_sequence();
5052     SetRectRgn( hrgn, 0, 0, 100, 100 );
5053     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
5054     SetRectRgn( hrgn, 0, 0, 100, 50 );
5055     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
5056     ok_sequence( WmErase, "Erase", FALSE );
5057     SetRectRgn( hrgn, 0, 50, 100, 100 );
5058     check_update_rgn( hwnd, hrgn );
5059
5060     flush_sequence();
5061     SetRectRgn( hrgn, 0, 0, 100, 100 );
5062     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
5063     SetRectRgn( hrgn, 0, 0, 50, 50 );
5064     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
5065     ok_sequence( WmPaint, "Paint", FALSE );
5066
5067     flush_sequence();
5068     SetRectRgn( hrgn, -4, -4, -2, -2 );
5069     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5070     SetRectRgn( hrgn, -200, -200, -198, -198 );
5071     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
5072     ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
5073
5074     flush_sequence();
5075     SetRectRgn( hrgn, -4, -4, -2, -2 );
5076     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5077     SetRectRgn( hrgn, -4, -4, -3, -3 );
5078     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
5079     SetRectRgn( hrgn, 0, 0, 1, 1 );
5080     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
5081     ok_sequence( WmPaint, "Paint", FALSE );
5082
5083     flush_sequence();
5084     SetRectRgn( hrgn, -4, -4, -1, -1 );
5085     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5086     RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
5087     /* make sure no WM_PAINT was generated */
5088     flush_events();
5089     ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
5090
5091     flush_sequence();
5092     SetRectRgn( hrgn, -4, -4, -1, -1 );
5093     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5094     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
5095     {
5096         if (msg.hwnd == hwnd && msg.message == WM_PAINT)
5097         {
5098             /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
5099             INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
5100             ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
5101             ret = GetUpdateRect( hwnd, &rect, FALSE );
5102             ok( ret, "Invalid GetUpdateRect result %d\n", ret );
5103             /* this will send WM_NCPAINT and validate the non client area */
5104             ret = GetUpdateRect( hwnd, &rect, TRUE );
5105             ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
5106         }
5107         DispatchMessage( &msg );
5108     }
5109     ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
5110
5111     DestroyWindow( hwnd );
5112
5113     /* now test with a child window */
5114
5115     hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
5116                               100, 100, 200, 200, 0, 0, 0, NULL);
5117     ok (hparent != 0, "Failed to create parent window\n");
5118
5119     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
5120                            10, 10, 100, 100, hparent, 0, 0, NULL);
5121     ok (hchild != 0, "Failed to create child window\n");
5122
5123     ShowWindow( hparent, SW_SHOW );
5124     UpdateWindow( hparent );
5125     UpdateWindow( hchild );
5126     flush_events();
5127     flush_sequence();
5128     log_all_parent_messages++;
5129
5130     SetRect( &rect, 0, 0, 50, 50 );
5131     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5132     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
5133     ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
5134
5135     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5136     pt.x = pt.y = 0;
5137     MapWindowPoints( hchild, hparent, &pt, 1 );
5138     SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
5139     check_update_rgn( hchild, hrgn );
5140     SetRectRgn( hrgn, 0, 0, 50, 50 );
5141     check_update_rgn( hparent, hrgn );
5142     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5143     ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
5144     RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
5145     ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
5146
5147     flush_events();
5148     ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
5149
5150     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5151     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5152     ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
5153     RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
5154     ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
5155
5156     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
5157     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
5158     ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
5159
5160     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
5161     flush_sequence();
5162     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5163     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5164     ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
5165
5166     /* flush all paint messages */
5167     flush_events();
5168     flush_sequence();
5169
5170     /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
5171     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5172     SetRectRgn( hrgn, 0, 0, 50, 50 );
5173     check_update_rgn( hparent, hrgn );
5174     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5175     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5176     SetRectRgn( hrgn, 0, 0, 50, 50 );
5177     check_update_rgn( hparent, hrgn );
5178
5179     /* flush all paint messages */
5180     flush_events();
5181     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
5182     flush_sequence();
5183
5184     /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
5185     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5186     SetRectRgn( hrgn, 0, 0, 50, 50 );
5187     check_update_rgn( hparent, hrgn );
5188     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5189     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5190     SetRectRgn( hrgn2, 10, 10, 50, 50 );
5191     CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
5192     check_update_rgn( hparent, hrgn );
5193     /* flush all paint messages */
5194     flush_events();
5195     flush_sequence();
5196
5197     /* same as above but parent gets completely validated */
5198     SetRect( &rect, 20, 20, 30, 30 );
5199     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5200     SetRectRgn( hrgn, 20, 20, 30, 30 );
5201     check_update_rgn( hparent, hrgn );
5202     RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5203     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5204     check_update_rgn( hparent, 0 );  /* no update region */
5205     flush_events();
5206     ok_sequence( WmEmptySeq, "WmEmpty", FALSE );  /* and no paint messages */
5207
5208     /* make sure RDW_VALIDATE on child doesn't have the same effect */
5209     flush_sequence();
5210     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5211     SetRectRgn( hrgn, 20, 20, 30, 30 );
5212     check_update_rgn( hparent, hrgn );
5213     RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
5214     SetRectRgn( hrgn, 20, 20, 30, 30 );
5215     check_update_rgn( hparent, hrgn );
5216
5217     /* same as above but normal WM_PAINT doesn't validate parent */
5218     flush_sequence();
5219     SetRect( &rect, 20, 20, 30, 30 );
5220     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5221     SetRectRgn( hrgn, 20, 20, 30, 30 );
5222     check_update_rgn( hparent, hrgn );
5223     /* no WM_PAINT in child while parent still pending */
5224     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5225     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
5226     while (PeekMessage( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5227     ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
5228
5229     flush_sequence();
5230     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5231     /* no WM_PAINT in child while parent still pending */
5232     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5233     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
5234     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
5235     /* now that parent is valid child should get WM_PAINT */
5236     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5237     ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5238     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5239     ok_sequence( WmEmptySeq, "No other message", FALSE );
5240
5241     /* same thing with WS_CLIPCHILDREN in parent */
5242     flush_sequence();
5243     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
5244     ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
5245     /* changing style invalidates non client area, but we need to invalidate something else to see it */
5246     RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
5247     ok_sequence( WmEmptySeq, "No message", FALSE );
5248     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
5249     ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
5250
5251     flush_sequence();
5252     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
5253     SetRectRgn( hrgn, 20, 20, 30, 30 );
5254     check_update_rgn( hparent, hrgn );
5255     /* no WM_PAINT in child while parent still pending */
5256     while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5257     ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
5258     /* WM_PAINT in parent first */
5259     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5260     ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
5261
5262     /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
5263     flush_sequence();
5264     SetRect( &rect, 0, 0, 30, 30 );
5265     RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
5266     SetRectRgn( hrgn, 0, 0, 30, 30 );
5267     check_update_rgn( hparent, hrgn );
5268     flush_events();
5269     ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
5270
5271     /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
5272     flush_sequence();
5273     SetRect( &rect, -10, 0, 30, 30 );
5274     RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
5275     SetRect( &rect, 0, 0, 20, 20 );
5276     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
5277     RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
5278     ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
5279
5280     /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
5281     flush_sequence();
5282     SetRect( &rect, -10, 0, 30, 30 );
5283     RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
5284     SetRect( &rect, 0, 0, 100, 100 );
5285     RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
5286     RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
5287     ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
5288     RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5289     ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
5290
5291     /* test RDW_INTERNALPAINT behavior */
5292
5293     flush_sequence();
5294     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
5295     flush_events();
5296     ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
5297
5298     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
5299     flush_events();
5300     ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
5301
5302     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
5303     flush_events();
5304     ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
5305
5306     assert( GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
5307     UpdateWindow( hparent );
5308     flush_events();
5309     flush_sequence();
5310     trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
5311     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5312     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
5313                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5314     flush_events();
5315     ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
5316
5317     UpdateWindow( hparent );
5318     flush_events();
5319     flush_sequence();
5320     trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
5321     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5322     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
5323                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5324     flush_events();
5325     ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
5326
5327     SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
5328     ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
5329     RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
5330     flush_events();
5331     ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
5332
5333     assert( !(GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
5334     UpdateWindow( hparent );
5335     flush_events();
5336     flush_sequence();
5337     trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
5338     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5339     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
5340                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5341     flush_events();
5342     ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
5343
5344     UpdateWindow( hparent );
5345     flush_events();
5346     flush_sequence();
5347     trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
5348     RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5349     SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
5350                   SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5351     flush_events();
5352     ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
5353
5354     log_all_parent_messages--;
5355     DestroyWindow( hparent );
5356     ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
5357
5358     DeleteObject( hrgn );
5359     DeleteObject( hrgn2 );
5360 }
5361
5362 struct wnd_event
5363 {
5364     HWND hwnd;
5365     HANDLE event;
5366 };
5367
5368 static DWORD WINAPI thread_proc(void *param)
5369 {
5370     MSG msg;
5371     struct wnd_event *wnd_event = (struct wnd_event *)param;
5372
5373     wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
5374                                       100, 100, 200, 200, 0, 0, 0, NULL);
5375     ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
5376
5377     SetEvent(wnd_event->event);
5378
5379     while (GetMessage(&msg, 0, 0, 0))
5380     {
5381         TranslateMessage(&msg);
5382         DispatchMessage(&msg);
5383     }
5384
5385     ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
5386
5387     return 0;
5388 }
5389
5390 static void test_interthread_messages(void)
5391 {
5392     HANDLE hThread;
5393     DWORD tid;
5394     WNDPROC proc;
5395     MSG msg;
5396     char buf[256];
5397     int len, expected_len;
5398     struct wnd_event wnd_event;
5399     BOOL ret;
5400
5401     wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
5402     if (!wnd_event.event)
5403     {
5404         trace("skipping interthread message test under win9x\n");
5405         return;
5406     }
5407
5408     hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
5409     ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
5410
5411     ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5412
5413     CloseHandle(wnd_event.event);
5414
5415     SetLastError(0xdeadbeef);
5416     ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
5417     ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error code %d\n", GetLastError());
5418
5419     proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
5420     ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %d\n", GetLastError());
5421
5422     expected_len = lstrlenA("window caption text");
5423     memset(buf, 0, sizeof(buf));
5424     SetLastError(0xdeadbeef);
5425     len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
5426     ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %d, len %d, expected len %d\n", GetLastError(), len, expected_len);
5427     ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
5428
5429     msg.hwnd = wnd_event.hwnd;
5430     msg.message = WM_GETTEXT;
5431     msg.wParam = sizeof(buf);
5432     msg.lParam = (LPARAM)buf;
5433     memset(buf, 0, sizeof(buf));
5434     SetLastError(0xdeadbeef);
5435     len = DispatchMessageA(&msg);
5436     ok(!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY,
5437        "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %d\n", len, GetLastError());
5438
5439     /* the following test causes an exception in user.exe under win9x */
5440     msg.hwnd = wnd_event.hwnd;
5441     msg.message = WM_TIMER;
5442     msg.wParam = 0;
5443     msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
5444     SetLastError(0xdeadbeef);
5445     len = DispatchMessageA(&msg);
5446     ok(!len && GetLastError() == 0xdeadbeef,
5447        "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %d\n", len, GetLastError());
5448
5449     ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
5450     ok( ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
5451
5452     ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
5453     CloseHandle(hThread);
5454
5455     ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
5456 }
5457
5458
5459 static const struct message WmVkN[] = {
5460     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
5461     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
5462     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
5463     { WM_CHAR, wparam|lparam, 'n', 1 },
5464     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
5465     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
5466     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
5467     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
5468     { 0 }
5469 };
5470 static const struct message WmShiftVkN[] = {
5471     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
5472     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
5473     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
5474     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
5475     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
5476     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
5477     { WM_CHAR, wparam|lparam, 'N', 1 },
5478     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
5479     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
5480     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
5481     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
5482     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
5483     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
5484     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
5485     { 0 }
5486 };
5487 static const struct message WmCtrlVkN[] = {
5488     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
5489     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
5490     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
5491     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
5492     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
5493     { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
5494     { WM_CHAR, wparam|lparam, 0x000e, 1 },
5495     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
5496     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
5497     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
5498     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
5499     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
5500     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
5501     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
5502     { 0 }
5503 };
5504 static const struct message WmCtrlVkN_2[] = {
5505     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
5506     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
5507     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
5508     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
5509     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
5510     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
5511     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
5512     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
5513     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
5514     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
5515     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
5516     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
5517     { 0 }
5518 };
5519 static const struct message WmAltVkN[] = {
5520     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
5521     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
5522     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
5523     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
5524     { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
5525     { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
5526     { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
5527     { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
5528     { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
5529     { HCBT_SYSCOMMAND, hook },
5530     { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
5531     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5532     { 0x00AE, sent|defwinproc|optional }, /* XP */
5533     { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
5534     { WM_INITMENU, sent|defwinproc },
5535     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
5536     { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
5537     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
5538     { WM_CAPTURECHANGED, sent|defwinproc },
5539     { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
5540     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
5541     { WM_EXITMENULOOP, sent|defwinproc },
5542     { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
5543     { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
5544     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
5545     { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
5546     { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
5547     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5548     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5549     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5550     { 0 }
5551 };
5552 static const struct message WmAltVkN_2[] = {
5553     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
5554     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
5555     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
5556     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
5557     { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
5558     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
5559     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
5560     { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
5561     { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
5562     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5563     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5564     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5565     { 0 }
5566 };
5567 static const struct message WmCtrlAltVkN[] = {
5568     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
5569     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
5570     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
5571     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
5572     { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
5573     { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
5574     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
5575     { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
5576     { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
5577     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
5578     { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
5579     { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
5580     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5581     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5582     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5583     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
5584     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
5585     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
5586     { 0 }
5587 };
5588 static const struct message WmCtrlShiftVkN[] = {
5589     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
5590     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
5591     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
5592     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
5593     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
5594     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
5595     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
5596     { WM_KEYDOWN, wparam|lparam, 'N', 1 },
5597     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
5598     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
5599     { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
5600     { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
5601     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
5602     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
5603     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
5604     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
5605     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
5606     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
5607     { 0 }
5608 };
5609 static const struct message WmCtrlAltShiftVkN[] = {
5610     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
5611     { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
5612     { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
5613     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
5614     { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
5615     { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
5616     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0x20000001 }, /* XP */
5617     { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
5618     { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
5619     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
5620     { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
5621     { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
5622     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
5623     { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
5624     { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
5625     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xe0000001 }, /* XP */
5626     { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
5627     { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
5628     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5629     { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5630     { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5631     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
5632     { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
5633     { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
5634     { 0 }
5635 };
5636 static const struct message WmAltPressRelease[] = {
5637     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
5638     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
5639     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
5640     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5641     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5642     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5643     { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
5644     { HCBT_SYSCOMMAND, hook },
5645     { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
5646     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
5647     { WM_INITMENU, sent|defwinproc },
5648     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
5649     { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE) },
5650     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
5651
5652     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x30000001 }, /* XP */
5653
5654     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
5655     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
5656     { WM_CAPTURECHANGED, sent|defwinproc },
5657     { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
5658     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
5659     { WM_EXITMENULOOP, sent|defwinproc },
5660     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5661     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5662     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5663     { 0 }
5664 };
5665 static const struct message WmAltMouseButton[] = {
5666     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
5667     { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
5668     { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
5669     { WM_MOUSEMOVE, wparam|optional, 0, 0 },
5670     { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
5671     { WM_LBUTTONDOWN, wparam, MK_LBUTTON, 0 },
5672     { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON, 0 },
5673     { WM_LBUTTONUP, wparam, 0, 0 },
5674     { WM_LBUTTONUP, sent|wparam, 0, 0 },
5675     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
5676     { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
5677     { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
5678     { 0 }
5679 };
5680 static const struct message WmF1Seq[] = {
5681     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 1 }, /* XP */
5682     { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
5683     { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
5684     { 0x4d, wparam|lparam, 0, 0 },
5685     { 0x4d, sent|wparam|lparam, 0, 0 },
5686     { WM_HELP, sent|defwinproc },
5687     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 0xc0000001 }, /* XP */
5688     { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
5689     { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
5690     { 0 }
5691 };
5692 static const struct message WmVkAppsSeq[] = {
5693     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 1 }, /* XP */
5694     { WM_KEYDOWN, wparam|lparam, VK_APPS, 1 },
5695     { WM_KEYDOWN, sent|wparam|lparam, VK_APPS, 0x00000001 },
5696     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 0xc0000001 }, /* XP */
5697     { WM_KEYUP, wparam|lparam, VK_APPS, 0xc0000001 },
5698     { WM_KEYUP, sent|wparam|lparam, VK_APPS, 0xc0000001 },
5699     { WM_CONTEXTMENU, lparam, /*hwnd*/0, (LPARAM)-1 },
5700     { WM_CONTEXTMENU, sent|lparam, /*hwnd*/0, (LPARAM)-1 },
5701     { 0 }
5702 };
5703
5704 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
5705 {
5706     MSG msg;
5707
5708     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
5709     {
5710         struct message log_msg;
5711
5712         trace("accel: %p, %04x, %08lx, %08lx\n", msg.hwnd, msg.message, msg.wParam, msg.lParam);
5713
5714         /* ignore some unwanted messages */
5715         if (msg.message == WM_MOUSEMOVE ||
5716             msg.message == WM_GETICON ||
5717             msg.message == WM_DEVICECHANGE)
5718             continue;
5719
5720         log_msg.message = msg.message;
5721         log_msg.flags = wparam|lparam;
5722         log_msg.wParam = msg.wParam;
5723         log_msg.lParam = msg.lParam;
5724         add_message(&log_msg);
5725
5726         if (!hAccel || !TranslateAccelerator(hwnd, hAccel, &msg))
5727         {
5728             TranslateMessage(&msg);
5729             DispatchMessage(&msg);
5730         }
5731     }
5732 }
5733
5734 static void test_accelerators(void)
5735 {
5736     RECT rc;
5737     SHORT state;
5738     HACCEL hAccel;
5739     HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5740                                 100, 100, 200, 200, 0, 0, 0, NULL);
5741     BOOL ret;
5742
5743     assert(hwnd != 0);
5744     UpdateWindow(hwnd);
5745     flush_events();
5746     flush_sequence();
5747
5748     SetFocus(hwnd);
5749     ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
5750
5751     state = GetKeyState(VK_SHIFT);
5752     ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
5753     state = GetKeyState(VK_CAPITAL);
5754     ok(state == 0, "wrong CapsLock state %04x\n", state);
5755
5756     hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
5757     assert(hAccel != 0);
5758
5759     pump_msg_loop(hwnd, 0);
5760     flush_sequence();
5761
5762     trace("testing VK_N press/release\n");
5763     flush_sequence();
5764     keybd_event('N', 0, 0, 0);
5765     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5766     pump_msg_loop(hwnd, hAccel);
5767     ok_sequence(WmVkN, "VK_N press/release", FALSE);
5768
5769     trace("testing Shift+VK_N press/release\n");
5770     flush_sequence();
5771     keybd_event(VK_SHIFT, 0, 0, 0);
5772     keybd_event('N', 0, 0, 0);
5773     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5774     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
5775     pump_msg_loop(hwnd, hAccel);
5776     ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
5777
5778     trace("testing Ctrl+VK_N press/release\n");
5779     flush_sequence();
5780     keybd_event(VK_CONTROL, 0, 0, 0);
5781     keybd_event('N', 0, 0, 0);
5782     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5783     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
5784     pump_msg_loop(hwnd, hAccel);
5785     ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
5786
5787     trace("testing Alt+VK_N press/release\n");
5788     flush_sequence();
5789     keybd_event(VK_MENU, 0, 0, 0);
5790     keybd_event('N', 0, 0, 0);
5791     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5792     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5793     pump_msg_loop(hwnd, hAccel);
5794     ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
5795
5796     trace("testing Ctrl+Alt+VK_N press/release 1\n");
5797     flush_sequence();
5798     keybd_event(VK_CONTROL, 0, 0, 0);
5799     keybd_event(VK_MENU, 0, 0, 0);
5800     keybd_event('N', 0, 0, 0);
5801     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5802     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5803     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
5804     pump_msg_loop(hwnd, hAccel);
5805     ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
5806
5807     ret = DestroyAcceleratorTable(hAccel);
5808     ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
5809
5810     hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
5811     assert(hAccel != 0);
5812
5813     trace("testing VK_N press/release\n");
5814     flush_sequence();
5815     keybd_event('N', 0, 0, 0);
5816     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5817     pump_msg_loop(hwnd, hAccel);
5818     ok_sequence(WmVkN, "VK_N press/release", FALSE);
5819
5820     trace("testing Shift+VK_N press/release\n");
5821     flush_sequence();
5822     keybd_event(VK_SHIFT, 0, 0, 0);
5823     keybd_event('N', 0, 0, 0);
5824     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5825     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
5826     pump_msg_loop(hwnd, hAccel);
5827     ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
5828
5829     trace("testing Ctrl+VK_N press/release 2\n");
5830     flush_sequence();
5831     keybd_event(VK_CONTROL, 0, 0, 0);
5832     keybd_event('N', 0, 0, 0);
5833     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5834     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
5835     pump_msg_loop(hwnd, hAccel);
5836     ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
5837
5838     trace("testing Alt+VK_N press/release 2\n");
5839     flush_sequence();
5840     keybd_event(VK_MENU, 0, 0, 0);
5841     keybd_event('N', 0, 0, 0);
5842     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5843     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5844     pump_msg_loop(hwnd, hAccel);
5845     ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
5846
5847     trace("testing Ctrl+Alt+VK_N press/release 2\n");
5848     flush_sequence();
5849     keybd_event(VK_CONTROL, 0, 0, 0);
5850     keybd_event(VK_MENU, 0, 0, 0);
5851     keybd_event('N', 0, 0, 0);
5852     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5853     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5854     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
5855     pump_msg_loop(hwnd, hAccel);
5856     ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
5857
5858     trace("testing Ctrl+Shift+VK_N press/release\n");
5859     flush_sequence();
5860     keybd_event(VK_CONTROL, 0, 0, 0);
5861     keybd_event(VK_SHIFT, 0, 0, 0);
5862     keybd_event('N', 0, 0, 0);
5863     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5864     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
5865     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
5866     pump_msg_loop(hwnd, hAccel);
5867     ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
5868
5869     trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
5870     flush_sequence();
5871     keybd_event(VK_CONTROL, 0, 0, 0);
5872     keybd_event(VK_MENU, 0, 0, 0);
5873     keybd_event(VK_SHIFT, 0, 0, 0);
5874     keybd_event('N', 0, 0, 0);
5875     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
5876     keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
5877     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5878     keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
5879     pump_msg_loop(hwnd, hAccel);
5880     ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
5881
5882     ret = DestroyAcceleratorTable(hAccel);
5883     ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
5884
5885     trace("testing Alt press/release\n");
5886     flush_sequence();
5887     keybd_event(VK_MENU, 0, 0, 0);
5888     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5889     keybd_event(VK_MENU, 0, 0, 0);
5890     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5891     pump_msg_loop(hwnd, 0);
5892     /* this test doesn't pass in Wine for managed windows */
5893     ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
5894
5895     trace("testing Alt+MouseButton press/release\n");
5896     /* first, move mouse pointer inside of the window client area */
5897     GetClientRect(hwnd, &rc);
5898     MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
5899     rc.left += (rc.right - rc.left)/2;
5900     rc.top += (rc.bottom - rc.top)/2;
5901     SetCursorPos(rc.left, rc.top);
5902
5903     flush_events();
5904     flush_sequence();
5905     keybd_event(VK_MENU, 0, 0, 0);
5906     mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
5907     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
5908     keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
5909     pump_msg_loop(hwnd, 0);
5910     ok_sequence(WmAltMouseButton, "Alt+MouseButton press/release", FALSE);
5911
5912     trace("testing VK_F1 press/release\n");
5913     keybd_event(VK_F1, 0, 0, 0);
5914     keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
5915     pump_msg_loop(hwnd, 0);
5916     ok_sequence(WmF1Seq, "F1 press/release", TRUE);
5917
5918     trace("testing VK_APPS press/release\n");
5919     keybd_event(VK_APPS, 0, 0, 0);
5920     keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
5921     pump_msg_loop(hwnd, 0);
5922     ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
5923
5924     DestroyWindow(hwnd);
5925 }
5926
5927 /************* window procedures ********************/
5928
5929 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message, 
5930                              WPARAM wParam, LPARAM lParam)
5931 {
5932     static long defwndproc_counter = 0;
5933     static long beginpaint_counter = 0;
5934     LRESULT ret;
5935     struct message msg;
5936
5937     trace("%p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
5938
5939     /* explicitly ignore WM_GETICON message */
5940     if (message == WM_GETICON) return 0;
5941
5942     switch (message)
5943     {
5944         case WM_ENABLE:
5945         {
5946             LONG style = GetWindowLongA(hwnd, GWL_STYLE);
5947             ok((BOOL)wParam == !(style & WS_DISABLED),
5948                 "wrong WS_DISABLED state: %ld != %d\n", wParam, !(style & WS_DISABLED));
5949             break;
5950         }
5951
5952         case WM_CAPTURECHANGED:
5953             if (test_DestroyWindow_flag)
5954             {
5955                 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
5956                 if (style & WS_CHILD)
5957                     lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
5958                 else if (style & WS_POPUP)
5959                     lParam = WND_POPUP_ID;
5960                 else
5961                     lParam = WND_PARENT_ID;
5962             }
5963             break;
5964
5965         case WM_NCDESTROY:
5966         {
5967             HWND capture;
5968
5969             ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
5970             capture = GetCapture();
5971             if (capture)
5972             {
5973                 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
5974                 trace("current capture %p, releasing...\n", capture);
5975                 ReleaseCapture();
5976             }
5977         }
5978         /* fall through */
5979         case WM_DESTROY:
5980             if (pGetAncestor)
5981                 ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
5982             if (test_DestroyWindow_flag)
5983             {
5984                 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
5985                 if (style & WS_CHILD)
5986                     lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
5987                 else if (style & WS_POPUP)
5988                     lParam = WND_POPUP_ID;
5989                 else
5990                     lParam = WND_PARENT_ID;
5991             }
5992             break;
5993
5994         /* test_accelerators() depends on this */
5995         case WM_NCHITTEST:
5996             return HTCLIENT;
5997     
5998         /* ignore */
5999         case WM_MOUSEMOVE:
6000         case WM_SETCURSOR:
6001         case WM_DEVICECHANGE:
6002             return 0;
6003
6004         case WM_WINDOWPOSCHANGING:
6005         case WM_WINDOWPOSCHANGED:
6006         {
6007             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6008
6009             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6010             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
6011                   winpos->hwnd, winpos->hwndInsertAfter,
6012                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6013             dump_winpos_flags(winpos->flags);
6014
6015             /* Log only documented flags, win2k uses 0x1000 and 0x2000
6016              * in the high word for internal purposes
6017              */
6018             wParam = winpos->flags & 0xffff;
6019             /* We are not interested in the flags that don't match under XP and Win9x */
6020             wParam &= ~(SWP_NOZORDER);
6021             break;
6022         }
6023     }
6024
6025     msg.message = message;
6026     msg.flags = sent|wparam|lparam;
6027     if (defwndproc_counter) msg.flags |= defwinproc;
6028     if (beginpaint_counter) msg.flags |= beginpaint;
6029     msg.wParam = wParam;
6030     msg.lParam = lParam;
6031     add_message(&msg);
6032
6033     if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
6034     {
6035         HWND parent = GetParent(hwnd);
6036         RECT rc;
6037         MINMAXINFO *minmax = (MINMAXINFO *)lParam;
6038
6039         GetClientRect(parent, &rc);
6040         trace("parent %p client size = (%d x %d)\n", parent, rc.right, rc.bottom);
6041
6042         trace("ptReserved = (%d,%d)\n"
6043               "ptMaxSize = (%d,%d)\n"
6044               "ptMaxPosition = (%d,%d)\n"
6045               "ptMinTrackSize = (%d,%d)\n"
6046               "ptMaxTrackSize = (%d,%d)\n",
6047               minmax->ptReserved.x, minmax->ptReserved.y,
6048               minmax->ptMaxSize.x, minmax->ptMaxSize.y,
6049               minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
6050               minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
6051               minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
6052
6053         ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %d != %d\n",
6054            minmax->ptMaxSize.x, rc.right);
6055         ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %d != %d\n",
6056            minmax->ptMaxSize.y, rc.bottom);
6057     }
6058
6059     if (message == WM_PAINT)
6060     {
6061         PAINTSTRUCT ps;
6062         beginpaint_counter++;
6063         BeginPaint( hwnd, &ps );
6064         beginpaint_counter--;
6065         EndPaint( hwnd, &ps );
6066         return 0;
6067     }
6068
6069     defwndproc_counter++;
6070     ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam) 
6071                   : DefWindowProcA(hwnd, message, wParam, lParam);
6072     defwndproc_counter--;
6073
6074     return ret;
6075 }
6076
6077 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6078 {
6079     return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
6080 }
6081
6082 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6083 {
6084     return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
6085 }
6086
6087 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6088 {
6089     static long defwndproc_counter = 0;
6090     LRESULT ret;
6091     struct message msg;
6092
6093     trace("popup: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6094
6095     /* explicitly ignore WM_GETICON message */
6096     if (message == WM_GETICON) return 0;
6097
6098     msg.message = message;
6099     msg.flags = sent|wparam|lparam;
6100     if (defwndproc_counter) msg.flags |= defwinproc;
6101     msg.wParam = wParam;
6102     msg.lParam = lParam;
6103     add_message(&msg);
6104
6105     if (message == WM_CREATE)
6106     {
6107         DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
6108         SetWindowLongA(hwnd, GWL_STYLE, style);
6109     }
6110
6111     defwndproc_counter++;
6112     ret = DefWindowProcA(hwnd, message, wParam, lParam);
6113     defwndproc_counter--;
6114
6115     return ret;
6116 }
6117
6118 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6119 {
6120     static long defwndproc_counter = 0;
6121     static long beginpaint_counter = 0;
6122     LRESULT ret;
6123     struct message msg;
6124
6125     trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6126
6127     /* explicitly ignore WM_GETICON message */
6128     if (message == WM_GETICON) return 0;
6129
6130     if (log_all_parent_messages ||
6131         message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
6132         message == WM_SETFOCUS || message == WM_KILLFOCUS ||
6133         message == WM_ENABLE || message == WM_ENTERIDLE ||
6134         message == WM_IME_SETCONTEXT)
6135     {
6136         switch (message)
6137         {
6138             /* ignore */
6139             case WM_NCHITTEST:
6140                 return HTCLIENT;
6141             case WM_SETCURSOR:
6142             case WM_MOUSEMOVE:
6143                 return 0;
6144
6145             case WM_ERASEBKGND:
6146             {
6147                 RECT rc;
6148                 INT ret = GetClipBox((HDC)wParam, &rc);
6149
6150                 trace("WM_ERASEBKGND: GetClipBox()=%d, (%d,%d-%d,%d)\n",
6151                        ret, rc.left, rc.top, rc.right, rc.bottom);
6152                 break;
6153             }
6154
6155             case WM_WINDOWPOSCHANGING:
6156             case WM_WINDOWPOSCHANGED:
6157             {
6158                 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6159
6160                 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6161                 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
6162                       winpos->hwnd, winpos->hwndInsertAfter,
6163                       winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6164                 dump_winpos_flags(winpos->flags);
6165
6166                 /* Log only documented flags, win2k uses 0x1000 and 0x2000
6167                  * in the high word for internal purposes
6168                  */
6169                 wParam = winpos->flags & 0xffff;
6170                 /* We are not interested in the flags that don't match under XP and Win9x */
6171                 wParam &= ~(SWP_NOZORDER);
6172                 break;
6173             }
6174         }
6175
6176         msg.message = message;
6177         msg.flags = sent|parent|wparam|lparam;
6178         if (defwndproc_counter) msg.flags |= defwinproc;
6179         if (beginpaint_counter) msg.flags |= beginpaint;
6180         msg.wParam = wParam;
6181         msg.lParam = lParam;
6182         add_message(&msg);
6183     }
6184
6185     if (message == WM_PAINT)
6186     {
6187         PAINTSTRUCT ps;
6188         beginpaint_counter++;
6189         BeginPaint( hwnd, &ps );
6190         beginpaint_counter--;
6191         EndPaint( hwnd, &ps );
6192         return 0;
6193     }
6194
6195     defwndproc_counter++;
6196     ret = DefWindowProcA(hwnd, message, wParam, lParam);
6197     defwndproc_counter--;
6198
6199     return ret;
6200 }
6201
6202 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6203 {
6204     static long defwndproc_counter = 0;
6205     LRESULT ret;
6206     struct message msg;
6207
6208     trace("dialog: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6209
6210     /* explicitly ignore WM_GETICON message */
6211     if (message == WM_GETICON) return 0;
6212
6213     if (test_def_id)
6214     {
6215         DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
6216         ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
6217         if (after_end_dialog)
6218             ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
6219         else
6220             ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
6221     }
6222
6223     switch (message)
6224     {
6225         case WM_WINDOWPOSCHANGING:
6226         case WM_WINDOWPOSCHANGED:
6227         {
6228             WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6229
6230             trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6231             trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
6232                   winpos->hwnd, winpos->hwndInsertAfter,
6233                   winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6234             dump_winpos_flags(winpos->flags);
6235
6236             /* Log only documented flags, win2k uses 0x1000 and 0x2000
6237              * in the high word for internal purposes
6238              */
6239             wParam = winpos->flags & 0xffff;
6240             /* We are not interested in the flags that don't match under XP and Win9x */
6241             wParam &= ~(SWP_NOZORDER);
6242             break;
6243         }
6244     }
6245
6246     msg.message = message;
6247     msg.flags = sent|wparam|lparam;
6248     if (defwndproc_counter) msg.flags |= defwinproc;
6249     msg.wParam = wParam;
6250     msg.lParam = lParam;
6251     add_message(&msg);
6252
6253     defwndproc_counter++;
6254     ret = DefDlgProcA(hwnd, message, wParam, lParam);
6255     defwndproc_counter--;
6256
6257     return ret;
6258 }
6259
6260 static void dump_winpos_flags(UINT flags)
6261 {
6262     if (!winetest_debug) return;
6263
6264     if (flags & SWP_SHOWWINDOW) printf("|SWP_SHOWWINDOW");
6265     if (flags & SWP_HIDEWINDOW) printf("|SWP_HIDEWINDOW");
6266     if (flags & SWP_NOACTIVATE) printf("|SWP_NOACTIVATE");
6267     if (flags & SWP_FRAMECHANGED) printf("|SWP_FRAMECHANGED");
6268     if (flags & SWP_NOCOPYBITS) printf("|SWP_NOCOPYBITS");
6269     if (flags & SWP_NOOWNERZORDER) printf("|SWP_NOOWNERZORDER");
6270     if (flags & SWP_NOSENDCHANGING) printf("|SWP_NOSENDCHANGING");
6271     if (flags & SWP_DEFERERASE) printf("|SWP_DEFERERASE");
6272     if (flags & SWP_ASYNCWINDOWPOS) printf("|SWP_ASYNCWINDOWPOS");
6273     if (flags & SWP_NOZORDER) printf("|SWP_NOZORDER");
6274     if (flags & SWP_NOREDRAW) printf("|SWP_NOREDRAW");
6275     if (flags & SWP_NOSIZE) printf("|SWP_NOSIZE");
6276     if (flags & SWP_NOMOVE) printf("|SWP_NOMOVE");
6277     if (flags & SWP_NOCLIENTSIZE) printf("|SWP_NOCLIENTSIZE");
6278     if (flags & SWP_NOCLIENTMOVE) printf("|SWP_NOCLIENTMOVE");
6279
6280 #define DUMPED_FLAGS \
6281     (SWP_NOSIZE | \
6282     SWP_NOMOVE | \
6283     SWP_NOZORDER | \
6284     SWP_NOREDRAW | \
6285     SWP_NOACTIVATE | \
6286     SWP_FRAMECHANGED | \
6287     SWP_SHOWWINDOW | \
6288     SWP_HIDEWINDOW | \
6289     SWP_NOCOPYBITS | \
6290     SWP_NOOWNERZORDER | \
6291     SWP_NOSENDCHANGING | \
6292     SWP_DEFERERASE | \
6293     SWP_ASYNCWINDOWPOS | \
6294     SWP_NOCLIENTSIZE | \
6295     SWP_NOCLIENTMOVE)
6296
6297     if(flags & ~DUMPED_FLAGS) printf("|0x%04x", flags & ~DUMPED_FLAGS);
6298     printf("\n");
6299 #undef DUMPED_FLAGS
6300 }
6301
6302 static LRESULT WINAPI ShowWindowProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6303 {
6304     static long defwndproc_counter = 0;
6305     LRESULT ret;
6306     struct message msg;
6307
6308     /* log only specific messages we are interested in */
6309     switch (message)
6310     {
6311 #if 0 /* probably log these as well */
6312     case WM_ACTIVATE:
6313     case WM_SETFOCUS:
6314     case WM_KILLFOCUS:
6315 #endif
6316     case WM_SHOWWINDOW:
6317         trace("WM_SHOWWINDOW %ld\n", wParam);
6318         break;
6319     case WM_SIZE:
6320         trace("WM_SIZE %ld\n", wParam);
6321         break;
6322     case WM_MOVE:
6323         trace("WM_MOVE\n");
6324         break;
6325     case WM_GETMINMAXINFO:
6326         trace("WM_GETMINMAXINFO\n");
6327         break;
6328
6329     case WM_WINDOWPOSCHANGING:
6330     case WM_WINDOWPOSCHANGED:
6331     {
6332         WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6333
6334         trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6335         trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
6336               winpos->hwnd, winpos->hwndInsertAfter,
6337               winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6338         trace("flags: ");
6339         dump_winpos_flags(winpos->flags);
6340
6341         /* Log only documented flags, win2k uses 0x1000 and 0x2000
6342          * in the high word for internal purposes
6343          */
6344         wParam = winpos->flags & 0xffff;
6345         /* We are not interested in the flags that don't match under XP and Win9x */
6346         wParam &= ~(SWP_NOZORDER);
6347         break;
6348     }
6349
6350     default: /* ignore */
6351         /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
6352         return DefWindowProcA(hwnd, message, wParam, lParam);
6353     }
6354
6355     msg.message = message;
6356     msg.flags = sent|wparam|lparam;
6357     if (defwndproc_counter) msg.flags |= defwinproc;
6358     msg.wParam = wParam;
6359     msg.lParam = lParam;
6360     add_message(&msg);
6361
6362     defwndproc_counter++;
6363     ret = DefWindowProcA(hwnd, message, wParam, lParam);
6364     defwndproc_counter--;
6365
6366     return ret;
6367 }
6368
6369 static BOOL RegisterWindowClasses(void)
6370 {
6371     WNDCLASSA cls;
6372     WNDCLASSW clsW;
6373
6374     cls.style = 0;
6375     cls.lpfnWndProc = MsgCheckProcA;
6376     cls.cbClsExtra = 0;
6377     cls.cbWndExtra = 0;
6378     cls.hInstance = GetModuleHandleA(0);
6379     cls.hIcon = 0;
6380     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
6381     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
6382     cls.lpszMenuName = NULL;
6383     cls.lpszClassName = "TestWindowClass";
6384     if(!RegisterClassA(&cls)) return FALSE;
6385
6386     cls.lpfnWndProc = ShowWindowProcA;
6387     cls.lpszClassName = "ShowWindowClass";
6388     if(!RegisterClassA(&cls)) return FALSE;
6389
6390     cls.lpfnWndProc = PopupMsgCheckProcA;
6391     cls.lpszClassName = "TestPopupClass";
6392     if(!RegisterClassA(&cls)) return FALSE;
6393
6394     cls.lpfnWndProc = ParentMsgCheckProcA;
6395     cls.lpszClassName = "TestParentClass";
6396     if(!RegisterClassA(&cls)) return FALSE;
6397
6398     cls.lpfnWndProc = DefWindowProcA;
6399     cls.lpszClassName = "SimpleWindowClass";
6400     if(!RegisterClassA(&cls)) return FALSE;
6401
6402     cls.style = CS_NOCLOSE;
6403     cls.lpszClassName = "NoCloseWindowClass";
6404     if(!RegisterClassA(&cls)) return FALSE;
6405
6406     ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
6407     cls.style = 0;
6408     cls.hInstance = GetModuleHandleA(0);
6409     cls.hbrBackground = 0;
6410     cls.lpfnWndProc = TestDlgProcA;
6411     cls.lpszClassName = "TestDialogClass";
6412     if(!RegisterClassA(&cls)) return FALSE;
6413
6414     clsW.style = 0;
6415     clsW.lpfnWndProc = MsgCheckProcW;
6416     clsW.cbClsExtra = 0;
6417     clsW.cbWndExtra = 0;
6418     clsW.hInstance = GetModuleHandleW(0);
6419     clsW.hIcon = 0;
6420     clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
6421     clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
6422     clsW.lpszMenuName = NULL;
6423     clsW.lpszClassName = testWindowClassW;
6424     RegisterClassW(&clsW);  /* ignore error, this fails on Win9x */
6425
6426     return TRUE;
6427 }
6428
6429 static HHOOK hCBT_hook;
6430 static DWORD cbt_hook_thread_id;
6431
6432 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam) 
6433 { 
6434     static const char * const CBT_code_name[10] = {
6435         "HCBT_MOVESIZE",
6436         "HCBT_MINMAX",
6437         "HCBT_QS",
6438         "HCBT_CREATEWND",
6439         "HCBT_DESTROYWND",
6440         "HCBT_ACTIVATE",
6441         "HCBT_CLICKSKIPPED",
6442         "HCBT_KEYSKIPPED",
6443         "HCBT_SYSCOMMAND",
6444         "HCBT_SETFOCUS" };
6445     const char *code_name = (nCode >= 0 && nCode <= HCBT_SETFOCUS) ? CBT_code_name[nCode] : "Unknown";
6446     HWND hwnd;
6447     char buf[256];
6448
6449     trace("CBT: %d (%s), %08lx, %08lx\n", nCode, code_name, wParam, lParam);
6450
6451     ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
6452
6453     if (nCode == HCBT_CLICKSKIPPED)
6454     {
6455         /* ignore this event, XP sends it a lot when switching focus between windows */
6456         return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
6457     }
6458
6459     if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
6460     {
6461         struct message msg;
6462
6463         msg.message = nCode;
6464         msg.flags = hook|wparam|lparam;
6465         msg.wParam = wParam;
6466         msg.lParam = lParam;
6467         add_message(&msg);
6468
6469         return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
6470     }
6471
6472     if (nCode == HCBT_DESTROYWND)
6473     {
6474         if (test_DestroyWindow_flag)
6475         {
6476             DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
6477             if (style & WS_CHILD)
6478                 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
6479             else if (style & WS_POPUP)
6480                 lParam = WND_POPUP_ID;
6481             else
6482                 lParam = WND_PARENT_ID;
6483         }
6484     }
6485
6486     /* Log also SetFocus(0) calls */
6487     hwnd = wParam ? (HWND)wParam : (HWND)lParam;
6488
6489     if (GetClassNameA(hwnd, buf, sizeof(buf)))
6490     {
6491         if (!lstrcmpiA(buf, "TestWindowClass") ||
6492             !lstrcmpiA(buf, "ShowWindowClass") ||
6493             !lstrcmpiA(buf, "TestParentClass") ||
6494             !lstrcmpiA(buf, "TestPopupClass") ||
6495             !lstrcmpiA(buf, "SimpleWindowClass") ||
6496             !lstrcmpiA(buf, "TestDialogClass") ||
6497             !lstrcmpiA(buf, "MDI_frame_class") ||
6498             !lstrcmpiA(buf, "MDI_client_class") ||
6499             !lstrcmpiA(buf, "MDI_child_class") ||
6500             !lstrcmpiA(buf, "my_button_class") ||
6501             !lstrcmpiA(buf, "my_edit_class") ||
6502             !lstrcmpiA(buf, "static") ||
6503             !lstrcmpiA(buf, "MyDialogClass") ||
6504             !lstrcmpiA(buf, "#32770"))
6505         {
6506             struct message msg;
6507
6508             msg.message = nCode;
6509             msg.flags = hook|wparam|lparam;
6510             msg.wParam = wParam;
6511             msg.lParam = lParam;
6512             add_message(&msg);
6513         }
6514     }
6515     return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
6516 }
6517
6518 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
6519                                     DWORD event,
6520                                     HWND hwnd,
6521                                     LONG object_id,
6522                                     LONG child_id,
6523                                     DWORD thread_id,
6524                                     DWORD event_time)
6525 {
6526     char buf[256];
6527
6528     trace("WEH:%p,event %08x,hwnd %p,obj %08x,id %08x,thread %08x,time %08x\n",
6529            hevent, event, hwnd, object_id, child_id, thread_id, event_time);
6530
6531     ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
6532
6533     /* ignore mouse cursor events */
6534     if (object_id == OBJID_CURSOR) return;
6535
6536     if (!hwnd || GetClassNameA(hwnd, buf, sizeof(buf)))
6537     {
6538         if (!hwnd ||
6539             !lstrcmpiA(buf, "TestWindowClass") ||
6540             !lstrcmpiA(buf, "TestParentClass") ||
6541             !lstrcmpiA(buf, "TestPopupClass") ||
6542             !lstrcmpiA(buf, "SimpleWindowClass") ||
6543             !lstrcmpiA(buf, "TestDialogClass") ||
6544             !lstrcmpiA(buf, "MDI_frame_class") ||
6545             !lstrcmpiA(buf, "MDI_client_class") ||
6546             !lstrcmpiA(buf, "MDI_child_class") ||
6547             !lstrcmpiA(buf, "my_button_class") ||
6548             !lstrcmpiA(buf, "my_edit_class") ||
6549             !lstrcmpiA(buf, "static") ||
6550             !lstrcmpiA(buf, "MyDialogClass") ||
6551             !lstrcmpiA(buf, "#32770"))
6552         {
6553             struct message msg;
6554
6555             msg.message = event;
6556             msg.flags = winevent_hook|wparam|lparam;
6557             msg.wParam = object_id;
6558             msg.lParam = child_id;
6559             add_message(&msg);
6560         }
6561     }
6562 }
6563
6564 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
6565 static const WCHAR wszAnsi[] = {'U',0};
6566
6567 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
6568 {
6569     switch (uMsg)
6570     {
6571     case CB_FINDSTRINGEXACT:
6572         trace("String: %p\n", (LPCWSTR)lParam);
6573         if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
6574             return 1;
6575         if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
6576             return 0;
6577         return -1;
6578     }
6579     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
6580 }
6581
6582 static const struct message WmGetTextLengthAfromW[] = {
6583     { WM_GETTEXTLENGTH, sent },
6584     { WM_GETTEXT, sent },
6585     { 0 }
6586 };
6587
6588 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
6589
6590 /* dummy window proc for WM_GETTEXTLENGTH test */
6591 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
6592 {
6593     switch(msg)
6594     {
6595     case WM_GETTEXTLENGTH:
6596         return lstrlenW(dummy_window_text) + 37;  /* some random length */
6597     case WM_GETTEXT:
6598         lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
6599         return lstrlenW( (LPWSTR)lp );
6600     default:
6601         return DefWindowProcW( hwnd, msg, wp, lp );
6602     }
6603 }
6604
6605 static void test_message_conversion(void)
6606 {
6607     static const WCHAR wszMsgConversionClass[] =
6608         {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
6609     WNDCLASSW cls;
6610     LRESULT lRes;
6611     HWND hwnd;
6612     WNDPROC wndproc, newproc;
6613     BOOL ret;
6614
6615     cls.style = 0;
6616     cls.lpfnWndProc = MsgConversionProcW;
6617     cls.cbClsExtra = 0;
6618     cls.cbWndExtra = 0;
6619     cls.hInstance = GetModuleHandleW(NULL);
6620     cls.hIcon = NULL;
6621     cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
6622     cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
6623     cls.lpszMenuName = NULL;
6624     cls.lpszClassName = wszMsgConversionClass;
6625     /* this call will fail on Win9x, but that doesn't matter as this test is
6626      * meaningless on those platforms */
6627     if(!RegisterClassW(&cls)) return;
6628
6629     hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
6630                            100, 100, 200, 200, 0, 0, 0, NULL);
6631     ok(hwnd != NULL, "Window creation failed\n");
6632
6633     /* {W, A} -> A */
6634
6635     wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
6636     lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6637     ok(lRes == 0, "String should have been converted\n");
6638     lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6639     ok(lRes == 1, "String shouldn't have been converted\n");
6640
6641     /* {W, A} -> W */
6642
6643     wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
6644     lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6645     ok(lRes == 1, "String shouldn't have been converted\n");
6646     lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6647     ok(lRes == 1, "String shouldn't have been converted\n");
6648
6649     /* Synchronous messages */
6650
6651     lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6652     ok(lRes == 0, "String should have been converted\n");
6653     lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6654     ok(lRes == 1, "String shouldn't have been converted\n");
6655
6656     /* Asynchronous messages */
6657
6658     SetLastError(0);
6659     lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6660     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6661         "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6662     SetLastError(0);
6663     lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6664     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6665         "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6666     SetLastError(0);
6667     lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6668     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6669         "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6670     SetLastError(0);
6671     lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6672     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6673         "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6674     SetLastError(0);
6675     lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6676     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6677         "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6678     SetLastError(0);
6679     lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
6680     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6681         "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6682     SetLastError(0);
6683     lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
6684     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6685         "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6686     SetLastError(0);
6687     lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
6688     ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
6689         "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
6690
6691     /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
6692
6693     hwnd = CreateWindowW (testWindowClassW, wszUnicode,
6694                           WS_OVERLAPPEDWINDOW,
6695                           100, 100, 200, 200, 0, 0, 0, NULL);
6696     assert(hwnd);
6697     flush_sequence();
6698     lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
6699     ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
6700     ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
6701         "got bad length %ld\n", lRes );
6702
6703     flush_sequence();
6704     lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
6705                             hwnd, WM_GETTEXTLENGTH, 0, 0);
6706     ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
6707     ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
6708         "got bad length %ld\n", lRes );
6709
6710     wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
6711     newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
6712     lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
6713     ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
6714                                      NULL, 0, NULL, NULL ),
6715         "got bad length %ld\n", lRes );
6716
6717     SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc );  /* restore old wnd proc */
6718     lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
6719     ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
6720                                      NULL, 0, NULL, NULL ),
6721         "got bad length %ld\n", lRes );
6722
6723     ret = DestroyWindow(hwnd);
6724     ok( ret, "DestroyWindow() error %d\n", GetLastError());
6725 }
6726
6727 struct timer_info
6728 {
6729     HWND hWnd;
6730     HANDLE handles[2];
6731     DWORD id;
6732 };
6733
6734 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
6735 {
6736 }
6737
6738 #define TIMER_ID  0x19
6739
6740 static DWORD WINAPI timer_thread_proc(LPVOID x)
6741 {
6742     struct timer_info *info = x;
6743     DWORD r;
6744
6745     r = KillTimer(info->hWnd, 0x19);
6746     ok(r,"KillTimer failed in thread\n");
6747     r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
6748     ok(r,"SetTimer failed in thread\n");
6749     ok(r==TIMER_ID,"SetTimer id different\n");
6750     r = SetEvent(info->handles[0]);
6751     ok(r,"SetEvent failed in thread\n");
6752     return 0;
6753 }
6754
6755 static void test_timers(void)
6756 {
6757     struct timer_info info;
6758     DWORD id;
6759
6760     info.hWnd = CreateWindow ("TestWindowClass", NULL,
6761        WS_OVERLAPPEDWINDOW ,
6762        CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
6763        NULL, NULL, 0);
6764
6765     info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
6766     ok(info.id, "SetTimer failed\n");
6767     ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
6768     info.handles[0] = CreateEvent(NULL,0,0,NULL);
6769     info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
6770
6771     WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
6772
6773     WaitForSingleObject(info.handles[1], INFINITE);
6774
6775     CloseHandle(info.handles[0]);
6776     CloseHandle(info.handles[1]);
6777
6778     ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
6779
6780     ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
6781 }
6782
6783 static int count = 0;
6784 static VOID CALLBACK callback_count(
6785     HWND hwnd,
6786     UINT uMsg,
6787     UINT_PTR idEvent,
6788     DWORD dwTime
6789 )
6790 {
6791     count++;
6792 }
6793
6794 static void test_timers_no_wnd(void)
6795 {
6796     UINT_PTR id, id2;
6797     MSG msg;
6798
6799     count = 0;
6800     id = SetTimer(NULL, 0, 100, callback_count);
6801     ok(id != 0, "did not get id from SetTimer.\n");
6802     id2 = SetTimer(NULL, id, 200, callback_count);
6803     ok(id2 == id, "did not get same id from SetTimer when replacing (%li expected %li).\n", id2, id);
6804     Sleep(150);
6805     while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
6806     ok(count == 0, "did not get zero count as expected (%i).\n", count);
6807     Sleep(150);
6808     while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
6809     ok(count == 1, "did not get one count as expected (%i).\n", count);
6810     KillTimer(NULL, id);
6811     Sleep(250);
6812     while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
6813     ok(count == 1, "killing replaced timer did not work (%i).\n", count);
6814 }
6815
6816 /* Various win events with arbitrary parameters */
6817 static const struct message WmWinEventsSeq[] = {
6818     { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
6819     { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
6820     { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
6821     { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
6822     { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
6823     { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
6824     { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
6825     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
6826     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
6827     /* our win event hook ignores OBJID_CURSOR events */
6828     /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
6829     { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
6830     { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
6831     { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
6832     { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
6833     { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
6834     { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
6835     { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
6836     { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
6837     { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
6838     { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
6839     { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
6840     { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
6841     { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
6842     { 0 }
6843 };
6844 static const struct message WmWinEventCaretSeq[] = {
6845     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
6846     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
6847     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
6848     { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
6849     { 0 }
6850 };
6851 static const struct message WmWinEventCaretSeq_2[] = {
6852     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
6853     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
6854     { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
6855     { 0 }
6856 };
6857 static const struct message WmWinEventAlertSeq[] = {
6858     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
6859     { 0 }
6860 };
6861 static const struct message WmWinEventAlertSeq_2[] = {
6862     /* create window in the thread proc */
6863     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
6864     /* our test event */
6865     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
6866     { 0 }
6867 };
6868 static const struct message WmGlobalHookSeq_1[] = {
6869     /* create window in the thread proc */
6870     { HCBT_CREATEWND, hook|lparam, 0, 2 },
6871     /* our test events */
6872     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
6873     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
6874     { 0 }
6875 };
6876 static const struct message WmGlobalHookSeq_2[] = {
6877     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
6878     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
6879     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
6880     { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
6881     { 0 }
6882 };
6883
6884 static const struct message WmMouseLLHookSeq[] = {
6885     { WM_MOUSEMOVE, hook },
6886     { WM_LBUTTONUP, hook },
6887     { WM_MOUSEMOVE, hook },
6888     { 0 }
6889 };
6890
6891 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
6892                                          DWORD event,
6893                                          HWND hwnd,
6894                                          LONG object_id,
6895                                          LONG child_id,
6896                                          DWORD thread_id,
6897                                          DWORD event_time)
6898 {
6899     char buf[256];
6900
6901     trace("WEH_2:%p,event %08x,hwnd %p,obj %08x,id %08x,thread %08x,time %08x\n",
6902            hevent, event, hwnd, object_id, child_id, thread_id, event_time);
6903
6904     if (GetClassNameA(hwnd, buf, sizeof(buf)))
6905     {
6906         if (!lstrcmpiA(buf, "TestWindowClass") ||
6907             !lstrcmpiA(buf, "static"))
6908         {
6909             struct message msg;
6910
6911             msg.message = event;
6912             msg.flags = winevent_hook|wparam|lparam;
6913             msg.wParam = object_id;
6914             msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
6915             add_message(&msg);
6916         }
6917     }
6918 }
6919
6920 static HHOOK hCBT_global_hook;
6921 static DWORD cbt_global_hook_thread_id;
6922
6923 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam) 
6924 { 
6925     HWND hwnd;
6926     char buf[256];
6927
6928     trace("CBT_2: %d, %08lx, %08lx\n", nCode, wParam, lParam);
6929
6930     if (nCode == HCBT_SYSCOMMAND)
6931     {
6932         struct message msg;
6933
6934         msg.message = nCode;
6935         msg.flags = hook|wparam|lparam;
6936         msg.wParam = wParam;
6937         msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
6938         add_message(&msg);
6939
6940         return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
6941     }
6942     /* WH_MOUSE_LL hook */
6943     if (nCode == HC_ACTION)
6944     {
6945         struct message msg;
6946         MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
6947
6948         /* we can't test for real mouse events */
6949         if (mhll->flags & LLMHF_INJECTED)
6950         {
6951             msg.message = wParam;
6952             msg.flags = hook;
6953             add_message(&msg);
6954         }
6955         return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
6956     }
6957
6958     /* Log also SetFocus(0) calls */
6959     hwnd = wParam ? (HWND)wParam : (HWND)lParam;
6960
6961     if (GetClassNameA(hwnd, buf, sizeof(buf)))
6962     {
6963         if (!lstrcmpiA(buf, "TestWindowClass") ||
6964             !lstrcmpiA(buf, "static"))
6965         {
6966             struct message msg;
6967
6968             msg.message = nCode;
6969             msg.flags = hook|wparam|lparam;
6970             msg.wParam = wParam;
6971             msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
6972             add_message(&msg);
6973         }
6974     }
6975     return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
6976 }
6977
6978 static DWORD WINAPI win_event_global_thread_proc(void *param)
6979 {
6980     HWND hwnd;
6981     MSG msg;
6982     HANDLE hevent = *(HANDLE *)param;
6983
6984     assert(pNotifyWinEvent);
6985
6986     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
6987     assert(hwnd);
6988     trace("created thread window %p\n", hwnd);
6989
6990     *(HWND *)param = hwnd;
6991
6992     flush_sequence();
6993     /* this event should be received only by our new hook proc,
6994      * an old one does not expect an event from another thread.
6995      */
6996     pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
6997     SetEvent(hevent);
6998
6999     while (GetMessage(&msg, 0, 0, 0))
7000     {
7001         TranslateMessage(&msg);
7002         DispatchMessage(&msg);
7003     }
7004     return 0;
7005 }
7006
7007 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
7008 {
7009     HWND hwnd;
7010     MSG msg;
7011     HANDLE hevent = *(HANDLE *)param;
7012
7013     flush_sequence();
7014     /* these events should be received only by our new hook proc,
7015      * an old one does not expect an event from another thread.
7016      */
7017
7018     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7019     assert(hwnd);
7020     trace("created thread window %p\n", hwnd);
7021
7022     *(HWND *)param = hwnd;
7023
7024     /* Windows doesn't like when a thread plays games with the focus,
7025        that leads to all kinds of misbehaviours and failures to activate
7026        a window. So, better keep next lines commented out.
7027     SetFocus(0);
7028     SetFocus(hwnd);*/
7029
7030     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
7031     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
7032
7033     SetEvent(hevent);
7034
7035     while (GetMessage(&msg, 0, 0, 0))
7036     {
7037         TranslateMessage(&msg);
7038         DispatchMessage(&msg);
7039     }
7040     return 0;
7041 }
7042
7043 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
7044 {
7045     HWND hwnd;
7046     MSG msg;
7047     HANDLE hevent = *(HANDLE *)param;
7048
7049     hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7050     assert(hwnd);
7051     trace("created thread window %p\n", hwnd);
7052
7053     *(HWND *)param = hwnd;
7054
7055     flush_sequence();
7056
7057     /* Windows doesn't like when a thread plays games with the focus,
7058      * that leads to all kinds of misbehaviours and failures to activate
7059      * a window. So, better don't generate a mouse click message below.
7060      */
7061     mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
7062     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
7063     mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
7064
7065     SetEvent(hevent);
7066     while (GetMessage(&msg, 0, 0, 0))
7067     {
7068         TranslateMessage(&msg);
7069         DispatchMessage(&msg);
7070     }
7071     return 0;
7072 }
7073
7074 static void test_winevents(void)
7075 {
7076     BOOL ret;
7077     MSG msg;
7078     HWND hwnd, hwnd2;
7079     UINT i;
7080     HANDLE hthread, hevent;
7081     DWORD tid;
7082     HWINEVENTHOOK hhook;
7083     const struct message *events = WmWinEventsSeq;
7084
7085     hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
7086                            WS_OVERLAPPEDWINDOW,
7087                            CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
7088                            NULL, NULL, 0);
7089     assert(hwnd);
7090
7091     /****** start of global hook test *************/
7092     hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
7093     assert(hCBT_global_hook);
7094
7095     hevent = CreateEventA(NULL, 0, 0, NULL);
7096     assert(hevent);
7097     hwnd2 = (HWND)hevent;
7098
7099     hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
7100     ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7101
7102     ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7103
7104     ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
7105
7106     flush_sequence();
7107     /* this one should be received only by old hook proc */
7108     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
7109     /* this one should be received only by old hook proc */
7110     DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
7111
7112     ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
7113
7114     ret = UnhookWindowsHookEx(hCBT_global_hook);
7115     ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
7116
7117     PostThreadMessageA(tid, WM_QUIT, 0, 0);
7118     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7119     CloseHandle(hthread);
7120     CloseHandle(hevent);
7121     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7122     /****** end of global hook test *************/
7123
7124     if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
7125     {
7126         ok(DestroyWindow(hwnd), "failed to destroy window\n");
7127         return;
7128     }
7129
7130     flush_sequence();
7131
7132     if (0)
7133     {
7134     /* this test doesn't pass under Win9x */
7135     /* win2k ignores events with hwnd == 0 */
7136     SetLastError(0xdeadbeef);
7137     pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
7138     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
7139        GetLastError() == 0xdeadbeef, /* Win9x */
7140        "unexpected error %d\n", GetLastError());
7141     ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
7142     }
7143
7144     for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
7145         pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
7146
7147     ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
7148
7149     /****** start of event filtering test *************/
7150     hhook = (HWINEVENTHOOK)pSetWinEventHook(
7151         EVENT_OBJECT_SHOW, /* 0x8002 */
7152         EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
7153         GetModuleHandleA(0), win_event_global_hook_proc,
7154         GetCurrentProcessId(), 0,
7155         WINEVENT_INCONTEXT);
7156     ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
7157
7158     hevent = CreateEventA(NULL, 0, 0, NULL);
7159     assert(hevent);
7160     hwnd2 = (HWND)hevent;
7161
7162     hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
7163     ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7164
7165     ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7166
7167     ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
7168
7169     flush_sequence();
7170     /* this one should be received only by old hook proc */
7171     pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
7172     pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
7173     /* this one should be received only by old hook proc */
7174     pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
7175
7176     ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
7177
7178     ret = pUnhookWinEvent(hhook);
7179     ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7180
7181     PostThreadMessageA(tid, WM_QUIT, 0, 0);
7182     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7183     CloseHandle(hthread);
7184     CloseHandle(hevent);
7185     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7186     /****** end of event filtering test *************/
7187
7188     /****** start of out of context event test *************/
7189     hhook = (HWINEVENTHOOK)pSetWinEventHook(
7190         EVENT_MIN, EVENT_MAX,
7191         0, win_event_global_hook_proc,
7192         GetCurrentProcessId(), 0,
7193         WINEVENT_OUTOFCONTEXT);
7194     ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
7195
7196     hevent = CreateEventA(NULL, 0, 0, NULL);
7197     assert(hevent);
7198     hwnd2 = (HWND)hevent;
7199
7200     flush_sequence();
7201
7202     hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
7203     ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7204
7205     ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7206
7207     ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
7208     /* process pending winevent messages */
7209     ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
7210     ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
7211
7212     flush_sequence();
7213     /* this one should be received only by old hook proc */
7214     pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
7215     pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
7216     /* this one should be received only by old hook proc */
7217     pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
7218
7219     ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
7220     /* process pending winevent messages */
7221     ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
7222     ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
7223
7224     ret = pUnhookWinEvent(hhook);
7225     ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7226
7227     PostThreadMessageA(tid, WM_QUIT, 0, 0);
7228     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7229     CloseHandle(hthread);
7230     CloseHandle(hevent);
7231     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7232     /****** end of out of context event test *************/
7233
7234     /****** start of MOUSE_LL hook test *************/
7235     hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
7236     /* WH_MOUSE_LL is not supported on Win9x platforms */
7237     if (!hCBT_global_hook)
7238     {
7239         trace("Skipping WH_MOUSE_LL test on this platform\n");
7240         goto skip_mouse_ll_hook_test;
7241     }
7242
7243     hevent = CreateEventA(NULL, 0, 0, NULL);
7244     assert(hevent);
7245     hwnd2 = (HWND)hevent;
7246
7247     hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
7248     ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7249
7250     while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
7251         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
7252
7253     ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
7254     flush_sequence();
7255
7256     mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
7257     mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
7258     mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
7259
7260     ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
7261
7262     ret = UnhookWindowsHookEx(hCBT_global_hook);
7263     ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
7264
7265     PostThreadMessageA(tid, WM_QUIT, 0, 0);
7266     ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7267     CloseHandle(hthread);
7268     CloseHandle(hevent);
7269     ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7270     /****** end of MOUSE_LL hook test *************/
7271 skip_mouse_ll_hook_test:
7272
7273     ok(DestroyWindow(hwnd), "failed to destroy window\n");
7274 }
7275
7276 static void test_set_hook(void)
7277 {
7278     BOOL ret;
7279     HHOOK hhook;
7280     HWINEVENTHOOK hwinevent_hook;
7281
7282     hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
7283     ok(hhook != 0, "local hook does not require hModule set to 0\n");
7284     UnhookWindowsHookEx(hhook);
7285
7286     if (0)
7287     {
7288     /* this test doesn't pass under Win9x: BUG! */
7289     SetLastError(0xdeadbeef);
7290     hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
7291     ok(!hhook, "global hook requires hModule != 0\n");
7292     ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %d\n", GetLastError());
7293     }
7294
7295     SetLastError(0xdeadbeef);
7296     hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
7297     ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
7298     ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
7299        GetLastError() == 0xdeadbeef, /* Win9x */
7300        "unexpected error %d\n", GetLastError());
7301
7302     SetLastError(0xdeadbeef);
7303     ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
7304     ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
7305        GetLastError() == 0xdeadbeef, /* Win9x */
7306        "unexpected error %d\n", GetLastError());
7307
7308     if (!pSetWinEventHook || !pUnhookWinEvent) return;
7309
7310     /* even process local incontext hooks require hmodule */
7311     SetLastError(0xdeadbeef);
7312     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
7313         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
7314     ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
7315     ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
7316        GetLastError() == 0xdeadbeef, /* Win9x */
7317        "unexpected error %d\n", GetLastError());
7318
7319     /* even thread local incontext hooks require hmodule */
7320     SetLastError(0xdeadbeef);
7321     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
7322         0, win_event_proc, GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
7323     ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
7324     ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
7325        GetLastError() == 0xdeadbeef, /* Win9x */
7326        "unexpected error %d\n", GetLastError());
7327
7328     if (0)
7329     {
7330     /* these 3 tests don't pass under Win9x */
7331     SetLastError(0xdeadbeef);
7332     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(1, 0,
7333         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
7334     ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
7335     ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
7336
7337     SetLastError(0xdeadbeef);
7338     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(-1, 1,
7339         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
7340     ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
7341     ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
7342
7343     SetLastError(0xdeadbeef);
7344     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
7345         0, win_event_proc, 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
7346     ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
7347     ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %d\n", GetLastError());
7348     }
7349
7350     SetLastError(0xdeadbeef);
7351     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(0, 0,
7352         0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
7353     ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
7354     ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
7355     ret = pUnhookWinEvent(hwinevent_hook);
7356     ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7357
7358 todo_wine {
7359     /* This call succeeds under win2k SP4, but fails under Wine.
7360        Does win2k test/use passed process id? */
7361     SetLastError(0xdeadbeef);
7362     hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
7363         0, win_event_proc, 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
7364     ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
7365     ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
7366     ret = pUnhookWinEvent(hwinevent_hook);
7367     ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7368 }
7369
7370     SetLastError(0xdeadbeef);
7371     ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
7372     ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
7373         GetLastError() == 0xdeadbeef, /* Win9x */
7374         "unexpected error %d\n", GetLastError());
7375 }
7376
7377 static const struct message ScrollWindowPaint1[] = {
7378     { WM_PAINT, sent },
7379     { WM_ERASEBKGND, sent|beginpaint },
7380     { 0 }
7381 };
7382
7383 static const struct message ScrollWindowPaint2[] = {
7384     { WM_PAINT, sent },
7385     { 0 }
7386 };
7387
7388 static void test_scrollwindowex(void)
7389 {
7390     HWND hwnd, hchild;
7391     RECT rect={0,0,130,130};
7392
7393     hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
7394             WS_VISIBLE|WS_OVERLAPPEDWINDOW,
7395             100, 100, 200, 200, 0, 0, 0, NULL);
7396     ok (hwnd != 0, "Failed to create overlapped window\n");
7397     hchild = CreateWindowExA(0, "TestWindowClass", "Test child", 
7398             WS_VISIBLE|WS_CAPTION|WS_CHILD,
7399             10, 10, 150, 150, hwnd, 0, 0, NULL);
7400     ok (hchild != 0, "Failed to create child\n");
7401     UpdateWindow(hwnd);
7402     flush_events();
7403     flush_sequence();
7404
7405     /* scroll without the child window */
7406     trace("start scroll\n");
7407     ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
7408             SW_ERASE|SW_INVALIDATE);
7409     ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
7410     trace("end scroll\n");
7411     flush_sequence();
7412     flush_events();
7413     ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
7414     flush_events();
7415     flush_sequence();
7416
7417     /* Now without the SW_ERASE flag */
7418     trace("start scroll\n");
7419     ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
7420     ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
7421     trace("end scroll\n");
7422     flush_sequence();
7423     flush_events();
7424     ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", 0);
7425     flush_events();
7426     flush_sequence();
7427
7428     /* now scroll the child window as well */
7429     trace("start scroll\n");
7430     ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
7431             SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
7432     todo_wine { /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
7433                 /* windows sometimes a WM_MOVE */
7434         ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
7435     }
7436     trace("end scroll\n");
7437     flush_sequence();
7438     flush_events();
7439     ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
7440     flush_events();
7441     flush_sequence();
7442
7443     /* now scroll with ScrollWindow() */
7444     trace("start scroll with ScrollWindow\n");
7445     ScrollWindow( hwnd, 5, 5, NULL, NULL);
7446     trace("end scroll\n");
7447     flush_sequence();
7448     flush_events();
7449     ok_sequence(ScrollWindowPaint1, "ScrollWindow", 0);
7450
7451     ok(DestroyWindow(hchild), "failed to destroy window\n");
7452     ok(DestroyWindow(hwnd), "failed to destroy window\n");
7453     flush_sequence();
7454 }
7455
7456 static const struct message destroy_window_with_children[] = {
7457     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
7458     { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
7459     { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
7460     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
7461     { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
7462     { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
7463     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
7464     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
7465     { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
7466     { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
7467     { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
7468     { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
7469     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
7470     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
7471     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
7472     { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
7473     { 0 }
7474 };
7475
7476 static void test_DestroyWindow(void)
7477 {
7478     BOOL ret;
7479     HWND parent, child1, child2, child3, child4, test;
7480     UINT child_id = WND_CHILD_ID + 1;
7481
7482     parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
7483                              100, 100, 200, 200, 0, 0, 0, NULL);
7484     assert(parent != 0);
7485     child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
7486                              0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
7487     assert(child1 != 0);
7488     child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
7489                              0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
7490     assert(child2 != 0);
7491     child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
7492                              0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
7493     assert(child3 != 0);
7494     child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
7495                              0, 0, 50, 50, parent, 0, 0, NULL);
7496     assert(child4 != 0);
7497
7498     /* test owner/parent of child2 */
7499     test = GetParent(child2);
7500     ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
7501     ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
7502     if(pGetAncestor) {
7503         test = pGetAncestor(child2, GA_PARENT);
7504         ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
7505     }
7506     test = GetWindow(child2, GW_OWNER);
7507     ok(!test, "wrong owner %p\n", test);
7508
7509     test = SetParent(child2, parent);
7510     ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
7511
7512     /* test owner/parent of the parent */
7513     test = GetParent(parent);
7514     ok(!test, "wrong parent %p\n", test);
7515     ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
7516     if(pGetAncestor) {
7517         test = pGetAncestor(parent, GA_PARENT);
7518         ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
7519     }
7520     test = GetWindow(parent, GW_OWNER);
7521     ok(!test, "wrong owner %p\n", test);
7522
7523     /* test owner/parent of child1 */
7524     test = GetParent(child1);
7525     ok(test == parent, "wrong parent %p\n", test);
7526     ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
7527     if(pGetAncestor) {
7528         test = pGetAncestor(child1, GA_PARENT);
7529         ok(test == parent, "wrong parent %p\n", test);
7530     }
7531     test = GetWindow(child1, GW_OWNER);
7532     ok(!test, "wrong owner %p\n", test);
7533
7534     /* test owner/parent of child2 */
7535     test = GetParent(child2);
7536     ok(test == parent, "wrong parent %p\n", test);
7537     ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
7538     if(pGetAncestor) {
7539         test = pGetAncestor(child2, GA_PARENT);
7540         ok(test == parent, "wrong parent %p\n", test);
7541     }
7542     test = GetWindow(child2, GW_OWNER);
7543     ok(!test, "wrong owner %p\n", test);
7544
7545     /* test owner/parent of child3 */
7546     test = GetParent(child3);
7547     ok(test == child1, "wrong parent %p\n", test);
7548     ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
7549     if(pGetAncestor) {
7550         test = pGetAncestor(child3, GA_PARENT);
7551         ok(test == child1, "wrong parent %p\n", test);
7552     }
7553     test = GetWindow(child3, GW_OWNER);
7554     ok(!test, "wrong owner %p\n", test);
7555
7556     /* test owner/parent of child4 */
7557     test = GetParent(child4);
7558     ok(test == parent, "wrong parent %p\n", test);
7559     ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
7560     if(pGetAncestor) {
7561         test = pGetAncestor(child4, GA_PARENT);
7562         ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
7563     }
7564     test = GetWindow(child4, GW_OWNER);
7565     ok(test == parent, "wrong owner %p\n", test);
7566
7567     flush_sequence();
7568
7569     trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
7570            parent, child1, child2, child3, child4);
7571
7572     SetCapture(child4);
7573     test = GetCapture();
7574     ok(test == child4, "wrong capture window %p\n", test);
7575
7576     test_DestroyWindow_flag = TRUE;
7577     ret = DestroyWindow(parent);
7578     ok( ret, "DestroyWindow() error %d\n", GetLastError());
7579     test_DestroyWindow_flag = FALSE;
7580     ok_sequence(destroy_window_with_children, "destroy window with children", 0);
7581
7582     ok(!IsWindow(parent), "parent still exists\n");
7583     ok(!IsWindow(child1), "child1 still exists\n");
7584     ok(!IsWindow(child2), "child2 still exists\n");
7585     ok(!IsWindow(child3), "child3 still exists\n");
7586     ok(!IsWindow(child4), "child4 still exists\n");
7587
7588     test = GetCapture();
7589     ok(!test, "wrong capture window %p\n", test);
7590 }
7591
7592
7593 static const struct message WmDispatchPaint[] = {
7594     { WM_NCPAINT, sent },
7595     { WM_GETTEXT, sent|defwinproc|optional },
7596     { WM_GETTEXT, sent|defwinproc|optional },
7597     { WM_ERASEBKGND, sent },
7598     { 0 }
7599 };
7600
7601 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7602 {
7603     if (message == WM_PAINT) return 0;
7604     return MsgCheckProcA( hwnd, message, wParam, lParam );
7605 }
7606
7607 static void test_DispatchMessage(void)
7608 {
7609     RECT rect;
7610     MSG msg;
7611     int count;
7612     HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
7613                                100, 100, 200, 200, 0, 0, 0, NULL);
7614     ShowWindow( hwnd, SW_SHOW );
7615     UpdateWindow( hwnd );
7616     flush_events();
7617     flush_sequence();
7618     SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
7619
7620     SetRect( &rect, -5, -5, 5, 5 );
7621     RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
7622     count = 0;
7623     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
7624     {
7625         if (msg.message != WM_PAINT) DispatchMessage( &msg );
7626         else
7627         {
7628             flush_sequence();
7629             DispatchMessage( &msg );
7630             /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
7631             if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
7632             else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
7633             if (++count > 10) break;
7634         }
7635     }
7636     ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
7637
7638     trace("now without DispatchMessage\n");
7639     flush_sequence();
7640     RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
7641     count = 0;
7642     while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
7643     {
7644         if (msg.message != WM_PAINT) DispatchMessage( &msg );
7645         else
7646         {
7647             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
7648             flush_sequence();
7649             /* this will send WM_NCCPAINT just like DispatchMessage does */
7650             GetUpdateRgn( hwnd, hrgn, TRUE );
7651             ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
7652             DeleteObject( hrgn );
7653             GetClientRect( hwnd, &rect );
7654             ValidateRect( hwnd, &rect );  /* this will stop WM_PAINTs */
7655             ok( !count, "Got multiple WM_PAINTs\n" );
7656             if (++count > 10) break;
7657         }
7658     }
7659     DestroyWindow(hwnd);
7660 }
7661
7662
7663 static const struct message WmUser[] = {
7664     { WM_USER, sent },
7665     { 0 }
7666 };
7667
7668 struct sendmsg_info
7669 {
7670     HWND  hwnd;
7671     DWORD timeout;
7672     DWORD ret;
7673 };
7674
7675 static DWORD CALLBACK send_msg_thread( LPVOID arg )
7676 {
7677     struct sendmsg_info *info = arg;
7678     info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
7679     if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT, "unexpected error %d\n", GetLastError());
7680     return 0;
7681 }
7682
7683 static void wait_for_thread( HANDLE thread )
7684 {
7685     while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
7686     {
7687         MSG msg;
7688         while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage(&msg);
7689     }
7690 }
7691
7692 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7693 {
7694     if (message == WM_USER) Sleep(200);
7695     return MsgCheckProcA( hwnd, message, wParam, lParam );
7696 }
7697
7698 static void test_SendMessageTimeout(void)
7699 {
7700     HANDLE thread;
7701     struct sendmsg_info info;
7702     DWORD tid;
7703
7704     info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
7705                                100, 100, 200, 200, 0, 0, 0, NULL);
7706     flush_events();
7707     flush_sequence();
7708
7709     info.timeout = 1000;
7710     info.ret = 0xdeadbeef;
7711     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
7712     wait_for_thread( thread );
7713     CloseHandle( thread );
7714     ok( info.ret == 1, "SendMessageTimeout failed\n" );
7715     ok_sequence( WmUser, "WmUser", FALSE );
7716
7717     info.timeout = 1;
7718     info.ret = 0xdeadbeef;
7719     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
7720     Sleep(100);  /* SendMessageTimeout should timeout here */
7721     wait_for_thread( thread );
7722     CloseHandle( thread );
7723     ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
7724     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
7725
7726     /* 0 means infinite timeout */
7727     info.timeout = 0;
7728     info.ret = 0xdeadbeef;
7729     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
7730     Sleep(100);
7731     wait_for_thread( thread );
7732     CloseHandle( thread );
7733     ok( info.ret == 1, "SendMessageTimeout failed\n" );
7734     ok_sequence( WmUser, "WmUser", FALSE );
7735
7736     /* timeout is treated as signed despite the prototype */
7737     info.timeout = 0x7fffffff;
7738     info.ret = 0xdeadbeef;
7739     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
7740     Sleep(100);
7741     wait_for_thread( thread );
7742     CloseHandle( thread );
7743     ok( info.ret == 1, "SendMessageTimeout failed\n" );
7744     ok_sequence( WmUser, "WmUser", FALSE );
7745
7746     info.timeout = 0x80000000;
7747     info.ret = 0xdeadbeef;
7748     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
7749     Sleep(100);
7750     wait_for_thread( thread );
7751     CloseHandle( thread );
7752     ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
7753     ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
7754
7755     /* now check for timeout during message processing */
7756     SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
7757     info.timeout = 100;
7758     info.ret = 0xdeadbeef;
7759     thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
7760     wait_for_thread( thread );
7761     CloseHandle( thread );
7762     /* we should timeout but still get the message */
7763     ok( info.ret == 0, "SendMessageTimeout failed\n" );
7764     ok_sequence( WmUser, "WmUser", FALSE );
7765
7766     DestroyWindow( info.hwnd );
7767 }
7768
7769
7770 /****************** edit message test *************************/
7771 #define ID_EDIT 0x1234
7772 static const struct message sl_edit_setfocus[] =
7773 {
7774     { HCBT_SETFOCUS, hook },
7775     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
7776     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
7777     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
7778     { WM_SETFOCUS, sent|wparam, 0 },
7779     { WM_CTLCOLOREDIT, sent|parent },
7780     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7781     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7782     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
7783     { 0 }
7784 };
7785 static const struct message ml_edit_setfocus[] =
7786 {
7787     { HCBT_SETFOCUS, hook },
7788     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
7789     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
7790     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
7791     { WM_SETFOCUS, sent|wparam, 0 },
7792     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7793     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7794     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7795     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
7796     { 0 }
7797 };
7798 static const struct message sl_edit_killfocus[] =
7799 {
7800     { HCBT_SETFOCUS, hook },
7801     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
7802     { WM_KILLFOCUS, sent|wparam, 0 },
7803     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7804     { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7805     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
7806     { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
7807     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
7808     { 0 }
7809 };
7810 static const struct message sl_edit_lbutton_dblclk[] =
7811 {
7812     { WM_LBUTTONDBLCLK, sent },
7813     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7814     { 0 }
7815 };
7816 static const struct message sl_edit_lbutton_down[] =
7817 {
7818     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
7819     { HCBT_SETFOCUS, hook },
7820     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
7821     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
7822     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
7823     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
7824     { WM_CTLCOLOREDIT, sent|parent },
7825     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7826     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7827     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7828     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
7829     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7830     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7831     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7832     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7833     { 0 }
7834 };
7835 static const struct message ml_edit_lbutton_down[] =
7836 {
7837     { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
7838     { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
7839     { HCBT_SETFOCUS, hook },
7840     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
7841     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
7842     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
7843     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
7844     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7845     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7846     { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
7847     { 0 }
7848 };
7849 static const struct message sl_edit_lbutton_up[] =
7850 {
7851     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
7852     { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7853     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
7854     { WM_CAPTURECHANGED, sent|defwinproc },
7855     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
7856     { 0 }
7857 };
7858 static const struct message ml_edit_lbutton_up[] =
7859 {
7860     { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
7861     { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
7862     { WM_CAPTURECHANGED, sent|defwinproc },
7863     { 0 }
7864 };
7865
7866 static WNDPROC old_edit_proc;
7867
7868 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
7869 {
7870     static long defwndproc_counter = 0;
7871     LRESULT ret;
7872     struct message msg;
7873
7874     trace("edit: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
7875
7876     /* explicitly ignore WM_GETICON message */
7877     if (message == WM_GETICON) return 0;
7878
7879     msg.message = message;
7880     msg.flags = sent|wparam|lparam;
7881     if (defwndproc_counter) msg.flags |= defwinproc;
7882     msg.wParam = wParam;
7883     msg.lParam = lParam;
7884     add_message(&msg);
7885
7886     defwndproc_counter++;
7887     ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
7888     defwndproc_counter--;
7889
7890     return ret;
7891 }
7892
7893 static void subclass_edit(void)
7894 {
7895     WNDCLASSA cls;
7896
7897     if (!GetClassInfoA(0, "edit", &cls)) assert(0);
7898
7899     old_edit_proc = cls.lpfnWndProc;
7900
7901     cls.hInstance = GetModuleHandle(0);
7902     cls.lpfnWndProc = edit_hook_proc;
7903     cls.lpszClassName = "my_edit_class";
7904     UnregisterClass(cls.lpszClassName, cls.hInstance);
7905     if (!RegisterClassA(&cls)) assert(0);
7906 }
7907
7908 static void test_edit_messages(void)
7909 {
7910     HWND hwnd, parent;
7911     DWORD dlg_code;
7912
7913     subclass_edit();
7914     log_all_parent_messages++;
7915
7916     parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
7917                              100, 100, 200, 200, 0, 0, 0, NULL);
7918     ok (parent != 0, "Failed to create parent window\n");
7919
7920     /* test single line edit */
7921     hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
7922                            0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
7923     ok(hwnd != 0, "Failed to create edit window\n");
7924
7925     dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
7926     ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08x\n", dlg_code);
7927
7928     ShowWindow(hwnd, SW_SHOW);
7929     UpdateWindow(hwnd);
7930     SetFocus(0);
7931     flush_sequence();
7932
7933     SetFocus(hwnd);
7934     ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
7935
7936     SetFocus(0);
7937     ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
7938
7939     SetFocus(0);
7940     ReleaseCapture();
7941     flush_sequence();
7942
7943     SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
7944     ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
7945
7946     SetFocus(0);
7947     ReleaseCapture();
7948     flush_sequence();
7949
7950     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
7951     ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
7952
7953     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
7954     ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
7955
7956     DestroyWindow(hwnd);
7957
7958     /* test multiline edit */
7959     hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
7960                            0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
7961     ok(hwnd != 0, "Failed to create edit window\n");
7962
7963     dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
7964     ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
7965        "wrong dlg_code %08x\n", dlg_code);
7966
7967     ShowWindow(hwnd, SW_SHOW);
7968     UpdateWindow(hwnd);
7969     SetFocus(0);
7970     flush_sequence();
7971
7972     SetFocus(hwnd);
7973     ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
7974
7975     SetFocus(0);
7976     ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
7977
7978     SetFocus(0);
7979     ReleaseCapture();
7980     flush_sequence();
7981
7982     SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
7983     ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
7984
7985     SetFocus(0);
7986     ReleaseCapture();
7987     flush_sequence();
7988
7989     SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
7990     ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
7991
7992     SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
7993     ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
7994
7995     DestroyWindow(hwnd);
7996     DestroyWindow(parent);
7997
7998     log_all_parent_messages--;
7999 }
8000
8001 /**************************** End of Edit test ******************************/
8002
8003 static const struct message WmKeyDownSkippedSeq[] =
8004 {
8005     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
8006     { 0 }
8007 };
8008 static const struct message WmKeyUpSkippedSeq[] =
8009 {
8010     { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
8011     { 0 }
8012 };
8013
8014 #define EV_START_STOP 0
8015 #define EV_SENDMSG 1
8016 #define EV_ACK 2
8017
8018 struct peekmsg_info
8019 {
8020     HWND  hwnd;
8021     HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
8022 };
8023
8024 static DWORD CALLBACK send_msg_thread_2(void *param)
8025 {
8026     DWORD ret;
8027     struct peekmsg_info *info = param;
8028
8029     trace("thread: waiting for start\n");
8030     WaitForSingleObject(info->hevent[EV_START_STOP], INFINITE);
8031     trace("thread: looping\n");
8032
8033     while (1)
8034     {
8035         ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
8036
8037         switch (ret)
8038         {
8039         case WAIT_OBJECT_0 + EV_START_STOP:
8040             trace("thread: exiting\n");
8041             return 0;
8042
8043         case WAIT_OBJECT_0 + EV_SENDMSG:
8044             trace("thread: sending message\n");
8045             SendNotifyMessageA(info->hwnd, WM_USER, 0, 0);
8046             SetEvent(info->hevent[EV_ACK]);
8047             break;
8048
8049         default:
8050             trace("unexpected return: %04x\n", ret);
8051             assert(0);
8052             break;
8053         }
8054     }
8055     return 0;
8056 }
8057
8058 static void test_PeekMessage(void)
8059 {
8060     MSG msg;
8061     HANDLE hthread;
8062     DWORD tid, qstatus;
8063     UINT qs_all_input = QS_ALLINPUT;
8064     UINT qs_input = QS_INPUT;
8065     BOOL ret;
8066     struct peekmsg_info info;
8067
8068     info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8069                               100, 100, 200, 200, 0, 0, 0, NULL);
8070     assert(info.hwnd);
8071     ShowWindow(info.hwnd, SW_SHOW);
8072     UpdateWindow(info.hwnd);
8073     SetFocus(info.hwnd);
8074
8075     info.hevent[EV_START_STOP] = CreateEventA(NULL, 0, 0, NULL);
8076     info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
8077     info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
8078
8079     hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
8080     Sleep(100);
8081
8082     trace("signalling to start looping\n");
8083     SetEvent(info.hevent[EV_START_STOP]);
8084
8085     flush_events();
8086     flush_sequence();
8087
8088     SetLastError(0xdeadbeef);
8089     qstatus = GetQueueStatus(qs_all_input);
8090     if (GetLastError() == ERROR_INVALID_FLAGS)
8091     {
8092         trace("QS_RAWINPUT not supported on this platform\n");
8093         qs_all_input &= ~QS_RAWINPUT;
8094         qs_input &= ~QS_RAWINPUT;
8095     }
8096     ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
8097
8098     trace("signalling to send message\n");
8099     SetEvent(info.hevent[EV_SENDMSG]);
8100     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8101
8102     /* pass invalid QS_xxxx flags */
8103     SetLastError(0xdeadbeef);
8104     qstatus = GetQueueStatus(0xffffffff);
8105     ok(qstatus == 0, "GetQueueStatus should fail: %08x\n", qstatus);
8106     ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %d\n", GetLastError());
8107
8108     qstatus = GetQueueStatus(qs_all_input);
8109     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
8110        "wrong qstatus %08x\n", qstatus);
8111
8112     msg.message = 0;
8113     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8114     ok(!ret,
8115        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8116         msg.message);
8117     ok_sequence(WmUser, "WmUser", FALSE);
8118
8119     qstatus = GetQueueStatus(qs_all_input);
8120     ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
8121
8122     keybd_event('N', 0, 0, 0);
8123     keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
8124     qstatus = GetQueueStatus(qs_all_input);
8125     ok(qstatus == MAKELONG(QS_KEY, QS_KEY),
8126        "wrong qstatus %08x\n", qstatus);
8127
8128     PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8129     qstatus = GetQueueStatus(qs_all_input);
8130     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
8131        "wrong qstatus %08x\n", qstatus);
8132
8133     InvalidateRect(info.hwnd, NULL, FALSE);
8134     qstatus = GetQueueStatus(qs_all_input);
8135     ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8136        "wrong qstatus %08x\n", qstatus);
8137
8138     trace("signalling to send message\n");
8139     SetEvent(info.hevent[EV_SENDMSG]);
8140     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8141
8142     qstatus = GetQueueStatus(qs_all_input);
8143     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8144        "wrong qstatus %08x\n", qstatus);
8145
8146     msg.message = 0;
8147     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
8148     ok(!ret,
8149        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8150         msg.message);
8151     ok_sequence(WmUser, "WmUser", FALSE);
8152
8153     qstatus = GetQueueStatus(qs_all_input);
8154     ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8155        "wrong qstatus %08x\n", qstatus);
8156
8157     trace("signalling to send message\n");
8158     SetEvent(info.hevent[EV_SENDMSG]);
8159     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8160
8161     qstatus = GetQueueStatus(qs_all_input);
8162     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8163        "wrong qstatus %08x\n", qstatus);
8164
8165     msg.message = 0;
8166     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
8167     ok(!ret,
8168        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8169         msg.message);
8170     ok_sequence(WmUser, "WmUser", FALSE);
8171
8172     qstatus = GetQueueStatus(qs_all_input);
8173     ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8174        "wrong qstatus %08x\n", qstatus);
8175
8176     msg.message = 0;
8177     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
8178     ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
8179        "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
8180        ret, msg.message, msg.wParam);
8181     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8182
8183     qstatus = GetQueueStatus(qs_all_input);
8184     ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
8185        "wrong qstatus %08x\n", qstatus);
8186
8187     msg.message = 0;
8188     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
8189     ok(!ret,
8190        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8191         msg.message);
8192     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8193
8194     qstatus = GetQueueStatus(qs_all_input);
8195     ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
8196        "wrong qstatus %08x\n", qstatus);
8197
8198     msg.message = 0;
8199     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
8200     ok(ret && msg.message == WM_PAINT,
8201        "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
8202     DispatchMessageA(&msg);
8203     ok_sequence(WmPaint, "WmPaint", FALSE);
8204
8205     qstatus = GetQueueStatus(qs_all_input);
8206     ok(qstatus == MAKELONG(0, QS_KEY),
8207        "wrong qstatus %08x\n", qstatus);
8208
8209     msg.message = 0;
8210     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
8211     ok(!ret,
8212        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8213         msg.message);
8214     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8215
8216     qstatus = GetQueueStatus(qs_all_input);
8217     ok(qstatus == MAKELONG(0, QS_KEY),
8218        "wrong qstatus %08x\n", qstatus);
8219
8220     trace("signalling to send message\n");
8221     SetEvent(info.hevent[EV_SENDMSG]);
8222     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8223
8224     qstatus = GetQueueStatus(qs_all_input);
8225     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
8226        "wrong qstatus %08x\n", qstatus);
8227
8228     PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8229
8230     qstatus = GetQueueStatus(qs_all_input);
8231     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
8232        "wrong qstatus %08x\n", qstatus);
8233
8234     msg.message = 0;
8235     ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
8236     ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
8237        "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
8238        ret, msg.message, msg.wParam);
8239     ok_sequence(WmUser, "WmUser", FALSE);
8240
8241     qstatus = GetQueueStatus(qs_all_input);
8242     ok(qstatus == MAKELONG(0, QS_KEY),
8243        "wrong qstatus %08x\n", qstatus);
8244
8245     msg.message = 0;
8246     ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
8247     ok(!ret,
8248        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8249         msg.message);
8250     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8251
8252     qstatus = GetQueueStatus(qs_all_input);
8253     ok(qstatus == MAKELONG(0, QS_KEY),
8254        "wrong qstatus %08x\n", qstatus);
8255
8256     PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8257
8258     qstatus = GetQueueStatus(qs_all_input);
8259     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
8260        "wrong qstatus %08x\n", qstatus);
8261
8262     trace("signalling to send message\n");
8263     SetEvent(info.hevent[EV_SENDMSG]);
8264     WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8265
8266     qstatus = GetQueueStatus(qs_all_input);
8267     ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
8268        "wrong qstatus %08x\n", qstatus);
8269
8270     msg.message = 0;
8271     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
8272     ok(!ret,
8273        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8274         msg.message);
8275     ok_sequence(WmUser, "WmUser", FALSE);
8276
8277     qstatus = GetQueueStatus(qs_all_input);
8278     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
8279        "wrong qstatus %08x\n", qstatus);
8280
8281     msg.message = 0;
8282     if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
8283         ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
8284     else /* workaround for a missing QS_RAWINPUT support */
8285         ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
8286     ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
8287        "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
8288        ret, msg.message, msg.wParam);
8289     ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
8290
8291     qstatus = GetQueueStatus(qs_all_input);
8292     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
8293        "wrong qstatus %08x\n", qstatus);
8294
8295     msg.message = 0;
8296     if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
8297         ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
8298     else /* workaround for a missing QS_RAWINPUT support */
8299         ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
8300     ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
8301        "got %d and %04x wParam %08lx instead of TRUE and WM_KEYUP wParam 'N'\n",
8302        ret, msg.message, msg.wParam);
8303     ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
8304
8305     qstatus = GetQueueStatus(qs_all_input);
8306     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
8307        "wrong qstatus %08x\n", qstatus);
8308
8309     msg.message = 0;
8310     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
8311     ok(!ret,
8312        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8313         msg.message);
8314     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8315
8316     qstatus = GetQueueStatus(qs_all_input);
8317     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
8318        "wrong qstatus %08x\n", qstatus);
8319
8320     msg.message = 0;
8321     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8322     ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
8323        "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
8324        ret, msg.message, msg.wParam);
8325     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8326
8327     qstatus = GetQueueStatus(qs_all_input);
8328     ok(qstatus == 0,
8329        "wrong qstatus %08x\n", qstatus);
8330
8331     msg.message = 0;
8332     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8333     ok(!ret,
8334        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8335         msg.message);
8336     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8337
8338     qstatus = GetQueueStatus(qs_all_input);
8339     ok(qstatus == 0,
8340        "wrong qstatus %08x\n", qstatus);
8341
8342     /* test whether presence of the quit flag in the queue affects
8343      * the queue state
8344      */
8345     PostQuitMessage(0x1234abcd);
8346
8347     qstatus = GetQueueStatus(qs_all_input);
8348     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
8349        "wrong qstatus %08x\n", qstatus);
8350
8351     PostMessageA(info.hwnd, WM_USER, 0, 0);
8352
8353     qstatus = GetQueueStatus(qs_all_input);
8354     ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
8355        "wrong qstatus %08x\n", qstatus);
8356
8357     msg.message = 0;
8358     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8359     ok(ret && msg.message == WM_USER,
8360        "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
8361     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8362
8363     qstatus = GetQueueStatus(qs_all_input);
8364     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
8365        "wrong qstatus %08x\n", qstatus);
8366
8367     msg.message = 0;
8368     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8369     ok(ret && msg.message == WM_QUIT,
8370        "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
8371     ok(msg.wParam == 0x1234abcd, "got wParam %08lx instead of 0x1234abcd\n", msg.wParam);
8372     ok(msg.lParam == 0, "got lParam %08lx instead of 0\n", msg.lParam);
8373     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8374
8375     qstatus = GetQueueStatus(qs_all_input);
8376 todo_wine {
8377     ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
8378        "wrong qstatus %08x\n", qstatus);
8379 }
8380
8381     msg.message = 0;
8382     ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8383     ok(!ret,
8384        "PeekMessageA should have returned FALSE instead of msg %04x\n",
8385         msg.message);
8386     ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8387
8388     qstatus = GetQueueStatus(qs_all_input);
8389     ok(qstatus == 0,
8390        "wrong qstatus %08x\n", qstatus);
8391
8392     trace("signalling to exit\n");
8393     SetEvent(info.hevent[EV_START_STOP]);
8394
8395     WaitForSingleObject(hthread, INFINITE);
8396
8397     CloseHandle(hthread);
8398     CloseHandle(info.hevent[0]);
8399     CloseHandle(info.hevent[1]);
8400     CloseHandle(info.hevent[2]);
8401
8402     DestroyWindow(info.hwnd);
8403 }
8404
8405
8406 static void test_quit_message(void)
8407 {
8408     MSG msg;
8409     BOOL ret;
8410
8411     /* test using PostQuitMessage */
8412     PostQuitMessage(0xbeef);
8413
8414     ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
8415     ok(ret, "PeekMessage failed with error %d\n", GetLastError());
8416     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
8417     ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
8418
8419     ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
8420     ok(ret, "PostMessage failed with error %d\n", GetLastError());
8421
8422     ret = GetMessage(&msg, NULL, 0, 0);
8423     ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
8424     ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
8425
8426     /* note: WM_QUIT message received after WM_USER message */
8427     ret = GetMessage(&msg, NULL, 0, 0);
8428     ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
8429     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
8430     ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
8431
8432     ret = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
8433     ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
8434
8435     /* now test with PostThreadMessage - different behaviour! */
8436     PostThreadMessage(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
8437
8438     ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
8439     ok(ret, "PeekMessage failed with error %d\n", GetLastError());
8440     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
8441     ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
8442
8443     ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
8444     ok(ret, "PostMessage failed with error %d\n", GetLastError());
8445
8446     /* note: we receive the WM_QUIT message first this time */
8447     ret = GetMessage(&msg, NULL, 0, 0);
8448     ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
8449     ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
8450     ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
8451
8452     ret = GetMessage(&msg, NULL, 0, 0);
8453     ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
8454     ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
8455 }
8456
8457 static const struct message WmMouseHoverSeq[] = {
8458     { WM_MOUSEACTIVATE, sent|optional },  /* we can get those when moving the mouse in focus-follow-mouse mode under X11 */
8459     { WM_MOUSEACTIVATE, sent|optional },
8460     { WM_TIMER, sent|optional }, /* XP sends it */
8461     { WM_SYSTIMER, sent },
8462     { WM_MOUSEHOVER, sent|wparam, 0 },
8463     { 0 }
8464 };
8465
8466 static void pump_msg_loop_timeout(DWORD timeout, BOOL inject_mouse_move)
8467 {
8468     MSG msg;
8469     DWORD start_ticks, end_ticks;
8470
8471     start_ticks = GetTickCount();
8472     /* add some deviation (5%) to cover not expected delays */
8473     start_ticks += timeout / 20;
8474
8475     do
8476     {
8477         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
8478         {
8479             /* Timer proc messages are not dispatched to the window proc,
8480              * and therefore not logged.
8481              */
8482             if (msg.message == WM_TIMER || msg.message == WM_SYSTIMER)
8483             {
8484                 struct message s_msg;
8485
8486                 s_msg.message = msg.message;
8487                 s_msg.flags = sent|wparam|lparam;
8488                 s_msg.wParam = msg.wParam;
8489                 s_msg.lParam = msg.lParam;
8490                 add_message(&s_msg);
8491             }
8492             DispatchMessage(&msg);
8493         }
8494
8495         end_ticks = GetTickCount();
8496
8497         /* inject WM_MOUSEMOVE to see how it changes tracking */
8498         if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
8499         {
8500             mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
8501             mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
8502
8503             inject_mouse_move = FALSE;
8504         }
8505     } while (start_ticks + timeout >= end_ticks);
8506 }
8507
8508 static void test_TrackMouseEvent(void)
8509 {
8510     TRACKMOUSEEVENT tme;
8511     BOOL ret;
8512     HWND hwnd, hchild;
8513     RECT rc_parent, rc_child;
8514     UINT default_hover_time, hover_width = 0, hover_height = 0;
8515
8516 #define track_hover(track_hwnd, track_hover_time) \
8517     tme.cbSize = sizeof(tme); \
8518     tme.dwFlags = TME_HOVER; \
8519     tme.hwndTrack = track_hwnd; \
8520     tme.dwHoverTime = track_hover_time; \
8521     SetLastError(0xdeadbeef); \
8522     ret = pTrackMouseEvent(&tme); \
8523     ok(ret, "TrackMouseEvent(TME_HOVER) error %d\n", GetLastError())
8524
8525 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
8526     tme.cbSize = sizeof(tme); \
8527     tme.dwFlags = TME_QUERY; \
8528     tme.hwndTrack = (HWND)0xdeadbeef; \
8529     tme.dwHoverTime = 0xdeadbeef; \
8530     SetLastError(0xdeadbeef); \
8531     ret = pTrackMouseEvent(&tme); \
8532     ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());\
8533     ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize); \
8534     ok(tme.dwFlags == (expected_track_flags), \
8535        "wrong tme.dwFlags %08x, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
8536     ok(tme.hwndTrack == (expected_track_hwnd), \
8537        "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
8538     ok(tme.dwHoverTime == (expected_hover_time), \
8539        "wrong tme.dwHoverTime %u, expected %u\n", tme.dwHoverTime, (expected_hover_time))
8540
8541 #define track_hover_cancel(track_hwnd) \
8542     tme.cbSize = sizeof(tme); \
8543     tme.dwFlags = TME_HOVER | TME_CANCEL; \
8544     tme.hwndTrack = track_hwnd; \
8545     tme.dwHoverTime = 0xdeadbeef; \
8546     SetLastError(0xdeadbeef); \
8547     ret = pTrackMouseEvent(&tme); \
8548     ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %d\n", GetLastError())
8549
8550     default_hover_time = 0xdeadbeef;
8551     SetLastError(0xdeadbeef);
8552     ret = SystemParametersInfo(SPI_GETMOUSEHOVERTIME, 0, &default_hover_time, 0);
8553     ok(ret, "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %u\n", GetLastError());
8554     if (!ret) default_hover_time = 400;
8555     trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time);
8556
8557     SetLastError(0xdeadbeef);
8558     ret = SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0);
8559     ok(ret, "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %u\n", GetLastError());
8560     if (!ret) hover_width = 4;
8561     SetLastError(0xdeadbeef);
8562     ret = SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0);
8563     ok(ret, "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %u\n", GetLastError());
8564     if (!ret) hover_height = 4;
8565     trace("hover rect is %u x %d\n", hover_width, hover_height);
8566
8567     hwnd = CreateWindowEx(0, "TestWindowClass", NULL,
8568                           WS_OVERLAPPEDWINDOW | WS_VISIBLE,
8569                           CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
8570                           NULL, NULL, 0);
8571     assert(hwnd);
8572
8573     hchild = CreateWindowEx(0, "TestWindowClass", NULL,
8574                           WS_CHILD | WS_BORDER | WS_VISIBLE,
8575                           50, 50, 200, 200, hwnd,
8576                           NULL, NULL, 0);
8577     assert(hchild);
8578
8579     flush_events();
8580     flush_sequence();
8581
8582     tme.cbSize = 0;
8583     tme.dwFlags = TME_QUERY;
8584     tme.hwndTrack = (HWND)0xdeadbeef;
8585     tme.dwHoverTime = 0xdeadbeef;
8586     SetLastError(0xdeadbeef);
8587     ret = pTrackMouseEvent(&tme);
8588     ok(!ret, "TrackMouseEvent should fail\n");
8589     ok(GetLastError() == ERROR_INVALID_PARAMETER, "not expected error %d\n", GetLastError());
8590
8591     tme.cbSize = sizeof(tme);
8592     tme.dwFlags = TME_HOVER;
8593     tme.hwndTrack = (HWND)0xdeadbeef;
8594     tme.dwHoverTime = 0xdeadbeef;
8595     SetLastError(0xdeadbeef);
8596     ret = pTrackMouseEvent(&tme);
8597     ok(!ret, "TrackMouseEvent should fail\n");
8598     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "not expected error %d\n", GetLastError());
8599
8600     tme.cbSize = sizeof(tme);
8601     tme.dwFlags = TME_HOVER | TME_CANCEL;
8602     tme.hwndTrack = (HWND)0xdeadbeef;
8603     tme.dwHoverTime = 0xdeadbeef;
8604     SetLastError(0xdeadbeef);
8605     ret = pTrackMouseEvent(&tme);
8606     ok(!ret, "TrackMouseEvent should fail\n");
8607     ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "not expected error %d\n", GetLastError());
8608
8609     GetWindowRect(hwnd, &rc_parent);
8610     GetWindowRect(hchild, &rc_child);
8611     SetCursorPos(rc_child.left - 10, rc_child.top - 10);
8612
8613     /* Process messages so that the system updates its internal current
8614      * window and hittest, otherwise TrackMouseEvent calls don't have any
8615      * effect.
8616      */
8617     flush_events();
8618     flush_sequence();
8619
8620     track_query(0, NULL, 0);
8621     track_hover(hchild, 0);
8622     track_query(0, NULL, 0);
8623
8624     flush_events();
8625     flush_sequence();
8626
8627     track_hover(hwnd, 0);
8628     track_query(TME_HOVER, hwnd, default_hover_time);
8629
8630     pump_msg_loop_timeout(default_hover_time, FALSE);
8631     ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
8632
8633     track_query(0, NULL, 0);
8634
8635     track_hover(hwnd, HOVER_DEFAULT);
8636     track_query(TME_HOVER, hwnd, default_hover_time);
8637
8638     Sleep(default_hover_time / 2);
8639     mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
8640     mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
8641
8642     track_query(TME_HOVER, hwnd, default_hover_time);
8643
8644     pump_msg_loop_timeout(default_hover_time / 2, FALSE);
8645     ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
8646
8647     track_query(0, NULL, 0);
8648
8649     track_hover(hwnd, HOVER_DEFAULT);
8650     track_query(TME_HOVER, hwnd, default_hover_time);
8651
8652     pump_msg_loop_timeout(default_hover_time, TRUE);
8653     ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
8654
8655     track_query(0, NULL, 0);
8656
8657     track_hover(hwnd, HOVER_DEFAULT);
8658     track_query(TME_HOVER, hwnd, default_hover_time);
8659     track_hover_cancel(hwnd);
8660
8661     DestroyWindow(hwnd);
8662
8663 #undef track_hover
8664 #undef track_query
8665 #undef track_hover_cancel
8666 }
8667
8668
8669 static const struct message WmSetWindowRgn[] = {
8670     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
8671     { WM_NCCALCSIZE, sent|wparam, 1 },
8672     { WM_NCPAINT, sent }, /* wparam != 1 */
8673     { WM_GETTEXT, sent|defwinproc|optional },
8674     { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
8675     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
8676     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
8677     { 0 }
8678 };
8679
8680 static const struct message WmSetWindowRgn_no_redraw[] = {
8681     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
8682     { WM_NCCALCSIZE, sent|wparam, 1 },
8683     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
8684     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
8685     { 0 }
8686 };
8687
8688 static const struct message WmSetWindowRgn_clear[] = {
8689     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE }, /* some versions of 2000/XP also has SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE in wparam */
8690     { WM_NCCALCSIZE, sent|wparam, 1 },
8691     { WM_NCPAINT, sent }, /* wparam != 1 */
8692     { WM_GETTEXT, sent|defwinproc|optional },
8693     { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
8694     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
8695     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
8696     { WM_NCPAINT, sent|optional }, /* wparam != 1 */
8697     { WM_GETTEXT, sent|defwinproc|optional },
8698     { WM_ERASEBKGND, sent|optional },
8699     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
8700     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
8701     { 0 }
8702 };
8703
8704 static void test_SetWindowRgn(void)
8705 {
8706     HRGN hrgn;
8707     HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
8708                                 100, 100, 200, 200, 0, 0, 0, NULL);
8709     ok( hwnd != 0, "Failed to create overlapped window\n" );
8710
8711     ShowWindow( hwnd, SW_SHOW );
8712     UpdateWindow( hwnd );
8713     flush_events();
8714     flush_sequence();
8715
8716     trace("testing SetWindowRgn\n");
8717     hrgn = CreateRectRgn( 0, 0, 150, 150 );
8718     SetWindowRgn( hwnd, hrgn, TRUE );
8719     ok_sequence( WmSetWindowRgn, "WmSetWindowRgn", FALSE );
8720
8721     hrgn = CreateRectRgn( 30, 30, 160, 160 );
8722     SetWindowRgn( hwnd, hrgn, FALSE );
8723     ok_sequence( WmSetWindowRgn_no_redraw, "WmSetWindowRgn_no_redraw", FALSE );
8724
8725     hrgn = CreateRectRgn( 0, 0, 180, 180 );
8726     SetWindowRgn( hwnd, hrgn, TRUE );
8727     ok_sequence( WmSetWindowRgn, "WmSetWindowRgn2", FALSE );
8728
8729     SetWindowRgn( hwnd, 0, TRUE );
8730     ok_sequence( WmSetWindowRgn_clear, "WmSetWindowRgn_clear", FALSE );
8731
8732     DestroyWindow( hwnd );
8733 }
8734
8735 /*************************** ShowWindow() test ******************************/
8736 static const struct message WmShowNormal[] = {
8737     { WM_SHOWWINDOW, sent|wparam, 1 },
8738     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
8739     { HCBT_ACTIVATE, hook },
8740     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
8741     { HCBT_SETFOCUS, hook },
8742     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8743     { 0 }
8744 };
8745 static const struct message WmShow[] = {
8746     { WM_SHOWWINDOW, sent|wparam, 1 },
8747     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
8748     { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
8749     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
8750     { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
8751     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8752     { 0 }
8753 };
8754 static const struct message WmShowNoActivate_1[] = {
8755     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
8756     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000 },
8757     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|0x8000 },
8758     { WM_MOVE, sent|defwinproc },
8759     { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
8760     { 0 }
8761 };
8762 static const struct message WmShowNoActivate_2[] = {
8763     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
8764     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8765     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8766     { WM_MOVE, sent|defwinproc },
8767     { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
8768     { HCBT_SETFOCUS, hook },
8769     { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
8770     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
8771     { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
8772     { 0 }
8773 };
8774 static const struct message WmShowNA_1[] = {
8775     { WM_SHOWWINDOW, sent|wparam, 1 },
8776     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
8777     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8778     { 0 }
8779 };
8780 static const struct message WmShowNA_2[] = {
8781     { WM_SHOWWINDOW, sent|wparam, 1 },
8782     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
8783     { 0 }
8784 };
8785 static const struct message WmRestore_1[] = {
8786     { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
8787     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8788     { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
8789     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
8790     { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
8791     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8792     { WM_MOVE, sent|defwinproc },
8793     { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
8794     { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
8795     { 0 }
8796 };
8797 static const struct message WmRestore_2[] = {
8798     { WM_SHOWWINDOW, sent|wparam, 1 },
8799     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
8800     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8801     { 0 }
8802 };
8803 static const struct message WmRestore_3[] = {
8804     { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
8805     { WM_GETMINMAXINFO, sent },
8806     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8807     { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
8808     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
8809     { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
8810     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8811     { WM_MOVE, sent|defwinproc },
8812     { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
8813     { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
8814     { 0 }
8815 };
8816 static const struct message WmRestore_4[] = {
8817     { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
8818     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
8819     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|0x8000 },
8820     { WM_MOVE, sent|defwinproc },
8821     { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
8822     { 0 }
8823 };
8824 static const struct message WmRestore_5[] = {
8825     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
8826     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
8827     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|0x8000 },
8828     { WM_MOVE, sent|defwinproc },
8829     { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
8830     { 0 }
8831 };
8832 static const struct message WmHide_1[] = {
8833     { WM_SHOWWINDOW, sent|wparam, 0 },
8834     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
8835     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8836     { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
8837     { 0 }
8838 };
8839 static const struct message WmHide_2[] = {
8840     { WM_SHOWWINDOW, sent|wparam, 0 },
8841     { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
8842     { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
8843     { 0 }
8844 };
8845 static const struct message WmHide_3[] = {
8846     { WM_SHOWWINDOW, sent|wparam, 0 },
8847     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
8848     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8849     { HCBT_SETFOCUS, hook },
8850     { 0 }
8851 };
8852 static const struct message WmShowMinimized_1[] = {
8853     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
8854     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8855     { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
8856     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
8857     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8858     { WM_MOVE, sent|defwinproc },
8859     { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
8860     { 0 }
8861 };
8862 static const struct message WmMinimize_1[] = {
8863     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
8864     { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
8865     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8866     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8867     { WM_MOVE, sent|defwinproc },
8868     { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
8869     { 0 }
8870 };
8871 static const struct message WmMinimize_2[] = {
8872     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
8873     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8874     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8875     { WM_MOVE, sent|defwinproc },
8876     { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
8877     { 0 }
8878 };
8879 static const struct message WmMinimize_3[] = {
8880     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
8881     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8882     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8883     { WM_MOVE, sent|defwinproc },
8884     { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
8885     { 0 }
8886 };
8887 static const struct message WmShowMinNoActivate[] = {
8888     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
8889     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
8890     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8891     { 0 }
8892 };
8893 static const struct message WmMinMax_1[] = {
8894     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
8895     { 0 }
8896 };
8897 static const struct message WmMinMax_2[] = {
8898     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
8899     { 0 }
8900 };
8901 static const struct message WmMinMax_3[] = {
8902     { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
8903     { 0 }
8904 };
8905 static const struct message WmMinMax_4[] = {
8906     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
8907     { 0 }
8908 };
8909 static const struct message WmShowMaximized_1[] = {
8910     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
8911     { WM_GETMINMAXINFO, sent },
8912     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8913     { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
8914     { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
8915     { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
8916     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8917     { WM_MOVE, sent|defwinproc },
8918     { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
8919     { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
8920     { 0 }
8921 };
8922 static const struct message WmShowMaximized_2[] = {
8923     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
8924     { WM_GETMINMAXINFO, sent },
8925     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
8926     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
8927     { WM_MOVE, sent|optional }, /* Win9x doesn't send it */
8928     { WM_SIZE, sent|wparam|optional, SIZE_MAXIMIZED }, /* Win9x doesn't send it */
8929     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8930     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|0x8000 },
8931     { WM_MOVE, sent|defwinproc },
8932     { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
8933     { HCBT_SETFOCUS, hook },
8934     { 0 }
8935 };
8936 static const struct message WmShowMaximized_3[] = {
8937     { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
8938     { WM_GETMINMAXINFO, sent },
8939     { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|0x8000 },
8940     { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|0x8000 },
8941     { WM_MOVE, sent|defwinproc },
8942     { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
8943     { 0 }
8944 };
8945
8946 static void test_ShowWindow(void)
8947 {
8948     /* ShowWindow commands in random order */
8949     static const struct
8950     {
8951         INT cmd; /* ShowWindow command */
8952         LPARAM ret; /* ShowWindow return value */
8953         DWORD style; /* window style after the command */
8954         const struct message *msg; /* message sequence the command produces */
8955         BOOL todo_msg; /* message sequence doesn't match what Wine does */
8956     } sw[] =
8957     {
8958 /*  1 */ { SW_SHOWNORMAL, FALSE, WS_VISIBLE, WmShowNormal, FALSE },
8959 /*  2 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
8960 /*  3 */ { SW_HIDE, TRUE, 0, WmHide_1, FALSE },
8961 /*  4 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
8962 /*  5 */ { SW_SHOWMINIMIZED, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinimized_1, FALSE },
8963 /*  6 */ { SW_SHOWMINIMIZED, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_1, FALSE },
8964 /*  7 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_1, FALSE },
8965 /*  8 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
8966 /*  9 */ { SW_SHOWMAXIMIZED, FALSE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_1, FALSE },
8967 /* 10 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2, FALSE },
8968 /* 11 */ { SW_HIDE, TRUE, WS_MAXIMIZE, WmHide_1, FALSE },
8969 /* 12 */ { SW_HIDE, FALSE, WS_MAXIMIZE, WmEmptySeq, FALSE },
8970 /* 13 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_1, FALSE },
8971 /* 14 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
8972 /* 15 */ { SW_HIDE, TRUE, 0, WmHide_2, FALSE },
8973 /* 16 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
8974 /* 17 */ { SW_SHOW, FALSE, WS_VISIBLE, WmShow, FALSE },
8975 /* 18 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
8976 /* 19 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1, TRUE },
8977 /* 20 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
8978 /* 21 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
8979 /* 22 */ { SW_SHOWMINNOACTIVE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinNoActivate, TRUE },
8980 /* 23 */ { SW_SHOWMINNOACTIVE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_4, FALSE },
8981 /* 24 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
8982 /* 25 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
8983 /* 26 */ { SW_SHOWNA, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_1, FALSE },
8984 /* 27 */ { SW_SHOWNA, TRUE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_2, FALSE },
8985 /* 28 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
8986 /* 29 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
8987 /* 30 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_1, FALSE },
8988 /* 31 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
8989 /* 32 */ { SW_HIDE, TRUE, 0, WmHide_3, TRUE },
8990 /* 33 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
8991 /* 34 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, TRUE }, /* what does this mean?! */
8992 /* 35 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, TRUE },
8993 /* 36 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
8994 /* 37 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_2, FALSE },
8995 /* 38 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
8996 /* 39 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
8997 /* 40 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_2, TRUE },
8998 /* 41 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
8999 /* 42 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_2, TRUE },
9000 /* 43 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2, FALSE },
9001 /* 44 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1, TRUE },
9002 /* 45 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
9003 /* 46 */ { SW_RESTORE, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmRestore_3, FALSE },
9004 /* 47 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmRestore_4, FALSE },
9005 /* 48 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_3, FALSE },
9006 /* 49 */ { SW_SHOW, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmEmptySeq, FALSE },
9007 /* 50 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5, FALSE },
9008 /* 51 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9009 /* 52 */ { SW_HIDE, TRUE, 0, WmHide_1, FALSE },
9010 /* 53 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
9011 /* 54 */ { SW_MINIMIZE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_3, TRUE },
9012 /* 55 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
9013 /* 56 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_2, FALSE },
9014 /* 57 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq, FALSE }
9015     };
9016     HWND hwnd;
9017     DWORD style;
9018     LPARAM ret;
9019     INT i;
9020
9021 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
9022     hwnd = CreateWindowEx(0, "ShowWindowClass", NULL, WS_BASE,
9023                           120, 120, 90, 90,
9024                           0, 0, 0, NULL);
9025     assert(hwnd);
9026
9027     style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_BASE;
9028     ok(style == 0, "expected style 0, got %08x\n", style);
9029
9030     flush_events();
9031     flush_sequence();
9032
9033     for (i = 0; i < sizeof(sw)/sizeof(sw[0]); i++)
9034     {
9035         static const char * const sw_cmd_name[13] =
9036         {
9037             "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
9038             "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
9039             "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
9040             "SW_NORMALNA" /* 0xCC */
9041         };
9042         char comment[64];
9043         INT idx; /* index into the above array of names */
9044
9045         idx = (sw[i].cmd == SW_NORMALNA) ? 12 : sw[i].cmd;
9046
9047         style = GetWindowLong(hwnd, GWL_STYLE);
9048         trace("%d: sending %s, current window style %08x\n", i+1, sw_cmd_name[idx], style);
9049         ret = ShowWindow(hwnd, sw[i].cmd);
9050         ok(!ret == !sw[i].ret, "%d: cmd %s: expected ret %lu, got %lu\n", i+1, sw_cmd_name[idx], sw[i].ret, ret);
9051         style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_BASE;
9052         ok(style == sw[i].style, "%d: expected style %08x, got %08x\n", i+1, sw[i].style, style);
9053
9054         sprintf(comment, "%d: ShowWindow(%s)", i+1, sw_cmd_name[idx]);
9055         ok_sequence(sw[i].msg, comment, sw[i].todo_msg);
9056
9057         flush_events();
9058         flush_sequence();
9059     }
9060
9061     DestroyWindow(hwnd);
9062 }
9063
9064 static INT_PTR WINAPI test_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
9065 {
9066     struct message msg;
9067
9068     trace("dialog: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
9069
9070     switch (message)
9071     {
9072     case WM_WINDOWPOSCHANGING:
9073     case WM_WINDOWPOSCHANGED:
9074     {
9075         WINDOWPOS *winpos = (WINDOWPOS *)lParam;
9076
9077         trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
9078         trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
9079               winpos->hwnd, winpos->hwndInsertAfter,
9080               winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
9081         dump_winpos_flags(winpos->flags);
9082
9083         /* Log only documented flags, win2k uses 0x1000 and 0x2000
9084          * in the high word for internal purposes
9085          */
9086         wParam = winpos->flags & 0xffff;
9087         /* We are not interested in the flags that don't match under XP and Win9x */
9088         wParam &= ~(SWP_NOZORDER);
9089         break;
9090     }
9091
9092     /* explicitly ignore WM_GETICON message */
9093     case WM_GETICON:
9094         return 0;
9095     }
9096
9097     msg.message = message;
9098     msg.flags = sent|wparam|lparam;
9099     msg.wParam = wParam;
9100     msg.lParam = lParam;
9101     add_message(&msg);
9102
9103     /* calling DefDlgProc leads to a recursion under XP */
9104
9105     switch (message)
9106     {
9107     case WM_INITDIALOG:
9108     case WM_GETDLGCODE:
9109         return 0;
9110     }
9111     return 1;
9112 }
9113
9114 static const struct message WmDefDlgSetFocus_1[] = {
9115     { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
9116     { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
9117     { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
9118     { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
9119     { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
9120     { HCBT_SETFOCUS, hook },
9121     { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
9122     { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
9123     { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
9124     { WM_SETFOCUS, sent|wparam, 0 },
9125     { WM_CTLCOLOREDIT, sent },
9126     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9127     { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9128     { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9129     { WM_COMMAND, sent|wparam, MAKEWPARAM(1, EN_SETFOCUS) },
9130     { 0 }
9131 };
9132 static const struct message WmDefDlgSetFocus_2[] = {
9133     { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
9134     { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
9135     { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
9136     { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
9137     { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
9138     { WM_CTLCOLOREDIT, sent|optional }, /* XP */
9139     { 0 }
9140 };
9141 /* Creation of a dialog */
9142 static const struct message WmCreateDialogParamSeq_1[] = {
9143     { HCBT_CREATEWND, hook },
9144     { WM_NCCREATE, sent },
9145     { WM_NCCALCSIZE, sent|wparam, 0 },
9146     { WM_CREATE, sent },
9147     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
9148     { WM_SIZE, sent|wparam, SIZE_RESTORED },
9149     { WM_MOVE, sent },
9150     { WM_SETFONT, sent },
9151     { WM_INITDIALOG, sent },
9152     { WM_CHANGEUISTATE, sent|optional },
9153     { 0 }
9154 };
9155 /* Creation of a dialog */
9156 static const struct message WmCreateDialogParamSeq_2[] = {
9157     { HCBT_CREATEWND, hook },
9158     { WM_NCCREATE, sent },
9159     { WM_NCCALCSIZE, sent|wparam, 0 },
9160     { WM_CREATE, sent },
9161     { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
9162     { WM_SIZE, sent|wparam, SIZE_RESTORED },
9163     { WM_MOVE, sent },
9164     { WM_CHANGEUISTATE, sent|optional },
9165     { 0 }
9166 };
9167
9168 static void test_dialog_messages(void)
9169 {
9170     WNDCLASS cls;
9171     HWND hdlg, hedit1, hedit2, hfocus;
9172     LRESULT ret;
9173
9174 #define set_selection(hctl, start, end) \
9175     ret = SendMessage(hctl, EM_SETSEL, start, end); \
9176     ok(ret == 1, "EM_SETSEL returned %ld\n", ret);
9177
9178 #define check_selection(hctl, start, end) \
9179     ret = SendMessage(hctl, EM_GETSEL, 0, 0); \
9180     ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
9181
9182     subclass_edit();
9183
9184     hdlg = CreateWindowEx(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
9185                           WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
9186                           0, 0, 100, 100, 0, 0, 0, NULL);
9187     ok(hdlg != 0, "Failed to create custom dialog window\n");
9188
9189     hedit1 = CreateWindowEx(0, "my_edit_class", NULL,
9190                            WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
9191                            0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
9192     ok(hedit1 != 0, "Failed to create edit control\n");
9193     hedit2 = CreateWindowEx(0, "my_edit_class", NULL,
9194                            WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
9195                            0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
9196     ok(hedit2 != 0, "Failed to create edit control\n");
9197
9198     SendMessage(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
9199     SendMessage(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
9200
9201     hfocus = GetFocus();
9202     ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
9203
9204     SetFocus(hedit2);
9205     hfocus = GetFocus();
9206     ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
9207
9208     check_selection(hedit1, 0, 0);
9209     check_selection(hedit2, 0, 0);
9210
9211     set_selection(hedit2, 0, -1);
9212     check_selection(hedit2, 0, 3);
9213
9214     SetFocus(0);
9215     hfocus = GetFocus();
9216     ok(hfocus == 0, "wrong focus %p\n", hfocus);
9217
9218     flush_sequence();
9219     ret = DefDlgProc(hdlg, WM_SETFOCUS, 0, 0);
9220     ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
9221     ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
9222
9223     hfocus = GetFocus();
9224     ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
9225
9226     check_selection(hedit1, 0, 5);
9227     check_selection(hedit2, 0, 3);
9228
9229     flush_sequence();
9230     ret = DefDlgProc(hdlg, WM_SETFOCUS, 0, 0);
9231     ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
9232     ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
9233
9234     hfocus = GetFocus();
9235     ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
9236
9237     check_selection(hedit1, 0, 5);
9238     check_selection(hedit2, 0, 3);
9239
9240     EndDialog(hdlg, 0);
9241     DestroyWindow(hedit1);
9242     DestroyWindow(hedit2);
9243     DestroyWindow(hdlg);
9244     flush_sequence();
9245
9246 #undef set_selection
9247 #undef check_selection
9248
9249     ok(GetClassInfo(0, "#32770", &cls), "GetClassInfo failed\n");
9250     cls.lpszClassName = "MyDialogClass";
9251     cls.hInstance = GetModuleHandle(0);
9252     /* need a cast since a dlgproc is used as a wndproc */
9253     cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
9254     if (!RegisterClass(&cls)) assert(0);
9255
9256     hdlg = CreateDialogParam(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
9257     ok(IsWindow(hdlg), "CreateDialogParam failed\n");
9258     ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
9259     EndDialog(hdlg, 0);
9260     DestroyWindow(hdlg);
9261     flush_sequence();
9262
9263     hdlg = CreateDialogParam(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
9264     ok(IsWindow(hdlg), "CreateDialogParam failed\n");
9265     ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
9266     EndDialog(hdlg, 0);
9267     DestroyWindow(hdlg);
9268     flush_sequence();
9269
9270     UnregisterClass(cls.lpszClassName, cls.hInstance);
9271 }
9272
9273 static void test_nullCallback(void)
9274 {
9275     HWND hwnd;
9276
9277     hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
9278                            100, 100, 200, 200, 0, 0, 0, NULL);
9279     ok (hwnd != 0, "Failed to create overlapped window\n");
9280
9281     SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
9282     flush_events();
9283     DestroyWindow(hwnd);
9284 }
9285
9286 static const struct message SetForegroundWindowSeq[] =
9287 {
9288     { WM_NCACTIVATE, sent|wparam, 0 },
9289     { WM_GETTEXT, sent|defwinproc|optional },
9290     { WM_ACTIVATE, sent|wparam, 0 },
9291     { WM_ACTIVATEAPP, sent|wparam, 0 },
9292     { WM_KILLFOCUS, sent },
9293     { 0 }
9294 };
9295
9296 static void test_SetForegroundWindow(void)
9297 {
9298     HWND hwnd;
9299
9300     hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetForegroundWindow",
9301                            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
9302                            100, 100, 200, 200, 0, 0, 0, NULL);
9303     ok (hwnd != 0, "Failed to create overlapped window\n");
9304     flush_sequence();
9305
9306     trace("SetForegroundWindow( 0 )\n");
9307     SetForegroundWindow( 0 );
9308     ok_sequence(WmEmptySeq, "SetForegroundWindow( 0 ) away from foreground top level window", FALSE);
9309     trace("SetForegroundWindow( GetDesktopWindow() )\n");
9310     SetForegroundWindow( GetDesktopWindow() );
9311     ok_sequence(SetForegroundWindowSeq, "SetForegroundWindow( desktop ) away from "
9312                                         "foreground top level window", FALSE);
9313     trace("done\n");
9314
9315     DestroyWindow(hwnd);
9316 }
9317
9318 static void test_dbcs_wm_char(void)
9319 {
9320     BYTE dbch[2];
9321     WCHAR wch, bad_wch;
9322     HWND hwnd, hwnd2;
9323     MSG msg;
9324     DWORD time;
9325     POINT pt;
9326     DWORD_PTR res;
9327     CPINFOEXA cpinfo;
9328     UINT i, j, k;
9329     struct message wmCharSeq[2];
9330
9331     pGetCPInfoExA( CP_ACP, 0, &cpinfo );
9332     if (cpinfo.MaxCharSize != 2)
9333     {
9334         skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
9335         return;
9336     }
9337
9338     dbch[0] = dbch[1] = 0;
9339     wch = 0;
9340     bad_wch = cpinfo.UnicodeDefaultChar;
9341     for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
9342         for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
9343             for (k = 128; k <= 255; k++)
9344             {
9345                 char str[2];
9346                 WCHAR wstr[2];
9347                 str[0] = j;
9348                 str[1] = k;
9349                 if (MultiByteToWideChar( CP_ACP, 0, str, 2, wstr, 2 ) == 1 &&
9350                     WideCharToMultiByte( CP_ACP, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
9351                     (BYTE)str[0] == j && (BYTE)str[1] == k &&
9352                     HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
9353                 {
9354                     dbch[0] = j;
9355                     dbch[1] = k;
9356                     wch = wstr[0];
9357                     break;
9358                 }
9359             }
9360
9361     if (!wch)
9362     {
9363         skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
9364         return;
9365     }
9366     trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
9367            dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
9368
9369     hwnd = CreateWindowExW(0, testWindowClassW, NULL,
9370                            WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
9371     hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
9372                            WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
9373     ok (hwnd != 0, "Failed to create overlapped window\n");
9374     ok (hwnd2 != 0, "Failed to create overlapped window\n");
9375     flush_sequence();
9376
9377     memset( wmCharSeq, 0, sizeof(wmCharSeq) );
9378     wmCharSeq[0].message = WM_CHAR;
9379     wmCharSeq[0].flags = sent|wparam;
9380     wmCharSeq[0].wParam = wch;
9381
9382     /* posted message */
9383     PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
9384     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9385     PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9386     ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9387     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9388     ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
9389     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9390
9391     /* posted thread message */
9392     PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
9393     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9394     PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9395     ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9396     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9397     ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
9398     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9399
9400     /* sent message */
9401     flush_sequence();
9402     SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
9403     ok_sequence( WmEmptySeq, "no messages", FALSE );
9404     SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9405     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9406     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9407
9408     /* sent message with timeout */
9409     flush_sequence();
9410     SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
9411     ok_sequence( WmEmptySeq, "no messages", FALSE );
9412     SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
9413     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9414     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9415
9416     /* sent message with timeout and callback */
9417     flush_sequence();
9418     SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
9419     ok_sequence( WmEmptySeq, "no messages", FALSE );
9420     SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
9421     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9422     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9423
9424     /* sent message with callback */
9425     flush_sequence();
9426     SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
9427     ok_sequence( WmEmptySeq, "no messages", FALSE );
9428     SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
9429     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9430     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9431
9432     /* direct window proc call */
9433     flush_sequence();
9434     CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
9435     ok_sequence( WmEmptySeq, "no messages", FALSE );
9436     CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
9437     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9438
9439     /* dispatch message */
9440     msg.hwnd = hwnd;
9441     msg.message = WM_CHAR;
9442     msg.wParam = dbch[0];
9443     msg.lParam = 0;
9444     DispatchMessageA( &msg );
9445     ok_sequence( WmEmptySeq, "no messages", FALSE );
9446     msg.wParam = dbch[1];
9447     DispatchMessageA( &msg );
9448     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9449
9450     /* window handle is irrelevant */
9451     flush_sequence();
9452     SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
9453     ok_sequence( WmEmptySeq, "no messages", FALSE );
9454     SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9455     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9456     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9457
9458     /* interleaved post and send */
9459     flush_sequence();
9460     PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
9461     SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
9462     ok_sequence( WmEmptySeq, "no messages", FALSE );
9463     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9464     PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9465     ok_sequence( WmEmptySeq, "no messages", FALSE );
9466     ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9467     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9468     ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
9469     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9470     SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9471     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9472     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9473
9474     /* interleaved sent message and winproc */
9475     flush_sequence();
9476     SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
9477     CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
9478     ok_sequence( WmEmptySeq, "no messages", FALSE );
9479     SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9480     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9481     CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
9482     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9483
9484     /* interleaved winproc and dispatch */
9485     msg.hwnd = hwnd;
9486     msg.message = WM_CHAR;
9487     msg.wParam = dbch[0];
9488     msg.lParam = 0;
9489     CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
9490     DispatchMessageA( &msg );
9491     ok_sequence( WmEmptySeq, "no messages", FALSE );
9492     msg.wParam = dbch[1];
9493     DispatchMessageA( &msg );
9494     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9495     CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
9496     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9497
9498     /* interleaved sends */
9499     flush_sequence();
9500     SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
9501     SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
9502     ok_sequence( WmEmptySeq, "no messages", FALSE );
9503     SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
9504     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9505     SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
9506     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9507
9508     /* dbcs WM_CHAR */
9509     flush_sequence();
9510     SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
9511     ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
9512     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9513
9514     /* other char messages are not magic */
9515     PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
9516     ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9517     ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
9518     ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
9519     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9520     PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
9521     ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9522     ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
9523     ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
9524     ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9525
9526     /* test retrieving messages */
9527
9528     PostMessageW( hwnd, WM_CHAR, wch, 0 );
9529     ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9530     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9531     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9532     ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9533     ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9534     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9535     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9536     ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9537     ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9538
9539     /* message filters */
9540     PostMessageW( hwnd, WM_CHAR, wch, 0 );
9541     ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
9542     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9543     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9544     ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9545     /* message id is filtered, hwnd is not */
9546     ok( !PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ), "no message\n" );
9547     ok( PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE ), "no message\n" );
9548     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9549     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9550     ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9551     ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9552
9553     /* mixing GetMessage and PostMessage */
9554     PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
9555     ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
9556     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9557     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9558     ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9559     ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
9560     time = msg.time;
9561     pt = msg.pt;
9562     ok( time - GetTickCount() <= 100, "bad time %x\n", msg.time );
9563     ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
9564     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9565     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9566     ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9567     ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
9568     ok( msg.time == time, "bad time %x/%x\n", msg.time, time );
9569     ok( msg.pt.x == pt.x && msg.pt.y == pt.y, "bad point %u,%u/%u,%u\n", msg.pt.x, msg.pt.y, pt.x, pt.y );
9570     ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9571
9572     /* without PM_REMOVE */
9573     PostMessageW( hwnd, WM_CHAR, wch, 0 );
9574     ok( PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "no message\n" );
9575     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9576     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9577     ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9578     ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
9579     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9580     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9581     ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9582     ok( PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "no message\n" );
9583     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9584     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9585     ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9586     ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
9587     ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
9588     ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
9589     ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
9590     ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
9591
9592     DestroyWindow(hwnd);
9593 }
9594
9595 START_TEST(msg)
9596 {
9597     BOOL ret;
9598     FARPROC pIsWinEventHookInstalled = 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
9599
9600     init_procs();
9601
9602     if (!RegisterWindowClasses()) assert(0);
9603
9604     if (pSetWinEventHook)
9605     {
9606         hEvent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
9607                                                       GetModuleHandleA(0),
9608                                                       win_event_proc,
9609                                                       0,
9610                                                       GetCurrentThreadId(),
9611                                                       WINEVENT_INCONTEXT);
9612         assert(hEvent_hook);
9613
9614         if (pIsWinEventHookInstalled)
9615         {
9616             UINT event;
9617             for (event = EVENT_MIN; event <= EVENT_MAX; event++)
9618                 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
9619         }
9620     }
9621
9622     cbt_hook_thread_id = GetCurrentThreadId();
9623     hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
9624     assert(hCBT_hook);
9625
9626     test_winevents();
9627
9628     /* Fix message sequences before removing 4 lines below */
9629 #if 1
9630     if (pUnhookWinEvent && hEvent_hook)
9631     {
9632         ret = pUnhookWinEvent(hEvent_hook);
9633         ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9634         pUnhookWinEvent = 0;
9635     }
9636     hEvent_hook = 0;
9637 #endif
9638
9639     test_ShowWindow();
9640     test_PeekMessage();
9641     test_scrollwindowex();
9642     test_messages();
9643     test_showwindow();
9644     invisible_parent_tests();
9645     test_mdi_messages();
9646     test_button_messages();
9647     test_static_messages();
9648     test_paint_messages();
9649     test_interthread_messages();
9650     test_message_conversion();
9651     test_accelerators();
9652     test_timers();
9653     test_timers_no_wnd();
9654     test_set_hook();
9655     test_DestroyWindow();
9656     test_DispatchMessage();
9657     test_SendMessageTimeout();
9658     test_edit_messages();
9659     test_quit_message();
9660
9661     if (!pTrackMouseEvent)
9662         skip("TrackMouseEvent is not available\n");
9663     else
9664         test_TrackMouseEvent();
9665
9666     test_SetWindowRgn();
9667     test_sys_menu();
9668     test_dialog_messages();
9669     test_nullCallback();
9670     test_SetForegroundWindow();
9671     test_dbcs_wm_char();
9672
9673     UnhookWindowsHookEx(hCBT_hook);
9674     if (pUnhookWinEvent)
9675     {
9676         ret = pUnhookWinEvent(hEvent_hook);
9677         ok( ret, "UnhookWinEvent error %d\n", GetLastError());
9678         SetLastError(0xdeadbeef);
9679         ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
9680         ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
9681            GetLastError() == 0xdeadbeef, /* Win9x */
9682            "unexpected error %d\n", GetLastError());
9683     }
9684     else
9685         skip("UnhookWinEvent is not available\n");
9686 }
WINE + custom patches