?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32/tests: Skip some failing tests on NT4.
[wine/multimedia.git] / dlls / user32 / tests / msg.c
blob62cc2dce8810f04a3876c8a9e40f8bbd0913a50b
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_KEYF1
47 #define WM_KEYF1 0x004d
48 #endif
49
50 #ifndef WM_SYSTIMER
51 #define WM_SYSTIMER 0x0118
52 #endif
53
54 #define WND_PARENT_ID 1
55 #define WND_POPUP_ID 2
56 #define WND_CHILD_ID 3
57
58 #ifndef WM_LBTRACKPOINT
59 #define WM_LBTRACKPOINT 0x0131
60 #endif
61
62 /* encoded DRAWITEMSTRUCT into an LPARAM */
63 typedef struct
64 {
65 union
66 {
67 struct
68 {
69 UINT type : 4; /* ODT_* flags */
70 UINT ctl_id : 4; /* Control ID */
71 UINT item_id : 4; /* Menu item ID */
72 UINT action : 4; /* ODA_* flags */
73 UINT state : 16; /* ODS_* flags */
74 } item;
75 LPARAM lp;
76 } u;
77 } DRAW_ITEM_STRUCT;
78
79 static BOOL test_DestroyWindow_flag;
80 static HWINEVENTHOOK hEvent_hook;
81
82 static void dump_winpos_flags(UINT flags);
83
84 static const WCHAR testWindowClassW[] =
85 { 'T','e','s','t','W','i','n','d','o','w','C','l','a','s','s','W',0 };
86
87 /*
88 FIXME: add tests for these
89 Window Edge Styles (Win31/Win95/98 look), in order of precedence:
90 WS_EX_DLGMODALFRAME: double border, WS_CAPTION allowed
91 WS_THICKFRAME: thick border
92 WS_DLGFRAME: double border, WS_CAPTION not allowed (but possibly shown anyway)
93 WS_BORDER (default for overlapped windows): single black border
94 none (default for child (and popup?) windows): no border
95 */
96
97 typedef enum {
98 sent=0x1,
99 posted=0x2,
100 parent=0x4,
101 wparam=0x8,
102 lparam=0x10,
103 defwinproc=0x20,
104 beginpaint=0x40,
105 optional=0x80,
106 hook=0x100,
107 winevent_hook=0x200
108 } msg_flags_t;
109
110 struct message {
111 UINT message; /* the WM_* code */
112 msg_flags_t flags; /* message props */
113 WPARAM wParam; /* expected value of wParam */
114 LPARAM lParam; /* expected value of lParam */
115 };
116
117 /* Empty message sequence */
118 static const struct message WmEmptySeq[] =
119 {
120 { 0 }
121 };
122 /* CreateWindow (for overlapped window, not initially visible) (16/32) */
123 static const struct message WmCreateOverlappedSeq[] = {
124 { HCBT_CREATEWND, hook },
125 { WM_GETMINMAXINFO, sent },
126 { WM_NCCREATE, sent },
127 { WM_NCCALCSIZE, sent|wparam, 0 },
128 { 0x0093, sent|defwinproc|optional },
129 { 0x0094, sent|defwinproc|optional },
130 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
131 { WM_CREATE, sent },
132 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
133 { 0 }
134 };
135 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
136 * for a not visible overlapped window.
137 */
138 static const struct message WmSWP_ShowOverlappedSeq[] = {
139 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
140 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
141 { WM_NCPAINT, sent|wparam|optional, 1 },
142 { WM_GETTEXT, sent|defwinproc|optional },
143 { WM_ERASEBKGND, sent|optional },
144 { HCBT_ACTIVATE, hook },
145 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
146 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
147 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x: SWP_NOSENDCHANGING */
148 { WM_ACTIVATEAPP, sent|wparam, 1 },
149 { WM_NCACTIVATE, sent|wparam, 1 },
150 { WM_GETTEXT, sent|defwinproc|optional },
151 { WM_ACTIVATE, sent|wparam, 1 },
152 { HCBT_SETFOCUS, hook },
153 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
154 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
155 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
156 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
157 { WM_NCPAINT, sent|wparam|optional, 1 },
158 { WM_GETTEXT, sent|defwinproc|optional },
159 { WM_ERASEBKGND, sent|optional },
160 /* Win9x adds SWP_NOZORDER below */
161 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
162 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
163 { WM_NCPAINT, sent|wparam|optional, 1 },
164 { WM_ERASEBKGND, sent|optional },
165 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
166 { WM_PAINT, sent|optional },
167 { WM_NCPAINT, sent|beginpaint|optional },
168 { WM_ERASEBKGND, sent|beginpaint|optional },
169 { 0 }
170 };
171 /* SetWindowPos(SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE)
172 * for a visible overlapped window.
173 */
174 static const struct message WmSWP_HideOverlappedSeq[] = {
175 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
176 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
177 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
178 { 0 }
179 };
180
181 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
182 * for a visible overlapped window.
183 */
184 static const struct message WmSWP_ResizeSeq[] = {
185 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
186 { WM_GETMINMAXINFO, sent|defwinproc },
187 { WM_NCCALCSIZE, sent|wparam, TRUE },
188 { WM_NCPAINT, sent|optional },
189 { WM_GETTEXT, sent|defwinproc|optional },
190 { WM_ERASEBKGND, sent|optional },
191 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
192 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
193 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
194 { WM_NCPAINT, sent|optional },
195 { WM_GETTEXT, sent|defwinproc|optional },
196 { WM_ERASEBKGND, sent|optional },
197 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
198 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
199 { 0 }
200 };
201
202 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE)
203 * for a visible popup window.
204 */
205 static const struct message WmSWP_ResizePopupSeq[] = {
206 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE },
207 { WM_GETMINMAXINFO, sent|defwinproc|optional }, /* Win9x */
208 { WM_NCCALCSIZE, sent|wparam, TRUE },
209 { WM_NCPAINT, sent|optional },
210 { WM_GETTEXT, sent|defwinproc|optional },
211 { WM_ERASEBKGND, sent|optional },
212 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
213 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
214 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
215 { WM_NCPAINT, sent|optional },
216 { WM_GETTEXT, sent|defwinproc|optional },
217 { WM_ERASEBKGND, sent|optional },
218 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
219 { 0 }
220 };
221
222 /* SetWindowPos(SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE)
223 * for a visible overlapped window.
224 */
225 static const struct message WmSWP_MoveSeq[] = {
226 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE },
227 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOCLIENTSIZE },
228 { WM_MOVE, sent|defwinproc|wparam, 0 },
229 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
230 { 0 }
231 };
232 /* Resize with SetWindowPos(SWP_NOZORDER)
233 * for a visible overlapped window
234 * SWP_NOZORDER is stripped by the logging code
235 */
236 static const struct message WmSWP_ResizeNoZOrder[] = {
237 { WM_WINDOWPOSCHANGING, sent|wparam, /*SWP_NOZORDER|*/SWP_NOACTIVATE },
238 { WM_GETMINMAXINFO, sent|defwinproc },
239 { WM_NCCALCSIZE, sent|wparam, 1 },
240 { WM_NCPAINT, sent },
241 { WM_GETTEXT, sent|defwinproc|optional },
242 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
243 { WM_WINDOWPOSCHANGED, sent|wparam, /*SWP_NOZORDER|*/SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE },
244 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
245 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
246 { WM_NCPAINT, sent|optional }, /* Win9x doesn't send it */
247 { WM_GETTEXT, sent|defwinproc|optional }, /* Win9x doesn't send it */
248 { WM_ERASEBKGND, sent|optional }, /* Win9x doesn't send it */
249 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
250 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
251 { 0 }
252 };
253
254 /* Switch visible mdi children */
255 static const struct message WmSwitchChild[] = {
256 /* Switch MDI child */
257 { WM_MDIACTIVATE, sent },/* in the MDI client */
258 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 1st MDI child */
259 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
260 { WM_CHILDACTIVATE, sent },/* in the 1st MDI child */
261 /* Deactivate 2nd MDI child */
262 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
263 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
264 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
265 /* Preparing for maximize and maximaze the 1st MDI child */
266 { WM_GETMINMAXINFO, sent|defwinproc }, /* in the 1st MDI child */
267 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED }, /* in the 1st MDI child */
268 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
269 { WM_CHILDACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
270 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 1st MDI child */
271 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED }, /* in the 1st MDI child */
272 /* Lock redraw 2nd MDI child */
273 { WM_SETREDRAW, sent|wparam|defwinproc, 0 }, /* in the 2nd MDI child */
274 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
275 /* Restore 2nd MDI child */
276 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },/* in the 2nd MDI child */
277 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
278 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
279 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED }, /* in the 2nd MDI child */
280 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED }, /* in the 2nd MDI child */
281 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 2nd MDI child */
282 /* Redraw 2nd MDI child */
283 { WM_SETREDRAW, sent|wparam|defwinproc, 1 },/* in the 2nd MDI child */
284 /* Redraw MDI frame */
285 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },/* in MDI frame */
286 { WM_NCCALCSIZE, sent|wparam, 1 },/* in MDI frame */
287 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in MDI frame */
288 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in MDI frame */
289 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
290 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
291 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 1st MDI child */
292 { HCBT_SETFOCUS, hook },
293 { WM_KILLFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
294 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },/* in the 1st MDI child */
295 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
296 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
297 { WM_SETFOCUS, sent },/* in the MDI client */
298 { HCBT_SETFOCUS, hook },
299 { WM_KILLFOCUS, sent },/* in the MDI client */
300 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
301 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 }, /* in the 1st MDI child */
302 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
303 { WM_SETFOCUS, sent|defwinproc }, /* in the 1st MDI child */
304 { WM_MDIACTIVATE, sent|defwinproc },/* in the 1st MDI child */
305 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE }, /* in the 1st MDI child */
306 { 0 }
307 };
308
309 /* Switch visible not maximized mdi children */
310 static const struct message WmSwitchNotMaximizedChild[] = {
311 /* Switch not maximized MDI child */
312 { WM_MDIACTIVATE, sent },/* in the MDI client */
313 { WM_WINDOWPOSCHANGING, sent|wparam,SWP_NOSIZE|SWP_NOMOVE },/* in the 2nd MDI child */
314 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
315 { WM_CHILDACTIVATE, sent },/* in the 2nd MDI child */
316 /* Deactivate 1st MDI child */
317 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
318 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
319 /* Activate 2nd MDI child */
320 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE}, /* in the 2nd MDI child */
321 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 }, /* in the 2nd MDI child */
322 { HCBT_SETFOCUS, hook }, /* in the 1st MDI child */
323 { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
324 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
325 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
326 { WM_SETFOCUS, sent, 0 }, /* in the MDI client */
327 { HCBT_SETFOCUS, hook },
328 { WM_KILLFOCUS, sent }, /* in the MDI client */
329 { WM_IME_SETCONTEXT, sent|optional }, /* in the MDI client */
330 { WM_IME_SETCONTEXT, sent|defwinproc|optional }, /* in the 1st MDI child */
331 { WM_SETFOCUS, sent|defwinproc }, /* in the 2nd MDI child */
332 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 2nd MDI child */
333 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE}, /* in the 2nd MDI child */
334 { 0 }
335 };
336
337
338 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
339 SWP_NOZORDER|SWP_FRAMECHANGED)
340 * for a visible overlapped window with WS_CLIPCHILDREN style set.
341 */
342 static const struct message WmSWP_FrameChanged_clip[] = {
343 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
344 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
345 { WM_NCPAINT, sent|parent }, /* wparam != 1 */
346 { WM_GETTEXT, sent|parent|defwinproc|optional },
347 { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
348 { WM_NCPAINT, sent }, /* wparam != 1 */
349 { WM_ERASEBKGND, sent },
350 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
351 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
352 { WM_PAINT, sent },
353 { 0 }
354 };
355 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|
356 SWP_NOZORDER|SWP_FRAMECHANGED)
357 * for a visible overlapped window.
358 */
359 static const struct message WmSWP_FrameChangedDeferErase[] = {
360 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
361 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
362 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_DEFERERASE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
363 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
364 { WM_PAINT, sent|parent },
365 { WM_NCPAINT, sent|beginpaint|parent }, /* wparam != 1 */
366 { WM_GETTEXT, sent|beginpaint|parent|defwinproc|optional },
367 { WM_PAINT, sent },
368 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
369 { WM_ERASEBKGND, sent|beginpaint },
370 { 0 }
371 };
372
373 /* SetWindowPos(SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|
374 SWP_NOZORDER|SWP_FRAMECHANGED)
375 * for a visible overlapped window without WS_CLIPCHILDREN style set.
376 */
377 static const struct message WmSWP_FrameChanged_noclip[] = {
378 { WM_WINDOWPOSCHANGING, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED },
379 { WM_NCCALCSIZE, sent|wparam|parent, 1 },
380 { WM_NCPAINT, sent|parent }, /* wparam != 1 */
381 { WM_GETTEXT, sent|parent|defwinproc|optional },
382 { WM_ERASEBKGND, sent|parent|optional }, /* FIXME: remove optional once Wine is fixed */
383 { WM_WINDOWPOSCHANGED, sent|wparam|parent, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
384 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
385 { WM_PAINT, sent },
386 { WM_NCPAINT, sent|beginpaint }, /* wparam != 1 */
387 { WM_ERASEBKGND, sent|beginpaint },
388 { 0 }
389 };
390
391 /* ShowWindow(SW_SHOW) for a not visible overlapped window */
392 static const struct message WmShowOverlappedSeq[] = {
393 { WM_SHOWWINDOW, sent|wparam, 1 },
394 { WM_NCPAINT, sent|wparam|optional, 1 },
395 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
396 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
397 { WM_NCPAINT, sent|wparam|optional, 1 },
398 { WM_GETTEXT, sent|defwinproc|optional },
399 { WM_ERASEBKGND, sent|optional },
400 { HCBT_ACTIVATE, hook },
401 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
402 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
403 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
404 { WM_NCPAINT, sent|wparam|optional, 1 },
405 { WM_ACTIVATEAPP, sent|wparam, 1 },
406 { WM_NCACTIVATE, sent|wparam, 1 },
407 { WM_GETTEXT, sent|defwinproc|optional },
408 { WM_ACTIVATE, sent|wparam, 1 },
409 { HCBT_SETFOCUS, hook },
410 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
411 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
412 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
413 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
414 { WM_NCPAINT, sent|wparam|optional, 1 },
415 { WM_GETTEXT, sent|defwinproc|optional },
416 { WM_ERASEBKGND, sent|optional },
417 /* Win9x adds SWP_NOZORDER below */
418 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
419 { WM_NCCALCSIZE, sent|optional },
420 { WM_NCPAINT, sent|optional },
421 { WM_ERASEBKGND, sent|optional },
422 #if 0 /* CreateWindow/ShowWindow(SW_SHOW) also generates WM_SIZE/WM_MOVE
423 * messages. Does that mean that CreateWindow doesn't set initial
424 * window dimensions for overlapped windows?
425 */
426 { WM_SIZE, sent },
427 { WM_MOVE, sent },
428 #endif
429 { WM_PAINT, sent|optional },
430 { WM_NCPAINT, sent|beginpaint|optional },
431 { 0 }
432 };
433 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible overlapped window */
434 static const struct message WmShowMaxOverlappedSeq[] = {
435 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
436 { WM_GETMINMAXINFO, sent },
437 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
438 { WM_GETMINMAXINFO, sent|defwinproc },
439 { WM_NCCALCSIZE, sent|wparam, TRUE },
440 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
441 { HCBT_ACTIVATE, hook },
442 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
443 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
444 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
445 { WM_ACTIVATEAPP, sent|wparam, 1 },
446 { WM_NCACTIVATE, sent|wparam, 1 },
447 { WM_GETTEXT, sent|defwinproc|optional },
448 { WM_ACTIVATE, sent|wparam, 1 },
449 { HCBT_SETFOCUS, hook },
450 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
451 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
452 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
453 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
454 { WM_NCPAINT, sent|wparam|optional, 1 },
455 { WM_GETTEXT, sent|defwinproc|optional },
456 { WM_ERASEBKGND, sent|optional },
457 /* Win9x adds SWP_NOZORDER below */
458 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
459 { WM_MOVE, sent|defwinproc },
460 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
461 { WM_NCCALCSIZE, sent|optional },
462 { WM_NCPAINT, sent|optional },
463 { WM_ERASEBKGND, sent|optional },
464 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
465 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
466 { WM_PAINT, sent|optional },
467 { WM_NCPAINT, sent|beginpaint|optional },
468 { WM_ERASEBKGND, sent|beginpaint|optional },
469 { 0 }
470 };
471 /* ShowWindow(SW_RESTORE) for a not visible maximized overlapped window */
472 static const struct message WmShowRestoreMaxOverlappedSeq[] = {
473 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
474 { WM_GETTEXT, sent|optional },
475 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
476 { WM_GETMINMAXINFO, sent|defwinproc },
477 { WM_NCCALCSIZE, sent|wparam, TRUE },
478 { WM_NCPAINT, sent|optional },
479 { WM_GETTEXT, sent|defwinproc|optional },
480 { WM_ERASEBKGND, sent|optional },
481 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
482 { WM_MOVE, sent|defwinproc },
483 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
484 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
485 { WM_NCPAINT, sent|optional },
486 { WM_ERASEBKGND, sent|optional },
487 { WM_PAINT, sent|optional },
488 { WM_NCPAINT, sent|beginpaint|optional },
489 { WM_ERASEBKGND, sent|beginpaint|optional },
490 { 0 }
491 };
492 /* ShowWindow(SW_RESTORE) for a not visible minimized overlapped window */
493 static const struct message WmShowRestoreMinOverlappedSeq[] = {
494 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
495 { WM_QUERYOPEN, sent|optional },
496 { WM_GETTEXT, sent|optional },
497 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED|SWP_NOCOPYBITS },
498 { WM_GETMINMAXINFO, sent|defwinproc },
499 { WM_NCCALCSIZE, sent|wparam, TRUE },
500 { HCBT_ACTIVATE, hook },
501 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
502 { WM_ACTIVATEAPP, sent|wparam, 1 },
503 { WM_NCACTIVATE, sent|wparam, 1 },
504 { WM_GETTEXT, sent|defwinproc|optional },
505 { WM_ACTIVATE, sent|wparam, 1 },
506 { HCBT_SETFOCUS, hook },
507 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
508 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
509 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
510 { WM_NCPAINT, sent|wparam|optional, 1 },
511 { WM_GETTEXT, sent|defwinproc|optional },
512 { WM_ERASEBKGND, sent },
513 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_STATECHANGED|SWP_FRAMECHANGED|SWP_NOCOPYBITS },
514 { WM_MOVE, sent|defwinproc },
515 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
516 { WM_NCCALCSIZE, sent|wparam|optional, TRUE },
517 { WM_NCPAINT, sent|wparam|optional, 1 },
518 { WM_ERASEBKGND, sent|optional },
519 { WM_ACTIVATE, sent|wparam, 1 },
520 { WM_PAINT, sent|optional },
521 { WM_NCPAINT, sent|beginpaint|optional },
522 { WM_ERASEBKGND, sent|beginpaint|optional },
523 { 0 }
524 };
525 /* ShowWindow(SW_SHOWMINIMIZED) for a not visible overlapped window */
526 static const struct message WmShowMinOverlappedSeq[] = {
527 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
528 { HCBT_SETFOCUS, hook },
529 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
530 { WM_KILLFOCUS, sent },
531 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
532 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
533 { WM_GETTEXT, sent|optional },
534 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCOPYBITS|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
535 { WM_GETMINMAXINFO, sent|defwinproc },
536 { WM_NCCALCSIZE, sent|wparam, TRUE },
537 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
538 { WM_NCPAINT, sent|optional },
539 { WM_GETTEXT, sent|defwinproc|optional },
540 { WM_WINDOWPOSCHANGED, sent },
541 { WM_MOVE, sent|defwinproc },
542 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
543 { WM_NCCALCSIZE, sent|optional },
544 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
545 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
546 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
547 { WM_NCACTIVATE, sent|wparam, 0 },
548 { WM_GETTEXT, sent|defwinproc|optional },
549 { WM_ACTIVATE, sent },
550 { WM_ACTIVATEAPP, sent|wparam, 0 },
551 { WM_PAINT, sent|optional },
552 { WM_NCPAINT, sent|beginpaint|optional },
553 { WM_ERASEBKGND, sent|beginpaint|optional },
554 { 0 }
555 };
556 /* ShowWindow(SW_HIDE) for a visible overlapped window */
557 static const struct message WmHideOverlappedSeq[] = {
558 { WM_SHOWWINDOW, sent|wparam, 0 },
559 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
560 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
561 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
562 { WM_SIZE, sent|optional }, /* XP doesn't send it */
563 { WM_MOVE, sent|optional }, /* XP doesn't send it */
564 { WM_NCACTIVATE, sent|wparam, 0 },
565 { WM_ACTIVATE, sent|wparam, 0 },
566 { WM_ACTIVATEAPP, sent|wparam, 0 },
567 { WM_KILLFOCUS, sent|wparam, 0 },
568 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
569 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
570 { 0 }
571 };
572 /* DestroyWindow for a visible overlapped window */
573 static const struct message WmDestroyOverlappedSeq[] = {
574 { HCBT_DESTROYWND, hook },
575 { 0x0090, sent|optional },
576 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
577 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
578 { 0x0090, sent|optional },
579 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
580 { WM_NCACTIVATE, sent|optional|wparam, 0 },
581 { WM_ACTIVATE, sent|optional|wparam, 0 },
582 { WM_ACTIVATEAPP, sent|optional|wparam, 0 },
583 { WM_KILLFOCUS, sent|optional|wparam, 0 },
584 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
585 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
586 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
587 { WM_DESTROY, sent },
588 { WM_NCDESTROY, sent },
589 { 0 }
590 };
591 /* CreateWindow(WS_MAXIMIZE|WS_VISIBLE) for popup window */
592 static const struct message WmCreateMaxPopupSeq[] = {
593 { HCBT_CREATEWND, hook },
594 { WM_NCCREATE, sent },
595 { WM_NCCALCSIZE, sent|wparam, 0 },
596 { WM_CREATE, sent },
597 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
598 { WM_SIZE, sent|wparam, SIZE_RESTORED },
599 { WM_MOVE, sent },
600 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
601 { WM_GETMINMAXINFO, sent },
602 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
603 { WM_NCCALCSIZE, sent|wparam, TRUE },
604 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
605 { WM_MOVE, sent|defwinproc },
606 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
607 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
608 { WM_SHOWWINDOW, sent|wparam, 1 },
609 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
610 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
611 { HCBT_ACTIVATE, hook },
612 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
613 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
614 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
615 { WM_ACTIVATEAPP, sent|wparam, 1 },
616 { WM_NCACTIVATE, sent|wparam, 1 },
617 { WM_ACTIVATE, sent|wparam, 1 },
618 { HCBT_SETFOCUS, hook },
619 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
620 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
621 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
622 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
623 { WM_SYNCPAINT, sent|wparam|optional, 4 },
624 { WM_NCPAINT, sent|wparam|optional, 1 },
625 { WM_ERASEBKGND, sent|optional },
626 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
627 { 0 }
628 };
629 /* CreateWindow(WS_MAXIMIZE) for popup window, not initially visible */
630 static const struct message WmCreateInvisibleMaxPopupSeq[] = {
631 { HCBT_CREATEWND, hook },
632 { WM_NCCREATE, sent },
633 { WM_NCCALCSIZE, sent|wparam, 0 },
634 { WM_CREATE, sent },
635 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
636 { WM_SIZE, sent|wparam, SIZE_RESTORED },
637 { WM_MOVE, sent },
638 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
639 { WM_GETMINMAXINFO, sent },
640 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
641 { WM_NCCALCSIZE, sent|wparam, TRUE },
642 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
643 { WM_MOVE, sent|defwinproc },
644 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
645 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
646 { 0 }
647 };
648 /* ShowWindow(SW_SHOWMAXIMIZED) for a resized not visible popup window */
649 static const struct message WmShowMaxPopupResizedSeq[] = {
650 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
651 { WM_GETMINMAXINFO, sent },
652 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
653 { WM_NCCALCSIZE, sent|wparam, TRUE },
654 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
655 { HCBT_ACTIVATE, hook },
656 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
657 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
658 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
659 { WM_ACTIVATEAPP, sent|wparam, 1 },
660 { WM_NCACTIVATE, sent|wparam, 1 },
661 { WM_ACTIVATE, sent|wparam, 1 },
662 { HCBT_SETFOCUS, hook },
663 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
664 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
665 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
666 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
667 { WM_NCPAINT, sent|wparam|optional, 1 },
668 { WM_ERASEBKGND, sent|optional },
669 { WM_WINDOWPOSCHANGED, sent },
670 /* WinNT4.0 sends WM_MOVE */
671 { WM_MOVE, sent|defwinproc|optional },
672 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
673 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
674 { 0 }
675 };
676 /* ShowWindow(SW_SHOWMAXIMIZED) for a not visible popup window */
677 static const struct message WmShowMaxPopupSeq[] = {
678 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
679 { WM_GETMINMAXINFO, sent },
680 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
681 { WM_NCCALCSIZE, sent|wparam, TRUE },
682 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
683 { HCBT_ACTIVATE, hook },
684 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
685 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
686 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
687 { WM_ACTIVATEAPP, sent|wparam, 1 },
688 { WM_NCACTIVATE, sent|wparam, 1 },
689 { WM_ACTIVATE, sent|wparam, 1 },
690 { HCBT_SETFOCUS, hook },
691 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
692 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
693 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
694 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
695 { WM_SYNCPAINT, sent|wparam|optional, 4 },
696 { WM_NCPAINT, sent|wparam|optional, 1 },
697 { WM_ERASEBKGND, sent|optional },
698 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE },
699 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
700 { 0 }
701 };
702 /* CreateWindow(WS_VISIBLE) for popup window */
703 static const struct message WmCreatePopupSeq[] = {
704 { HCBT_CREATEWND, hook },
705 { WM_NCCREATE, sent },
706 { WM_NCCALCSIZE, sent|wparam, 0 },
707 { WM_CREATE, sent },
708 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
709 { WM_SIZE, sent|wparam, SIZE_RESTORED },
710 { WM_MOVE, sent },
711 { WM_SHOWWINDOW, sent|wparam, 1 },
712 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
713 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
714 { HCBT_ACTIVATE, hook },
715 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
716 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
717 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE },
718 { WM_NCPAINT, sent|wparam|optional, 1 },
719 { WM_ERASEBKGND, sent|optional },
720 { WM_ACTIVATEAPP, sent|wparam, 1 },
721 { WM_NCACTIVATE, sent|wparam, 1 },
722 { WM_ACTIVATE, sent|wparam, 1 },
723 { HCBT_SETFOCUS, hook },
724 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
725 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
726 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
727 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
728 { WM_SYNCPAINT, sent|wparam|optional, 4 },
729 { WM_NCPAINT, sent|wparam|optional, 1 },
730 { WM_ERASEBKGND, sent|optional },
731 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTMOVE|SWP_NOCLIENTSIZE|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE },
732 { 0 }
733 };
734 /* ShowWindow(SW_SHOWMAXIMIZED) for a visible popup window */
735 static const struct message WmShowVisMaxPopupSeq[] = {
736 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
737 { WM_GETMINMAXINFO, sent },
738 { WM_GETTEXT, sent|optional },
739 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
740 { WM_NCCALCSIZE, sent|wparam, TRUE },
741 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
742 { WM_NCPAINT, sent|wparam|optional, 1 },
743 { WM_ERASEBKGND, sent|optional },
744 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
745 { WM_MOVE, sent|defwinproc },
746 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
747 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
748 { 0 }
749 };
750 /* CreateWindow (for a child popup window, not initially visible) */
751 static const struct message WmCreateChildPopupSeq[] = {
752 { HCBT_CREATEWND, hook },
753 { WM_NCCREATE, sent },
754 { WM_NCCALCSIZE, sent|wparam, 0 },
755 { WM_CREATE, sent },
756 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
757 { WM_SIZE, sent|wparam, SIZE_RESTORED },
758 { WM_MOVE, sent },
759 { 0 }
760 };
761 /* CreateWindow (for a popup window, not initially visible,
762 * which sets WS_VISIBLE in WM_CREATE handler)
763 */
764 static const struct message WmCreateInvisiblePopupSeq[] = {
765 { HCBT_CREATEWND, hook },
766 { WM_NCCREATE, sent },
767 { WM_NCCALCSIZE, sent|wparam, 0 },
768 { WM_CREATE, sent },
769 { WM_STYLECHANGING, sent },
770 { WM_STYLECHANGED, sent },
771 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
772 { WM_SIZE, sent|wparam, SIZE_RESTORED },
773 { WM_MOVE, sent },
774 { 0 }
775 };
776 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER)
777 * for a popup window with WS_VISIBLE style set
778 */
779 static const struct message WmShowVisiblePopupSeq_2[] = {
780 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
781 { 0 }
782 };
783 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
784 * for a popup window with WS_VISIBLE style set
785 */
786 static const struct message WmShowVisiblePopupSeq_3[] = {
787 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
788 { HCBT_ACTIVATE, hook },
789 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
790 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
791 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
792 { WM_NCACTIVATE, sent|wparam, 1 },
793 { WM_ACTIVATE, sent|wparam, 1 },
794 { HCBT_SETFOCUS, hook },
795 { WM_KILLFOCUS, sent|parent },
796 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
797 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
798 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
799 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
800 { WM_SETFOCUS, sent|defwinproc },
801 { 0 }
802 };
803 /* CreateWindow (for child window, not initially visible) */
804 static const struct message WmCreateChildSeq[] = {
805 { HCBT_CREATEWND, hook },
806 { WM_NCCREATE, sent },
807 /* child is inserted into parent's child list after WM_NCCREATE returns */
808 { WM_NCCALCSIZE, sent|wparam, 0 },
809 { WM_CREATE, sent },
810 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
811 { WM_SIZE, sent|wparam, SIZE_RESTORED },
812 { WM_MOVE, sent },
813 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
814 { 0 }
815 };
816 /* CreateWindow (for maximized child window, not initially visible) */
817 static const struct message WmCreateMaximizedChildSeq[] = {
818 { HCBT_CREATEWND, hook },
819 { WM_NCCREATE, sent },
820 { WM_NCCALCSIZE, sent|wparam, 0 },
821 { WM_CREATE, sent },
822 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
823 { WM_SIZE, sent|wparam, SIZE_RESTORED },
824 { WM_MOVE, sent },
825 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
826 { WM_GETMINMAXINFO, sent },
827 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
828 { WM_NCCALCSIZE, sent|wparam, 1 },
829 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
830 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
831 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
832 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
833 { 0 }
834 };
835 /* CreateWindow (for a child window, initially visible) */
836 static const struct message WmCreateVisibleChildSeq[] = {
837 { HCBT_CREATEWND, hook },
838 { WM_NCCREATE, sent },
839 /* child is inserted into parent's child list after WM_NCCREATE returns */
840 { WM_NCCALCSIZE, sent|wparam, 0 },
841 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
842 { WM_CREATE, sent },
843 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
844 { WM_SIZE, sent|wparam, SIZE_RESTORED },
845 { WM_MOVE, sent },
846 { WM_PARENTNOTIFY, sent|parent|wparam, WM_CREATE },
847 { WM_SHOWWINDOW, sent|wparam, 1 },
848 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
849 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
850 { WM_ERASEBKGND, sent|parent|optional },
851 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
852 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* WinXP */
853 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
854 { 0 }
855 };
856 /* ShowWindow(SW_SHOW) for a not visible child window */
857 static const struct message WmShowChildSeq[] = {
858 { WM_SHOWWINDOW, sent|wparam, 1 },
859 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
860 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
861 { WM_ERASEBKGND, sent|parent|optional },
862 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
863 { 0 }
864 };
865 /* ShowWindow(SW_HIDE) for a visible child window */
866 static const struct message WmHideChildSeq[] = {
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 { 0 }
873 };
874 /* ShowWindow(SW_HIDE) for a visible child window checking all parent events*/
875 static const struct message WmHideChildSeq2[] = {
876 { WM_SHOWWINDOW, sent|wparam, 0 },
877 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
878 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
879 { WM_ERASEBKGND, sent|parent },
880 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
881 { 0 }
882 };
883 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
884 * for a not visible child window
885 */
886 static const struct message WmShowChildSeq_2[] = {
887 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
888 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
889 { WM_CHILDACTIVATE, sent },
890 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
891 { 0 }
892 };
893 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE)
894 * for a not visible child window
895 */
896 static const struct message WmShowChildSeq_3[] = {
897 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
898 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
899 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
900 { 0 }
901 };
902 /* SetWindowPos(SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE)
903 * for a visible child window with a caption
904 */
905 static const struct message WmShowChildSeq_4[] = {
906 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
907 { WM_CHILDACTIVATE, sent },
908 { 0 }
909 };
910 /* ShowWindow(SW_MINIMIZE) for child with invisible parent */
911 static const struct message WmShowChildInvisibleParentSeq_1[] = {
912 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
913 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
914 { WM_NCCALCSIZE, sent|wparam, 1 },
915 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
916 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
917 { WM_MOVE, sent|defwinproc },
918 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
919 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
920 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
921 /* FIXME: Wine creates an icon/title window while Windows doesn't */
922 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
923 { WM_GETTEXT, sent|optional },
924 { 0 }
925 };
926 /* repeated ShowWindow(SW_MINIMIZE) for child with invisible parent */
927 static const struct message WmShowChildInvisibleParentSeq_1r[] = {
928 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
929 { 0 }
930 };
931 /* ShowWindow(SW_MAXIMIZE) for child with invisible parent */
932 static const struct message WmShowChildInvisibleParentSeq_2[] = {
933 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
934 { WM_GETMINMAXINFO, sent },
935 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
936 { WM_NCCALCSIZE, sent|wparam, 1 },
937 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
938 { WM_CHILDACTIVATE, sent },
939 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
940 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
941 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
942 { 0 }
943 };
944 /* repeated ShowWindow(SW_MAXIMIZE) for child with invisible parent */
945 static const struct message WmShowChildInvisibleParentSeq_2r[] = {
946 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
947 { 0 }
948 };
949 /* ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
950 static const struct message WmShowChildInvisibleParentSeq_3[] = {
951 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
952 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
953 { WM_NCCALCSIZE, sent|wparam, 1 },
954 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
955 { WM_CHILDACTIVATE, sent },
956 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
957 { WM_MOVE, sent|defwinproc },
958 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
959 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
960 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
961 /* FIXME: Wine creates an icon/title window while Windows doesn't */
962 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
963 { WM_GETTEXT, sent|optional },
964 { 0 }
965 };
966 /* repeated ShowWindow(SW_SHOWMINIMIZED) for child with invisible parent */
967 static const struct message WmShowChildInvisibleParentSeq_3r[] = {
968 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
969 { 0 }
970 };
971 /* ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
972 static const struct message WmShowChildInvisibleParentSeq_4[] = {
973 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
974 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
975 { WM_NCCALCSIZE, sent|wparam, 1 },
976 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
977 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCOPYBITS|SWP_STATECHANGED },
978 { WM_MOVE, sent|defwinproc },
979 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
980 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
981 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 },
982 /* FIXME: Wine creates an icon/title window while Windows doesn't */
983 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE },
984 { WM_GETTEXT, sent|optional },
985 { 0 }
986 };
987 /* repeated ShowWindow(SW_SHOWMINNOACTIVE) for child with invisible parent */
988 static const struct message WmShowChildInvisibleParentSeq_4r[] = {
989 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
990 { 0 }
991 };
992 /* ShowWindow(SW_SHOW) for child with invisible parent */
993 static const struct message WmShowChildInvisibleParentSeq_5[] = {
994 { WM_SHOWWINDOW, sent|wparam, 1 },
995 { 0 }
996 };
997 /* ShowWindow(SW_HIDE) for child with invisible parent */
998 static const struct message WmHideChildInvisibleParentSeq[] = {
999 { WM_SHOWWINDOW, sent|wparam, 0 },
1000 { 0 }
1001 };
1002 /* SetWindowPos(SWP_SHOWWINDOW) for child with invisible parent */
1003 static const struct message WmShowChildInvisibleParentSeq_6[] = {
1004 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1005 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1006 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1007 { 0 }
1008 };
1009 /* SetWindowPos(SWP_HIDEWINDOW) for child with invisible parent */
1010 static const struct message WmHideChildInvisibleParentSeq_2[] = {
1011 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1012 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1013 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1014 { 0 }
1015 };
1016 /* DestroyWindow for a visible child window */
1017 static const struct message WmDestroyChildSeq[] = {
1018 { HCBT_DESTROYWND, hook },
1019 { 0x0090, sent|optional },
1020 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1021 { WM_SHOWWINDOW, sent|wparam, 0 },
1022 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1023 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1024 { WM_ERASEBKGND, sent|parent|optional },
1025 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1026 { HCBT_SETFOCUS, hook }, /* set focus to a parent */
1027 { WM_KILLFOCUS, sent },
1028 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1029 { WM_IME_SETCONTEXT, sent|wparam|parent|optional, 1 },
1030 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1031 { WM_SETFOCUS, sent|parent },
1032 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1033 { WM_DESTROY, sent },
1034 { WM_DESTROY, sent|optional }, /* some other (IME?) window */
1035 { WM_NCDESTROY, sent|optional }, /* some other (IME?) window */
1036 { WM_NCDESTROY, sent },
1037 { 0 }
1038 };
1039 /* DestroyWindow for a visible child window with invisible parent */
1040 static const struct message WmDestroyInvisibleChildSeq[] = {
1041 { HCBT_DESTROYWND, hook },
1042 { 0x0090, sent|optional },
1043 { WM_PARENTNOTIFY, sent|parent|wparam, WM_DESTROY },
1044 { WM_SHOWWINDOW, sent|wparam, 0 },
1045 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1046 { WM_DESTROY, sent },
1047 { WM_NCDESTROY, sent },
1048 { 0 }
1049 };
1050 /* Moving the mouse in nonclient area */
1051 static const struct message WmMouseMoveInNonClientAreaSeq[] = { /* FIXME: add */
1052 { WM_NCHITTEST, sent },
1053 { WM_SETCURSOR, sent },
1054 { WM_NCMOUSEMOVE, posted },
1055 { 0 }
1056 };
1057 /* Moving the mouse in client area */
1058 static const struct message WmMouseMoveInClientAreaSeq[] = { /* FIXME: add */
1059 { WM_NCHITTEST, sent },
1060 { WM_SETCURSOR, sent },
1061 { WM_MOUSEMOVE, posted },
1062 { 0 }
1063 };
1064 /* Moving by dragging the title bar (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
1065 static const struct message WmDragTitleBarSeq[] = { /* FIXME: add */
1066 { WM_NCLBUTTONDOWN, sent|wparam, HTCAPTION },
1067 { WM_SYSCOMMAND, sent|defwinproc|wparam, SC_MOVE+2 },
1068 { WM_GETMINMAXINFO, sent|defwinproc },
1069 { WM_ENTERSIZEMOVE, sent|defwinproc },
1070 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
1071 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
1072 { WM_MOVE, sent|defwinproc },
1073 { WM_EXITSIZEMOVE, sent|defwinproc },
1074 { 0 }
1075 };
1076 /* Sizing by dragging the thick borders (after WM_NCHITTEST and WM_SETCURSOR) (outline move) */
1077 static const struct message WmDragThickBordersBarSeq[] = { /* FIXME: add */
1078 { WM_NCLBUTTONDOWN, sent|wparam, 0xd },
1079 { WM_SYSCOMMAND, sent|defwinproc|wparam, 0xf004 },
1080 { WM_GETMINMAXINFO, sent|defwinproc },
1081 { WM_ENTERSIZEMOVE, sent|defwinproc },
1082 { WM_SIZING, sent|defwinproc|wparam, 4}, /* one for each mouse movement */
1083 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, 0 },
1084 { WM_GETMINMAXINFO, sent|defwinproc },
1085 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
1086 { WM_NCPAINT, sent|defwinproc|wparam, 1 },
1087 { WM_GETTEXT, sent|defwinproc },
1088 { WM_ERASEBKGND, sent|defwinproc },
1089 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, 0 },
1090 { WM_MOVE, sent|defwinproc },
1091 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1092 { WM_EXITSIZEMOVE, sent|defwinproc },
1093 { 0 }
1094 };
1095 /* Resizing child window with MoveWindow (32) */
1096 static const struct message WmResizingChildWithMoveWindowSeq[] = {
1097 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
1098 { WM_NCCALCSIZE, sent|wparam, 1 },
1099 { WM_ERASEBKGND, sent|parent|optional },
1100 { WM_ERASEBKGND, sent|optional },
1101 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE },
1102 { WM_MOVE, sent|defwinproc },
1103 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1104 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1105 { 0 }
1106 };
1107 /* Clicking on inactive button */
1108 static const struct message WmClickInactiveButtonSeq[] = { /* FIXME: add */
1109 { WM_NCHITTEST, sent },
1110 { WM_PARENTNOTIFY, sent|parent|wparam, WM_LBUTTONDOWN },
1111 { WM_MOUSEACTIVATE, sent },
1112 { WM_MOUSEACTIVATE, sent|parent|defwinproc },
1113 { WM_SETCURSOR, sent },
1114 { WM_SETCURSOR, sent|parent|defwinproc },
1115 { WM_LBUTTONDOWN, posted },
1116 { WM_KILLFOCUS, posted|parent },
1117 { WM_SETFOCUS, posted },
1118 { WM_CTLCOLORBTN, posted|parent },
1119 { BM_SETSTATE, posted },
1120 { WM_CTLCOLORBTN, posted|parent },
1121 { WM_LBUTTONUP, posted },
1122 { BM_SETSTATE, posted },
1123 { WM_CTLCOLORBTN, posted|parent },
1124 { WM_COMMAND, posted|parent },
1125 { 0 }
1126 };
1127 /* Reparenting a button (16/32) */
1128 /* The last child (button) reparented gets topmost for its new parent. */
1129 static const struct message WmReparentButtonSeq[] = { /* FIXME: add */
1130 { WM_SHOWWINDOW, sent|wparam, 0 },
1131 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1132 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1133 { WM_ERASEBKGND, sent|parent },
1134 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1135 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE },
1136 { WM_CHILDACTIVATE, sent },
1137 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOREDRAW },
1138 { WM_MOVE, sent|defwinproc },
1139 { WM_SHOWWINDOW, sent|wparam, 1 },
1140 { 0 }
1141 };
1142 /* Creation of a custom dialog (32) */
1143 static const struct message WmCreateCustomDialogSeq[] = {
1144 { HCBT_CREATEWND, hook },
1145 { WM_GETMINMAXINFO, sent },
1146 { WM_NCCREATE, sent },
1147 { WM_NCCALCSIZE, sent|wparam, 0 },
1148 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1149 { WM_CREATE, sent },
1150 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1151 { WM_SHOWWINDOW, sent|wparam, 1 },
1152 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1153 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1154 { HCBT_ACTIVATE, hook },
1155 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1156
1157
1158 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1159
1160 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1161
1162 { WM_NCACTIVATE, sent|wparam, 1 },
1163 { WM_GETTEXT, sent|optional|defwinproc },
1164 { WM_GETTEXT, sent|optional|defwinproc },
1165 { EVENT_OBJECT_DEFACTIONCHANGE, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
1166 { WM_ACTIVATE, sent|wparam, 1 },
1167 { WM_KILLFOCUS, sent|parent },
1168 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1169 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1170 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1171 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1172 { WM_SETFOCUS, sent },
1173 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1174 { WM_NCPAINT, sent|wparam, 1 },
1175 { WM_GETTEXT, sent|optional|defwinproc },
1176 { WM_GETTEXT, sent|optional|defwinproc },
1177 { WM_ERASEBKGND, sent },
1178 { WM_CTLCOLORDLG, sent|defwinproc },
1179 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1180 { WM_GETTEXT, sent|optional },
1181 { WM_GETTEXT, sent|optional },
1182 { WM_NCCALCSIZE, sent|optional },
1183 { WM_NCPAINT, sent|optional },
1184 { WM_GETTEXT, sent|optional|defwinproc },
1185 { WM_GETTEXT, sent|optional|defwinproc },
1186 { WM_ERASEBKGND, sent|optional },
1187 { WM_CTLCOLORDLG, sent|optional|defwinproc },
1188 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1189 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1190 { WM_MOVE, sent },
1191 { 0 }
1192 };
1193 /* Calling EndDialog for a custom dialog (32) */
1194 static const struct message WmEndCustomDialogSeq[] = {
1195 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1196 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1197 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1198 { WM_GETTEXT, sent|optional },
1199 { HCBT_ACTIVATE, hook },
1200 { WM_NCACTIVATE, sent|wparam, 0 },
1201 { WM_GETTEXT, sent|optional|defwinproc },
1202 { WM_GETTEXT, sent|optional|defwinproc },
1203 { WM_ACTIVATE, sent|wparam, 0 },
1204 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1205 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1206 { HCBT_SETFOCUS, hook },
1207 { WM_KILLFOCUS, sent },
1208 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
1209 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1210 { WM_IME_NOTIFY, sent|wparam|optional, 1 },
1211 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1212 { WM_SETFOCUS, sent|parent|defwinproc },
1213 { 0 }
1214 };
1215 /* ShowWindow(SW_SHOW) for a custom dialog (initially invisible) */
1216 static const struct message WmShowCustomDialogSeq[] = {
1217 { WM_SHOWWINDOW, sent|wparam, 1 },
1218 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1219 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1220 { HCBT_ACTIVATE, hook },
1221 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1222
1223 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1224
1225 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1226 { WM_ACTIVATEAPP, sent|wparam|optional, 1 },
1227 { WM_NCACTIVATE, sent|wparam, 1 },
1228 { WM_ACTIVATE, sent|wparam, 1 },
1229
1230 { WM_KILLFOCUS, sent|parent },
1231 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1232 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
1233 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1234 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1235 { WM_SETFOCUS, sent },
1236 { WM_GETDLGCODE, sent|defwinproc|wparam, 0 },
1237 { WM_NCPAINT, sent|wparam, 1 },
1238 { WM_ERASEBKGND, sent },
1239 { WM_CTLCOLORDLG, sent|defwinproc },
1240 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1241 { 0 }
1242 };
1243 /* Creation and destruction of a modal dialog (32) */
1244 static const struct message WmModalDialogSeq[] = {
1245 { WM_CANCELMODE, sent|parent },
1246 { HCBT_SETFOCUS, hook },
1247 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1248 { WM_KILLFOCUS, sent|parent },
1249 { WM_IME_SETCONTEXT, sent|parent|wparam|optional, 0 },
1250 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1251 { WM_ENABLE, sent|parent|wparam, 0 },
1252 { HCBT_CREATEWND, hook },
1253 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1254 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1255 { WM_SETFONT, sent },
1256 { WM_INITDIALOG, sent },
1257 { WM_CHANGEUISTATE, sent|optional },
1258 { WM_UPDATEUISTATE, sent|optional },
1259 { WM_SHOWWINDOW, sent },
1260 { HCBT_ACTIVATE, hook },
1261 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1262 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1263 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
1264 { WM_NCACTIVATE, sent|wparam, 1 },
1265 { WM_GETTEXT, sent|optional },
1266 { WM_ACTIVATE, sent|wparam, 1 },
1267 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1268 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1269 { WM_NCPAINT, sent },
1270 { WM_GETTEXT, sent|optional },
1271 { WM_ERASEBKGND, sent },
1272 { WM_CTLCOLORDLG, sent },
1273 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1274 { WM_GETTEXT, sent|optional },
1275 { WM_NCCALCSIZE, sent|optional },
1276 { WM_NCPAINT, sent|optional },
1277 { WM_GETTEXT, sent|optional },
1278 { WM_ERASEBKGND, sent|optional },
1279 { WM_CTLCOLORDLG, sent|optional },
1280 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1281 { WM_PAINT, sent|optional },
1282 { WM_CTLCOLORBTN, sent },
1283 { WM_ENTERIDLE, sent|parent|optional },
1284 { WM_ENTERIDLE, sent|parent|optional },
1285 { WM_ENTERIDLE, sent|parent|optional },
1286 { WM_ENTERIDLE, sent|parent|optional },
1287 { WM_ENTERIDLE, sent|parent|optional },
1288 { WM_ENTERIDLE, sent|parent|optional },
1289 { WM_ENTERIDLE, sent|parent|optional },
1290 { WM_ENTERIDLE, sent|parent|optional },
1291 { WM_ENTERIDLE, sent|parent|optional },
1292 { WM_ENTERIDLE, sent|parent|optional },
1293 { WM_ENTERIDLE, sent|parent|optional },
1294 { WM_ENTERIDLE, sent|parent|optional },
1295 { WM_ENTERIDLE, sent|parent|optional },
1296 { WM_ENTERIDLE, sent|parent|optional },
1297 { WM_ENTERIDLE, sent|parent|optional },
1298 { WM_ENTERIDLE, sent|parent|optional },
1299 { WM_ENTERIDLE, sent|parent|optional },
1300 { WM_ENTERIDLE, sent|parent|optional },
1301 { WM_ENTERIDLE, sent|parent|optional },
1302 { WM_ENTERIDLE, sent|parent|optional },
1303 { WM_TIMER, sent },
1304 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1305 { WM_ENABLE, sent|parent|wparam, 1 },
1306 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1307 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1308 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1309 { WM_GETTEXT, sent|optional },
1310 { HCBT_ACTIVATE, hook },
1311 { WM_NCACTIVATE, sent|wparam, 0 },
1312 { WM_GETTEXT, sent|optional },
1313 { WM_ACTIVATE, sent|wparam, 0 },
1314 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1315 { WM_WINDOWPOSCHANGING, sent|optional },
1316 { WM_WINDOWPOSCHANGED, sent|optional },
1317 { HCBT_SETFOCUS, hook },
1318 { WM_IME_SETCONTEXT, sent|parent|wparam|defwinproc|optional, 1 },
1319 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1320 { WM_SETFOCUS, sent|parent|defwinproc },
1321 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, 0, 0 },
1322 { HCBT_DESTROYWND, hook },
1323 { 0x0090, sent|optional },
1324 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1325 { WM_DESTROY, sent },
1326 { WM_NCDESTROY, sent },
1327 { 0 }
1328 };
1329 /* Creation of a modal dialog that is resized inside WM_INITDIALOG (32) */
1330 static const struct message WmCreateModalDialogResizeSeq[] = { /* FIXME: add */
1331 /* (inside dialog proc, handling WM_INITDIALOG) */
1332 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1333 { WM_NCCALCSIZE, sent },
1334 { WM_NCACTIVATE, sent|parent|wparam, 0 },
1335 { WM_GETTEXT, sent|defwinproc },
1336 { WM_ACTIVATE, sent|parent|wparam, 0 },
1337 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1338 { WM_WINDOWPOSCHANGING, sent|parent },
1339 { WM_NCACTIVATE, sent|wparam, 1 },
1340 { WM_ACTIVATE, sent|wparam, 1 },
1341 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1342 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1343 /* (setting focus) */
1344 { WM_SHOWWINDOW, sent|wparam, 1 },
1345 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
1346 { WM_NCPAINT, sent },
1347 { WM_GETTEXT, sent|defwinproc },
1348 { WM_ERASEBKGND, sent },
1349 { WM_CTLCOLORDLG, sent|defwinproc },
1350 { WM_WINDOWPOSCHANGED, sent|wparam, 0 },
1351 { WM_PAINT, sent },
1352 /* (bunch of WM_CTLCOLOR* for each control) */
1353 { WM_PAINT, sent|parent },
1354 { WM_ENTERIDLE, sent|parent|wparam, 0 },
1355 { WM_SETCURSOR, sent|parent },
1356 { 0 }
1357 };
1358 /* SetMenu for NonVisible windows with size change*/
1359 static const struct message WmSetMenuNonVisibleSizeChangeSeq[] = {
1360 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1361 { WM_NCCALCSIZE, sent|wparam, 1 },
1362 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1363 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
1364 { WM_MOVE, sent|defwinproc },
1365 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1366 { WM_NCCALCSIZE,sent|wparam|optional, 1 }, /* XP */
1367 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1368 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1369 { WM_GETTEXT, sent|optional },
1370 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1371 { 0 }
1372 };
1373 /* SetMenu for NonVisible windows with no size change */
1374 static const struct message WmSetMenuNonVisibleNoSizeChangeSeq[] = {
1375 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1376 { WM_NCCALCSIZE, sent|wparam, 1 },
1377 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1378 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1379 { 0 }
1380 };
1381 /* SetMenu for Visible windows with size change */
1382 static const struct message WmSetMenuVisibleSizeChangeSeq[] = {
1383 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1384 { WM_NCCALCSIZE, sent|wparam, 1 },
1385 { 0x0093, sent|defwinproc|optional },
1386 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1387 { WM_NCPAINT, sent }, /* wparam != 1 */
1388 { 0x0093, sent|defwinproc|optional },
1389 { 0x0093, sent|defwinproc|optional },
1390 { 0x0091, sent|defwinproc|optional },
1391 { 0x0092, sent|defwinproc|optional },
1392 { WM_GETTEXT, sent|defwinproc|optional },
1393 { WM_ERASEBKGND, sent|optional },
1394 { WM_ACTIVATE, sent|optional },
1395 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1396 { WM_MOVE, sent|defwinproc },
1397 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1398 { 0x0093, sent|optional },
1399 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1400 { 0x0093, sent|defwinproc|optional },
1401 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
1402 { 0x0093, sent|defwinproc|optional },
1403 { 0x0093, sent|defwinproc|optional },
1404 { 0x0091, sent|defwinproc|optional },
1405 { 0x0092, sent|defwinproc|optional },
1406 { WM_ERASEBKGND, sent|optional },
1407 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1408 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP sends a duplicate */
1409 { 0 }
1410 };
1411 /* SetMenu for Visible windows with no size change */
1412 static const struct message WmSetMenuVisibleNoSizeChangeSeq[] = {
1413 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1414 { WM_NCCALCSIZE, sent|wparam, 1 },
1415 { WM_NCPAINT, sent }, /* wparam != 1 */
1416 { WM_GETTEXT, sent|defwinproc|optional },
1417 { WM_ERASEBKGND, sent|optional },
1418 { WM_ACTIVATE, sent|optional },
1419 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1420 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1421 { 0 }
1422 };
1423 /* DrawMenuBar for a visible window */
1424 static const struct message WmDrawMenuBarSeq[] =
1425 {
1426 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1427 { WM_NCCALCSIZE, sent|wparam, 1 },
1428 { 0x0093, sent|defwinproc|optional },
1429 { WM_NCPAINT, sent }, /* wparam != 1 */
1430 { 0x0093, sent|defwinproc|optional },
1431 { 0x0093, sent|defwinproc|optional },
1432 { 0x0091, sent|defwinproc|optional },
1433 { 0x0092, sent|defwinproc|optional },
1434 { WM_GETTEXT, sent|defwinproc|optional },
1435 { WM_ERASEBKGND, sent|optional },
1436 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1437 { 0x0093, sent|optional },
1438 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1439 { 0 }
1440 };
1441
1442 static const struct message WmSetRedrawFalseSeq[] =
1443 {
1444 { WM_SETREDRAW, sent|wparam, 0 },
1445 { 0 }
1446 };
1447
1448 static const struct message WmSetRedrawTrueSeq[] =
1449 {
1450 { WM_SETREDRAW, sent|wparam, 1 },
1451 { 0 }
1452 };
1453
1454 static const struct message WmEnableWindowSeq_1[] =
1455 {
1456 { WM_CANCELMODE, sent|wparam|lparam, 0, 0 },
1457 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1458 { WM_ENABLE, sent|wparam|lparam, FALSE, 0 },
1459 { 0 }
1460 };
1461
1462 static const struct message WmEnableWindowSeq_2[] =
1463 {
1464 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, 0, 0 },
1465 { WM_ENABLE, sent|wparam|lparam, TRUE, 0 },
1466 { 0 }
1467 };
1468
1469 static const struct message WmGetScrollRangeSeq[] =
1470 {
1471 { SBM_GETRANGE, sent },
1472 { 0 }
1473 };
1474 static const struct message WmGetScrollInfoSeq[] =
1475 {
1476 { SBM_GETSCROLLINFO, sent },
1477 { 0 }
1478 };
1479 static const struct message WmSetScrollRangeSeq[] =
1480 {
1481 /* MSDN claims that Windows sends SBM_SETRANGE message, but win2k SP4
1482 sends SBM_SETSCROLLINFO.
1483 */
1484 { SBM_SETSCROLLINFO, sent },
1485 { 0 }
1486 };
1487 /* SetScrollRange for a window without a non-client area */
1488 static const struct message WmSetScrollRangeHSeq_empty[] =
1489 {
1490 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_HSCROLL, 0 },
1491 { 0 }
1492 };
1493 static const struct message WmSetScrollRangeVSeq_empty[] =
1494 {
1495 { EVENT_OBJECT_VALUECHANGE, winevent_hook|wparam|lparam, OBJID_VSCROLL, 0 },
1496 { 0 }
1497 };
1498 static const struct message WmSetScrollRangeHVSeq[] =
1499 {
1500 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1501 { WM_NCCALCSIZE, sent|wparam, 1 },
1502 { WM_GETTEXT, sent|defwinproc|optional },
1503 { WM_ERASEBKGND, sent|optional },
1504 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1505 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1506 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1507 { 0 }
1508 };
1509 /* SetScrollRange for a window with a non-client area */
1510 static const struct message WmSetScrollRangeHV_NC_Seq[] =
1511 {
1512 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE },
1513 { WM_NCCALCSIZE, sent|wparam, 1 },
1514 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1515 { WM_NCPAINT, sent|optional },
1516 { WM_STYLECHANGING, sent|defwinproc|optional },
1517 { WM_STYLECHANGED, sent|defwinproc|optional },
1518 { WM_STYLECHANGING, sent|defwinproc|optional },
1519 { WM_STYLECHANGED, sent|defwinproc|optional },
1520 { WM_STYLECHANGING, sent|defwinproc|optional },
1521 { WM_STYLECHANGED, sent|defwinproc|optional },
1522 { WM_STYLECHANGING, sent|defwinproc|optional },
1523 { WM_STYLECHANGED, sent|defwinproc|optional },
1524 { WM_GETTEXT, sent|defwinproc|optional },
1525 { WM_GETTEXT, sent|defwinproc|optional },
1526 { WM_ERASEBKGND, sent|optional },
1527 { WM_CTLCOLORDLG, sent|defwinproc|optional }, /* sent to a parent of the dialog */
1528 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTMOVE },
1529 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
1530 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1531 { EVENT_OBJECT_VALUECHANGE, winevent_hook|lparam|optional, 0/*OBJID_HSCROLL or OBJID_VSCROLL*/, 0 },
1532 { WM_GETTEXT, sent|optional },
1533 { WM_GETTEXT, sent|optional },
1534 { WM_GETTEXT, sent|optional },
1535 { WM_GETTEXT, sent|optional },
1536 { 0 }
1537 };
1538 /* test if we receive the right sequence of messages */
1539 /* after calling ShowWindow( SW_SHOWNA) */
1540 static const struct message WmSHOWNAChildInvisParInvis[] = {
1541 { WM_SHOWWINDOW, sent|wparam, 1 },
1542 { 0 }
1543 };
1544 static const struct message WmSHOWNAChildVisParInvis[] = {
1545 { WM_SHOWWINDOW, sent|wparam, 1 },
1546 { 0 }
1547 };
1548 static const struct message WmSHOWNAChildVisParVis[] = {
1549 { WM_SHOWWINDOW, sent|wparam, 1 },
1550 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1551 { 0 }
1552 };
1553 static const struct message WmSHOWNAChildInvisParVis[] = {
1554 { WM_SHOWWINDOW, sent|wparam, 1 },
1555 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1556 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1557 { WM_ERASEBKGND, sent|optional },
1558 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOACTIVATE|SWP_NOCLIENTMOVE },
1559 { 0 }
1560 };
1561 static const struct message WmSHOWNATopVisible[] = {
1562 { WM_SHOWWINDOW, sent|wparam, 1 },
1563 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
1564 { 0 }
1565 };
1566 static const struct message WmSHOWNATopInvisible[] = {
1567 { WM_SHOWWINDOW, sent|wparam, 1 },
1568 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1569 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1570 { WM_NCPAINT, sent|wparam, 1 },
1571 { WM_GETTEXT, sent|defwinproc|optional },
1572 { WM_ERASEBKGND, sent|optional },
1573 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1574 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
1575 { WM_NCPAINT, sent|wparam|optional, 1 },
1576 { WM_ERASEBKGND, sent|optional },
1577 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1578 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1579 { WM_MOVE, sent },
1580 { 0 }
1581 };
1582
1583 static int after_end_dialog, test_def_id;
1584 static int sequence_cnt, sequence_size;
1585 static struct message* sequence;
1586 static int log_all_parent_messages;
1587 static int paint_loop_done;
1588
1589 /* user32 functions */
1590 static HWND (WINAPI *pGetAncestor)(HWND,UINT);
1591 static BOOL (WINAPI *pGetMenuInfo)(HMENU,LPCMENUINFO);
1592 static void (WINAPI *pNotifyWinEvent)(DWORD, HWND, LONG, LONG);
1593 static BOOL (WINAPI *pSetMenuInfo)(HMENU,LPCMENUINFO);
1594 static HWINEVENTHOOK (WINAPI *pSetWinEventHook)(DWORD, DWORD, HMODULE, WINEVENTPROC, DWORD, DWORD, DWORD);
1595 static BOOL (WINAPI *pTrackMouseEvent)(TRACKMOUSEEVENT*);
1596 static BOOL (WINAPI *pUnhookWinEvent)(HWINEVENTHOOK);
1597 /* kernel32 functions */
1598 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
1599
1600 static void init_procs(void)
1601 {
1602 HMODULE user32 = GetModuleHandleA("user32.dll");
1603 HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
1604
1605 #define GET_PROC(dll, func) \
1606 p ## func = (void*)GetProcAddress(dll, #func); \
1607 if(!p ## func) { \
1608 trace("GetProcAddress(%s) failed\n", #func); \
1609 }
1610
1611 GET_PROC(user32, GetAncestor)
1612 GET_PROC(user32, GetMenuInfo)
1613 GET_PROC(user32, NotifyWinEvent)
1614 GET_PROC(user32, SetMenuInfo)
1615 GET_PROC(user32, SetWinEventHook)
1616 GET_PROC(user32, TrackMouseEvent)
1617 GET_PROC(user32, UnhookWinEvent)
1618
1619 GET_PROC(kernel32, GetCPInfoExA)
1620
1621 #undef GET_PROC
1622 }
1623
1624 static void add_message(const struct message *msg)
1625 {
1626 if (!sequence)
1627 {
1628 sequence_size = 10;
1629 sequence = HeapAlloc( GetProcessHeap(), 0, sequence_size * sizeof (struct message) );
1630 }
1631 if (sequence_cnt == sequence_size)
1632 {
1633 sequence_size *= 2;
1634 sequence = HeapReAlloc( GetProcessHeap(), 0, sequence, sequence_size * sizeof (struct message) );
1635 }
1636 assert(sequence);
1637
1638 sequence[sequence_cnt].message = msg->message;
1639 sequence[sequence_cnt].flags = msg->flags;
1640 sequence[sequence_cnt].wParam = msg->wParam;
1641 sequence[sequence_cnt].lParam = msg->lParam;
1642
1643 sequence_cnt++;
1644 }
1645
1646 /* try to make sure pending X events have been processed before continuing */
1647 static void flush_events(void)
1648 {
1649 MSG msg;
1650 int diff = 200;
1651 int min_timeout = 50;
1652 DWORD time = GetTickCount() + diff;
1653
1654 while (diff > 0)
1655 {
1656 if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
1657 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
1658 diff = time - GetTickCount();
1659 min_timeout = 10;
1660 }
1661 }
1662
1663 static void flush_sequence(void)
1664 {
1665 HeapFree(GetProcessHeap(), 0, sequence);
1666 sequence = 0;
1667 sequence_cnt = sequence_size = 0;
1668 }
1669
1670 #define ok_sequence( exp, contx, todo) \
1671 ok_sequence_( (exp), (contx), (todo), __FILE__, __LINE__)
1672
1673
1674 static void ok_sequence_(const struct message *expected, const char *context, int todo,
1675 const char *file, int line)
1676 {
1677 static const struct message end_of_sequence = { 0, 0, 0, 0 };
1678 const struct message *actual;
1679 int failcount = 0;
1680
1681 add_message(&end_of_sequence);
1682
1683 actual = sequence;
1684
1685 while (expected->message && actual->message)
1686 {
1687 trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
1688
1689 if (expected->message == actual->message)
1690 {
1691 if (expected->flags & wparam)
1692 {
1693 if (expected->wParam != actual->wParam && todo)
1694 {
1695 todo_wine {
1696 failcount ++;
1697 ok_( file, line) (FALSE,
1698 "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
1699 context, expected->message, expected->wParam, actual->wParam);
1700 }
1701 }
1702 else
1703 ok_( file, line) (expected->wParam == actual->wParam,
1704 "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
1705 context, expected->message, expected->wParam, actual->wParam);
1706 }
1707 if (expected->flags & lparam)
1708 {
1709 if (expected->lParam != actual->lParam && todo)
1710 {
1711 todo_wine {
1712 failcount ++;
1713 ok_( file, line) (FALSE,
1714 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1715 context, expected->message, expected->lParam, actual->lParam);
1716 }
1717 }
1718 else
1719 ok_( file, line) (expected->lParam == actual->lParam,
1720 "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
1721 context, expected->message, expected->lParam, actual->lParam);
1722 }
1723 if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
1724 {
1725 todo_wine {
1726 failcount ++;
1727 ok_( file, line) (FALSE,
1728 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1729 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1730 }
1731 }
1732 else
1733 ok_( file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
1734 "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
1735 context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
1736 ok_( file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
1737 "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
1738 context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
1739 ok_( file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
1740 "%s: the msg 0x%04x should have been %s\n",
1741 context, expected->message, (expected->flags & posted) ? "posted" : "sent");
1742 ok_( file, line) ((expected->flags & parent) == (actual->flags & parent),
1743 "%s: the msg 0x%04x was expected in %s\n",
1744 context, expected->message, (expected->flags & parent) ? "parent" : "child");
1745 ok_( file, line) ((expected->flags & hook) == (actual->flags & hook),
1746 "%s: the msg 0x%04x should have been sent by a hook\n",
1747 context, expected->message);
1748 ok_( file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
1749 "%s: the msg 0x%04x should have been sent by a winevent hook\n",
1750 context, expected->message);
1751 expected++;
1752 actual++;
1753 }
1754 /* silently drop winevent messages if there is no support for them */
1755 else if ((expected->flags & optional) || ((expected->flags & winevent_hook) && !hEvent_hook))
1756 expected++;
1757 else if (todo)
1758 {
1759 failcount++;
1760 todo_wine {
1761 ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1762 context, expected->message, actual->message);
1763 }
1764 flush_sequence();
1765 return;
1766 }
1767 else
1768 {
1769 ok_( file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
1770 context, expected->message, actual->message);
1771 expected++;
1772 actual++;
1773 }
1774 }
1775
1776 /* skip all optional trailing messages */
1777 while (expected->message && ((expected->flags & optional) ||
1778 ((expected->flags & winevent_hook) && !hEvent_hook)))
1779 expected++;
1780
1781 if (todo)
1782 {
1783 todo_wine {
1784 if (expected->message || actual->message) {
1785 failcount++;
1786 ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1787 context, expected->message, actual->message);
1788 }
1789 }
1790 }
1791 else
1792 {
1793 if (expected->message || actual->message)
1794 ok_( file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
1795 context, expected->message, actual->message);
1796 }
1797 if( todo && !failcount) /* succeeded yet marked todo */
1798 todo_wine {
1799 ok_( file, line)( TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
1800 }
1801
1802 flush_sequence();
1803 }
1804
1805 #define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))
1806
1807 /******************************** MDI test **********************************/
1808
1809 /* CreateWindow for MDI frame window, initially visible */
1810 static const struct message WmCreateMDIframeSeq[] = {
1811 { HCBT_CREATEWND, hook },
1812 { WM_GETMINMAXINFO, sent },
1813 { WM_NCCREATE, sent },
1814 { WM_NCCALCSIZE, sent|wparam, 0 },
1815 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
1816 { WM_CREATE, sent },
1817 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1818 { WM_SHOWWINDOW, sent|wparam, 1 },
1819 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1820 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1821 { HCBT_ACTIVATE, hook },
1822 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, 0, 0 },
1823 { WM_QUERYNEWPALETTE, sent|wparam|lparam|optional, 0, 0 },
1824 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* XP */
1825 { WM_ACTIVATEAPP, sent|wparam|optional, 1 }, /* Win9x doesn't send it */
1826 { WM_NCACTIVATE, sent|wparam, 1 },
1827 { WM_GETTEXT, sent|defwinproc|optional },
1828 { WM_ACTIVATE, sent|wparam, 1 },
1829 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* Win9x */
1830 { HCBT_SETFOCUS, hook },
1831 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1832 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
1833 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1834 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
1835 /* Win9x adds SWP_NOZORDER below */
1836 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1837 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
1838 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
1839 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1840 { WM_MOVE, sent },
1841 { 0 }
1842 };
1843 /* DestroyWindow for MDI frame window, initially visible */
1844 static const struct message WmDestroyMDIframeSeq[] = {
1845 { HCBT_DESTROYWND, hook },
1846 { 0x0090, sent|optional },
1847 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1848 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1849 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
1850 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1851 { WM_NCACTIVATE, sent|wparam|optional, 0 }, /* XP */
1852 { WM_ACTIVATE, sent|wparam|optional, 0 }, /* Win9x */
1853 { WM_ACTIVATEAPP, sent|wparam|optional, 0 }, /* Win9x */
1854 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
1855 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1856 { WM_DESTROY, sent },
1857 { WM_NCDESTROY, sent },
1858 { 0 }
1859 };
1860 /* CreateWindow for MDI client window, initially visible */
1861 static const struct message WmCreateMDIclientSeq[] = {
1862 { HCBT_CREATEWND, hook },
1863 { WM_NCCREATE, sent },
1864 { WM_NCCALCSIZE, sent|wparam, 0 },
1865 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1866 { WM_CREATE, sent },
1867 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1868 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1869 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1870 { WM_MOVE, sent },
1871 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE }, /* in MDI frame */
1872 { WM_SHOWWINDOW, sent|wparam, 1 },
1873 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1874 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1875 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1876 { 0 }
1877 };
1878 /* ShowWindow(SW_SHOW) for MDI client window */
1879 static const struct message WmShowMDIclientSeq[] = {
1880 { WM_SHOWWINDOW, sent|wparam, 1 },
1881 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1882 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1883 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1884 { 0 }
1885 };
1886 /* ShowWindow(SW_HIDE) for MDI client window */
1887 static const struct message WmHideMDIclientSeq[] = {
1888 { WM_SHOWWINDOW, sent|wparam, 0 },
1889 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1890 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* win2000 */
1891 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP */
1892 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1893 { 0 }
1894 };
1895 /* DestroyWindow for MDI client window, initially visible */
1896 static const struct message WmDestroyMDIclientSeq[] = {
1897 { HCBT_DESTROYWND, hook },
1898 { 0x0090, sent|optional },
1899 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY }, /* in MDI frame */
1900 { WM_SHOWWINDOW, sent|wparam, 0 },
1901 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1902 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1903 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1904 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
1905 { WM_DESTROY, sent },
1906 { WM_NCDESTROY, sent },
1907 { 0 }
1908 };
1909 /* CreateWindow for MDI child window, initially visible */
1910 static const struct message WmCreateMDIchildVisibleSeq[] = {
1911 { HCBT_CREATEWND, hook },
1912 { WM_NCCREATE, sent },
1913 { WM_NCCALCSIZE, sent|wparam, 0 },
1914 { WM_CREATE, sent },
1915 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1916 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1917 { WM_MOVE, sent },
1918 /* Win2k sends wparam set to
1919 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
1920 * while Win9x doesn't bother to set child window id according to
1921 * CLIENTCREATESTRUCT.idFirstChild
1922 */
1923 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1924 { WM_SHOWWINDOW, sent|wparam, 1 },
1925 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1926 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
1927 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
1928 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
1929 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1930 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1931 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1932
1933 /* Win9x: message sequence terminates here. */
1934
1935 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1936 { HCBT_SETFOCUS, hook }, /* in MDI client */
1937 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1938 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
1939 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1940 { WM_SETFOCUS, sent }, /* in MDI client */
1941 { HCBT_SETFOCUS, hook },
1942 { WM_KILLFOCUS, sent }, /* in MDI client */
1943 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1944 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1945 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1946 { WM_SETFOCUS, sent|defwinproc },
1947 { WM_MDIACTIVATE, sent|defwinproc },
1948 { 0 }
1949 };
1950 /* CreateWindow for MDI child window with invisible parent */
1951 static const struct message WmCreateMDIchildInvisibleParentSeq[] = {
1952 { HCBT_CREATEWND, hook },
1953 { WM_GETMINMAXINFO, sent },
1954 { WM_NCCREATE, sent },
1955 { WM_NCCALCSIZE, sent|wparam, 0 },
1956 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam|optional, 0, 0 },
1957 { WM_CREATE, sent },
1958 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
1959 { WM_SIZE, sent|wparam, SIZE_RESTORED },
1960 { WM_MOVE, sent },
1961 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
1962 { WM_SHOWWINDOW, sent|wparam, 1 },
1963 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
1964 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
1965 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
1966 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1967
1968 /* Win9x: message sequence terminates here. */
1969
1970 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
1971 { HCBT_SETFOCUS, hook }, /* in MDI client */
1972 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
1973 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
1974 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1975 { WM_SETFOCUS, sent }, /* in MDI client */
1976 { HCBT_SETFOCUS, hook },
1977 { WM_KILLFOCUS, sent }, /* in MDI client */
1978 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
1979 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
1980 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
1981 { WM_SETFOCUS, sent|defwinproc },
1982 { WM_MDIACTIVATE, sent|defwinproc },
1983 { 0 }
1984 };
1985 /* DestroyWindow for MDI child window, initially visible */
1986 static const struct message WmDestroyMDIchildVisibleSeq[] = {
1987 { HCBT_DESTROYWND, hook },
1988 /* Win2k sends wparam set to
1989 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
1990 * while Win9x doesn't bother to set child window id according to
1991 * CLIENTCREATESTRUCT.idFirstChild
1992 */
1993 { 0x0090, sent|optional },
1994 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
1995 { WM_SHOWWINDOW, sent|wparam, 0 },
1996 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
1997 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
1998 { WM_ERASEBKGND, sent|parent|optional },
1999 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2000
2001 /* { WM_DESTROY, sent }
2002 * Win9x: message sequence terminates here.
2003 */
2004
2005 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2006 { WM_KILLFOCUS, sent },
2007 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2008 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2009 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2010 { WM_SETFOCUS, sent }, /* in MDI client */
2011
2012 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2013 { WM_KILLFOCUS, sent }, /* in MDI client */
2014 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2015 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2016 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2017 { WM_SETFOCUS, sent }, /* in MDI client */
2018
2019 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2020
2021 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2022 { WM_KILLFOCUS, sent },
2023 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2024 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2025 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2026 { WM_SETFOCUS, sent }, /* in MDI client */
2027
2028 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2029 { WM_KILLFOCUS, sent }, /* in MDI client */
2030 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2031 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2032 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2033 { WM_SETFOCUS, sent }, /* in MDI client */
2034
2035 { WM_DESTROY, sent },
2036
2037 { HCBT_SETFOCUS, hook }, /* set focus to MDI client */
2038 { WM_KILLFOCUS, sent },
2039 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2040 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2041 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2042 { WM_SETFOCUS, sent }, /* in MDI client */
2043
2044 { HCBT_SETFOCUS, hook }, /* MDI client sets focus back to MDI child */
2045 { WM_KILLFOCUS, sent }, /* in MDI client */
2046 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2047 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2048 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2049 { WM_SETFOCUS, sent }, /* in MDI client */
2050
2051 { WM_NCDESTROY, sent },
2052 { 0 }
2053 };
2054 /* CreateWindow for MDI child window, initially invisible */
2055 static const struct message WmCreateMDIchildInvisibleSeq[] = {
2056 { HCBT_CREATEWND, hook },
2057 { WM_NCCREATE, sent },
2058 { WM_NCCALCSIZE, sent|wparam, 0 },
2059 { WM_CREATE, sent },
2060 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2061 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2062 { WM_MOVE, sent },
2063 /* Win2k sends wparam set to
2064 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2065 * while Win9x doesn't bother to set child window id according to
2066 * CLIENTCREATESTRUCT.idFirstChild
2067 */
2068 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2069 { 0 }
2070 };
2071 /* DestroyWindow for MDI child window, initially invisible */
2072 static const struct message WmDestroyMDIchildInvisibleSeq[] = {
2073 { HCBT_DESTROYWND, hook },
2074 /* Win2k sends wparam set to
2075 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2076 * while Win9x doesn't bother to set child window id according to
2077 * CLIENTCREATESTRUCT.idFirstChild
2078 */
2079 { 0x0090, sent|optional },
2080 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2081 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2082 { WM_DESTROY, sent },
2083 { WM_NCDESTROY, sent },
2084 /* FIXME: Wine destroys an icon/title window while Windows doesn't */
2085 { WM_PARENTNOTIFY, sent|wparam|optional, WM_DESTROY }, /* MDI client */
2086 { 0 }
2087 };
2088 /* CreateWindow for the 1st MDI child window, initially visible and maximized */
2089 static const struct message WmCreateMDIchildVisibleMaxSeq1[] = {
2090 { HCBT_CREATEWND, hook },
2091 { WM_NCCREATE, sent },
2092 { WM_NCCALCSIZE, sent|wparam, 0 },
2093 { WM_CREATE, sent },
2094 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2095 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2096 { WM_MOVE, sent },
2097 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2098 { WM_GETMINMAXINFO, sent },
2099 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2100 { WM_NCCALCSIZE, sent|wparam, 1 },
2101 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2102 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2103 /* in MDI frame */
2104 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2105 { WM_NCCALCSIZE, sent|wparam, 1 },
2106 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2107 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2108 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2109 /* Win2k sends wparam set to
2110 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2111 * while Win9x doesn't bother to set child window id according to
2112 * CLIENTCREATESTRUCT.idFirstChild
2113 */
2114 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2115 { WM_SHOWWINDOW, sent|wparam, 1 },
2116 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2117 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2118 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2119 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2120 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2121 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2122 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2123
2124 /* Win9x: message sequence terminates here. */
2125
2126 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2127 { HCBT_SETFOCUS, hook }, /* in MDI client */
2128 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2129 { WM_IME_NOTIFY, sent|wparam|optional, 2 }, /* in MDI client */
2130 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2131 { WM_SETFOCUS, sent }, /* in MDI client */
2132 { HCBT_SETFOCUS, hook },
2133 { WM_KILLFOCUS, sent }, /* in MDI client */
2134 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2135 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2136 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2137 { WM_SETFOCUS, sent|defwinproc },
2138 { WM_MDIACTIVATE, sent|defwinproc },
2139 /* in MDI frame */
2140 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2141 { WM_NCCALCSIZE, sent|wparam, 1 },
2142 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2143 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2144 { 0 }
2145 };
2146 /* CreateWindow for the 2nd MDI child window, initially visible and maximized */
2147 static const struct message WmCreateMDIchildVisibleMaxSeq2[] = {
2148 /* restore the 1st MDI child */
2149 { WM_SETREDRAW, sent|wparam, 0 },
2150 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2151 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2152 { WM_NCCALCSIZE, sent|wparam, 1 },
2153 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2154 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2155 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2156 /* in MDI frame */
2157 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2158 { WM_NCCALCSIZE, sent|wparam, 1 },
2159 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2160 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2161 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2162 { WM_SETREDRAW, sent|wparam, 1 }, /* in the 1st MDI child */
2163 /* create the 2nd MDI child */
2164 { HCBT_CREATEWND, hook },
2165 { WM_NCCREATE, sent },
2166 { WM_NCCALCSIZE, sent|wparam, 0 },
2167 { WM_CREATE, sent },
2168 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2169 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2170 { WM_MOVE, sent },
2171 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2172 { WM_GETMINMAXINFO, sent },
2173 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2174 { WM_NCCALCSIZE, sent|wparam, 1 },
2175 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2176 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2177 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2178 /* in MDI frame */
2179 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2180 { WM_NCCALCSIZE, sent|wparam, 1 },
2181 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2182 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2183 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2184 /* Win2k sends wparam set to
2185 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2186 * while Win9x doesn't bother to set child window id according to
2187 * CLIENTCREATESTRUCT.idFirstChild
2188 */
2189 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2190 { WM_SHOWWINDOW, sent|wparam, 1 },
2191 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2192 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2193 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2194 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2195 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2196 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2197
2198 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2199 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2200
2201 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2202
2203 /* Win9x: message sequence terminates here. */
2204
2205 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2206 { HCBT_SETFOCUS, hook },
2207 { WM_KILLFOCUS, sent|defwinproc }, /* in the 1st MDI child */
2208 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 }, /* in the 1st MDI child */
2209 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2210 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2211 { WM_SETFOCUS, sent }, /* in MDI client */
2212 { HCBT_SETFOCUS, hook },
2213 { WM_KILLFOCUS, sent }, /* in MDI client */
2214 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2215 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2216 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2217 { WM_SETFOCUS, sent|defwinproc },
2218
2219 { WM_MDIACTIVATE, sent|defwinproc },
2220 /* in MDI frame */
2221 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2222 { WM_NCCALCSIZE, sent|wparam, 1 },
2223 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2224 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2225 { 0 }
2226 };
2227 /* WM_MDICREATE MDI child window, initially visible and maximized */
2228 static const struct message WmCreateMDIchildVisibleMaxSeq3[] = {
2229 { WM_MDICREATE, sent },
2230 { HCBT_CREATEWND, hook },
2231 { WM_NCCREATE, sent },
2232 { WM_NCCALCSIZE, sent|wparam, 0 },
2233 { WM_CREATE, sent },
2234 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2235 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2236 { WM_MOVE, sent },
2237 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2238 { WM_GETMINMAXINFO, sent },
2239 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2240 { WM_NCCALCSIZE, sent|wparam, 1 },
2241 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2242 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2243
2244 /* in MDI frame */
2245 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2246 { WM_NCCALCSIZE, sent|wparam, 1 },
2247 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2248 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2249 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2250
2251 /* Win2k sends wparam set to
2252 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2253 * while Win9x doesn't bother to set child window id according to
2254 * CLIENTCREATESTRUCT.idFirstChild
2255 */
2256 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2257 { WM_SHOWWINDOW, sent|wparam, 1 },
2258 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2259
2260 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2261
2262 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2263 { WM_MDIREFRESHMENU, sent/*|wparam|lparam, 0, 0*/ },
2264 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
2265
2266 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2267 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2268
2269 /* Win9x: message sequence terminates here. */
2270
2271 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2272 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2273 { HCBT_SETFOCUS, hook }, /* in MDI client */
2274 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2275 { WM_IME_NOTIFY, sent|wparam|optional, 2 },
2276 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam|optional, OBJID_CLIENT, 0 },
2277 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2278 { HCBT_SETFOCUS, hook|optional },
2279 { WM_KILLFOCUS, sent }, /* in MDI client */
2280 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2281 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2282 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2283 { WM_SETFOCUS, sent|defwinproc },
2284
2285 { WM_MDIACTIVATE, sent|defwinproc },
2286
2287 /* in MDI child */
2288 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2289 { WM_NCCALCSIZE, sent|wparam, 1 },
2290 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2291 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
2292
2293 /* in MDI frame */
2294 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2295 { WM_NCCALCSIZE, sent|wparam, 1 },
2296 { 0x0093, sent|defwinproc|optional },
2297 { 0x0093, sent|defwinproc|optional },
2298 { 0x0093, sent|defwinproc|optional },
2299 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2300 { WM_MOVE, sent|defwinproc },
2301 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2302
2303 /* in MDI client */
2304 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2305 { WM_NCCALCSIZE, sent|wparam, 1 },
2306 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2307 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2308
2309 /* in MDI child */
2310 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2311 { WM_NCCALCSIZE, sent|wparam, 1 },
2312 { 0x0093, sent|optional },
2313 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2314 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2315
2316 { 0x0093, sent|optional },
2317 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2318 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2319 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP sends it to MDI frame */
2320 { 0x0093, sent|defwinproc|optional },
2321 { 0x0093, sent|defwinproc|optional },
2322 { 0x0093, sent|defwinproc|optional },
2323 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2324 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2325
2326 { 0 }
2327 };
2328 /* CreateWindow for the 1st MDI child window, initially invisible and maximized */
2329 static const struct message WmCreateMDIchildInvisibleMaxSeq4[] = {
2330 { HCBT_CREATEWND, hook },
2331 { WM_GETMINMAXINFO, sent },
2332 { WM_NCCREATE, sent },
2333 { WM_NCCALCSIZE, sent|wparam, 0 },
2334 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, 0, 0 },
2335 { WM_CREATE, sent },
2336 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
2337 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2338 { WM_MOVE, sent },
2339 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2340 { WM_GETMINMAXINFO, sent },
2341 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_STATECHANGED },
2342 { WM_GETMINMAXINFO, sent|defwinproc },
2343 { WM_NCCALCSIZE, sent|wparam, 1 },
2344 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_STATECHANGED },
2345 { WM_MOVE, sent|defwinproc },
2346 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2347 /* in MDI frame */
2348 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2349 { WM_NCCALCSIZE, sent|wparam, 1 },
2350 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2351 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2352 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* MDI child */
2353 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2354 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2355 /* Win2k sends wparam set to
2356 * MAKEWPARAM(WM_CREATE, MDI_FIRST_CHILD_ID + nTotalCreated),
2357 * while Win9x doesn't bother to set child window id according to
2358 * CLIENTCREATESTRUCT.idFirstChild
2359 */
2360 { WM_PARENTNOTIFY, sent /*|wparam, WM_CREATE*/ }, /* in MDI client */
2361 { 0 }
2362 };
2363 /* WM_SYSCOMMAND/SC_CLOSE for the 2nd MDI child window, initially visible and maximized */
2364 static const struct message WmDestroyMDIchildVisibleMaxSeq2[] = {
2365 { WM_SYSCOMMAND, sent|wparam, SC_CLOSE },
2366 { HCBT_SYSCOMMAND, hook },
2367 { WM_CLOSE, sent|defwinproc },
2368 { WM_MDIDESTROY, sent }, /* in MDI client */
2369
2370 /* bring the 1st MDI child to top */
2371 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE }, /* in the 1st MDI child */
2372 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE }, /* in the 2nd MDI child */
2373
2374 { EVENT_OBJECT_REORDER, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2375
2376 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 }, /* in the 1st MDI child */
2377 { WM_NCACTIVATE, sent|wparam|defwinproc, 0 }, /* in the 1st MDI child */
2378 { WM_MDIACTIVATE, sent|defwinproc }, /* in the 1st MDI child */
2379
2380 /* maximize the 1st MDI child */
2381 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2382 { WM_GETMINMAXINFO, sent|defwinproc },
2383 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_STATECHANGED },
2384 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2385 { WM_CHILDACTIVATE, sent|defwinproc|wparam|lparam, 0, 0 },
2386 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2387 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2388
2389 /* restore the 2nd MDI child */
2390 { WM_SETREDRAW, sent|defwinproc|wparam, 0 },
2391 { HCBT_MINMAX, hook|lparam, 0, SW_NORMALNA },
2392 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
2393 { WM_NCCALCSIZE, sent|defwinproc|wparam, 1 },
2394
2395 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2396
2397 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2398 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2399
2400 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2401
2402 { WM_SETREDRAW, sent|defwinproc|wparam, 1 },
2403 /* in MDI frame */
2404 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2405 { WM_NCCALCSIZE, sent|wparam, 1 },
2406 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2407 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2408 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2409
2410 /* bring the 1st MDI child to top */
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_KILLFOCUS, sent|defwinproc },
2415 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
2416 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2417 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2418 { WM_SETFOCUS, sent }, /* in MDI client */
2419 { HCBT_SETFOCUS, hook },
2420 { WM_KILLFOCUS, sent }, /* in MDI client */
2421 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2422 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2423 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2424 { WM_SETFOCUS, sent|defwinproc },
2425 { WM_MDIACTIVATE, sent|defwinproc },
2426 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2427
2428 /* apparently ShowWindow(SW_SHOW) on an MDI client */
2429 { WM_SHOWWINDOW, sent|wparam, 1 },
2430 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2431 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2432 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2433 { WM_MDIREFRESHMENU, sent },
2434
2435 { HCBT_DESTROYWND, hook },
2436 /* Win2k sends wparam set to
2437 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2438 * while Win9x doesn't bother to set child window id according to
2439 * CLIENTCREATESTRUCT.idFirstChild
2440 */
2441 { 0x0090, sent|defwinproc|optional },
2442 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2443 { WM_SHOWWINDOW, sent|defwinproc|wparam, 0 },
2444 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2445 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2446 { WM_ERASEBKGND, sent|parent|optional },
2447 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2448
2449 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2450 { WM_DESTROY, sent|defwinproc },
2451 { WM_NCDESTROY, sent|defwinproc },
2452 { 0 }
2453 };
2454 /* WM_MDIDESTROY for the single MDI child window, initially visible and maximized */
2455 static const struct message WmDestroyMDIchildVisibleMaxSeq1[] = {
2456 { WM_MDIDESTROY, sent }, /* in MDI client */
2457 { WM_SHOWWINDOW, sent|wparam, 0 },
2458 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2459 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2460 { WM_ERASEBKGND, sent|parent|optional },
2461 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2462
2463 { HCBT_SETFOCUS, hook },
2464 { WM_KILLFOCUS, sent },
2465 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2466 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2467 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2468 { WM_SETFOCUS, sent }, /* in MDI client */
2469 { HCBT_SETFOCUS, hook },
2470 { WM_KILLFOCUS, sent }, /* in MDI client */
2471 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2472 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2473 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2474 { WM_SETFOCUS, sent },
2475
2476 /* in MDI child */
2477 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2478 { WM_NCCALCSIZE, sent|wparam, 1 },
2479 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2480 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2481
2482 /* in MDI frame */
2483 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2484 { WM_NCCALCSIZE, sent|wparam, 1 },
2485 { 0x0093, sent|defwinproc|optional },
2486 { 0x0093, sent|defwinproc|optional },
2487 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2488 { WM_MOVE, sent|defwinproc },
2489 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2490
2491 /* in MDI client */
2492 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2493 { WM_NCCALCSIZE, sent|wparam, 1 },
2494 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2495 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2496
2497 /* in MDI child */
2498 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2499 { WM_NCCALCSIZE, sent|wparam, 1 },
2500 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2501 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2502
2503 /* in MDI child */
2504 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2505 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2506 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2507 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2508
2509 /* in MDI frame */
2510 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2511 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2512 { 0x0093, sent|defwinproc|optional },
2513 { 0x0093, sent|defwinproc|optional },
2514 { 0x0093, sent|defwinproc|optional },
2515 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2516 { WM_MOVE, sent|defwinproc },
2517 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2518
2519 /* in MDI client */
2520 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2521 { WM_NCCALCSIZE, sent|wparam, 1 },
2522 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2523 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2524
2525 /* in MDI child */
2526 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2527 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2528 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2529 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2530 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2531 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2532
2533 { 0x0093, sent|defwinproc|optional },
2534 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 }, /* XP sends it to MDI frame */
2535 { 0x0093, sent|defwinproc|optional },
2536 { 0x0093, sent|defwinproc|optional },
2537 { 0x0093, sent|defwinproc|optional },
2538 { 0x0093, sent|optional },
2539
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 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2543 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2544 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2545
2546 /* in MDI frame */
2547 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2548 { WM_NCCALCSIZE, sent|wparam, 1 },
2549 { 0x0093, sent|defwinproc|optional },
2550 { 0x0093, sent|defwinproc|optional },
2551 { 0x0093, sent|defwinproc|optional },
2552 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2553 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2554 { 0x0093, sent|optional },
2555
2556 { WM_NCACTIVATE, sent|wparam, 0 },
2557 { WM_MDIACTIVATE, sent },
2558
2559 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
2560 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_STATECHANGED },
2561 { WM_NCCALCSIZE, sent|wparam, 1 },
2562
2563 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2564
2565 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2566 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2567 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2568
2569 /* in MDI child */
2570 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2571 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2572 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2573 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2574
2575 /* in MDI frame */
2576 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2577 { WM_NCCALCSIZE, sent|wparam, 1 },
2578 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2579 { WM_MOVE, sent|defwinproc },
2580 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2581
2582 /* in MDI client */
2583 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2584 { WM_NCCALCSIZE, sent|wparam, 1 },
2585 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOCLIENTMOVE },
2586 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2587 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2588 { WM_NCCALCSIZE, sent|wparam|optional, 1 }, /* XP */
2589 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI client */
2590 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2591 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* XP sends a duplicate */
2592
2593 { HCBT_SETFOCUS, hook },
2594 { WM_KILLFOCUS, sent },
2595 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
2596 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2597 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2598 { WM_SETFOCUS, sent }, /* in MDI client */
2599
2600 { WM_MDIREFRESHMENU, sent }, /* in MDI client */
2601
2602 { HCBT_DESTROYWND, hook },
2603 /* Win2k sends wparam set to
2604 * MAKEWPARAM(WM_DESTROY, MDI_FIRST_CHILD_ID + nTotalCreated),
2605 * while Win9x doesn't bother to set child window id according to
2606 * CLIENTCREATESTRUCT.idFirstChild
2607 */
2608 { 0x0090, sent|optional },
2609 { WM_PARENTNOTIFY, sent /*|wparam, WM_DESTROY*/ }, /* in MDI client */
2610
2611 { WM_SHOWWINDOW, sent|wparam, 0 },
2612 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2613 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, 0, 0 },
2614 { WM_ERASEBKGND, sent|parent|optional },
2615 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2616
2617 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 },
2618 { WM_DESTROY, sent },
2619 { WM_NCDESTROY, sent },
2620 { 0 }
2621 };
2622 /* ShowWindow(SW_MAXIMIZE) for a not visible MDI child window */
2623 static const struct message WmMaximizeMDIchildInvisibleSeq[] = {
2624 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2625 { WM_GETMINMAXINFO, sent },
2626 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
2627 { WM_NCCALCSIZE, sent|wparam, 1 },
2628 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2629 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2630
2631 { WM_WINDOWPOSCHANGING, sent|wparam|optional|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2632 { WM_NCACTIVATE, sent|wparam|optional|defwinproc, 1 },
2633 { HCBT_SETFOCUS, hook|optional },
2634 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2635 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2636 { WM_SETFOCUS, sent|optional }, /* in MDI client */
2637 { HCBT_SETFOCUS, hook|optional },
2638 { WM_KILLFOCUS, sent|optional }, /* in MDI client */
2639 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2640 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2641 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2642 { WM_SETFOCUS, sent|optional|defwinproc },
2643 { WM_MDIACTIVATE, sent|optional|defwinproc },
2644 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2645 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2646 /* in MDI frame */
2647 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2648 { WM_NCCALCSIZE, sent|wparam, 1 },
2649 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2650 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2651 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2652 { 0 }
2653 };
2654 /* ShowWindow(SW_MAXIMIZE) for a not visible maximized MDI child window */
2655 static const struct message WmMaximizeMDIchildInvisibleSeq2[] = {
2656 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2657 { WM_GETMINMAXINFO, sent },
2658 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED },
2659 { WM_GETMINMAXINFO, sent|defwinproc },
2660 { WM_NCCALCSIZE, sent|wparam, 1 },
2661 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2662 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2663
2664 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2665 { WM_NCACTIVATE, sent|wparam|defwinproc, 1 },
2666 { HCBT_SETFOCUS, hook },
2667 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 }, /* in MDI client */
2668 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2669 { WM_SETFOCUS, sent }, /* in MDI client */
2670 { HCBT_SETFOCUS, hook },
2671 { WM_KILLFOCUS, sent }, /* in MDI client */
2672 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 }, /* in MDI client */
2673 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
2674 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2675 { WM_SETFOCUS, sent|defwinproc },
2676 { WM_MDIACTIVATE, sent|defwinproc },
2677 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2678 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2679 { 0 }
2680 };
2681 /* WM_MDIMAXIMIZE for an MDI child window with invisible parent */
2682 static const struct message WmMaximizeMDIchildInvisibleParentSeq[] = {
2683 { WM_MDIMAXIMIZE, sent }, /* in MDI client */
2684 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2685 { WM_GETMINMAXINFO, sent },
2686 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2687 { WM_GETMINMAXINFO, sent|defwinproc },
2688 { WM_NCCALCSIZE, sent|wparam, 1 },
2689 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam|optional, 0, 0 }, /* XP doesn't send it */
2690 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2691 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOREDRAW|SWP_STATECHANGED },
2692 { WM_MOVE, sent|defwinproc },
2693 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2694
2695 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2696 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2697 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2698 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
2699 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2700 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
2701 /* in MDI frame */
2702 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2703 { WM_NCCALCSIZE, sent|wparam, 1 },
2704 { 0x0093, sent|defwinproc|optional },
2705 { 0x0094, sent|defwinproc|optional },
2706 { 0x0094, sent|defwinproc|optional },
2707 { 0x0094, sent|defwinproc|optional },
2708 { 0x0094, sent|defwinproc|optional },
2709 { 0x0093, sent|defwinproc|optional },
2710 { 0x0093, sent|defwinproc|optional },
2711 { 0x0091, sent|defwinproc|optional },
2712 { 0x0092, sent|defwinproc|optional },
2713 { 0x0092, sent|defwinproc|optional },
2714 { 0x0092, sent|defwinproc|optional },
2715 { 0x0092, sent|defwinproc|optional },
2716 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2717 { WM_MOVE, sent|defwinproc },
2718 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2719 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame win2000 */
2720 /* in MDI client */
2721 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOACTIVATE },
2722 { WM_NCCALCSIZE, sent|wparam, 1 },
2723 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2724 { WM_SIZE, sent|wparam, SIZE_RESTORED },
2725 /* in MDI child */
2726 { WM_WINDOWPOSCHANGING, sent|wparam|defwinproc, SWP_NOACTIVATE },
2727 { WM_GETMINMAXINFO, sent|defwinproc },
2728 { WM_NCCALCSIZE, sent|wparam|defwinproc, 1 },
2729 { WM_WINDOWPOSCHANGED, sent|wparam|defwinproc, SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTMOVE },
2730 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2731 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child win2000 */
2732 { WM_NCCALCSIZE, sent|wparam|defwinproc|optional, 1 },
2733 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2734 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2735 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI client XP */
2736 /* in MDI frame */
2737 { 0x0093, sent|optional },
2738 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
2739 { 0x0093, sent|defwinproc|optional },
2740 { 0x0093, sent|defwinproc|optional },
2741 { 0x0093, sent|defwinproc|optional },
2742 { 0x0091, sent|defwinproc|optional },
2743 { 0x0092, sent|defwinproc|optional },
2744 { 0x0092, sent|defwinproc|optional },
2745 { 0x0092, sent|defwinproc|optional },
2746 { 0x0092, sent|defwinproc|optional },
2747 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
2748 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI frame XP */
2749 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam|optional, 0, 0 }, /* MDI child XP */
2750 { 0 }
2751 };
2752 /* ShowWindow(SW_MAXIMIZE) for a visible MDI child window */
2753 static const struct message WmMaximizeMDIchildVisibleSeq[] = {
2754 { HCBT_MINMAX, hook|lparam, 0, SW_MAXIMIZE },
2755 { WM_GETMINMAXINFO, sent },
2756 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2757 { WM_NCCALCSIZE, sent|wparam, 1 },
2758 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2759 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2760 { WM_SIZE, sent|defwinproc|wparam, SIZE_MAXIMIZED },
2761 /* in MDI frame */
2762 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2763 { WM_NCCALCSIZE, sent|wparam, 1 },
2764 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2765 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2766 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2767 { 0 }
2768 };
2769 /* ShowWindow(SW_RESTORE) for a visible maximized MDI child window */
2770 static const struct message WmRestoreMDIchildVisibleSeq[] = {
2771 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
2772 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
2773 { WM_NCCALCSIZE, sent|wparam, 1 },
2774 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2775 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2776 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2777 /* in MDI frame */
2778 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2779 { WM_NCCALCSIZE, sent|wparam, 1 },
2780 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2781 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2782 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2783 { 0 }
2784 };
2785 /* ShowWindow(SW_RESTORE) for a visible minimized MDI child window */
2786 static const struct message WmRestoreMDIchildVisibleSeq_2[] = {
2787 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
2788 { WM_QUERYOPEN, sent|wparam|lparam, 0, 0 },
2789 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
2790 { WM_NCCALCSIZE, sent|wparam, 1 },
2791 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2792 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_NOCLIENTSIZE|SWP_STATECHANGED },
2793 { WM_MOVE, sent|defwinproc },
2794 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2795 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2796 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2797 { HCBT_SETFOCUS, hook },
2798 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
2799 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
2800 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
2801 { WM_SETFOCUS, sent },
2802 { 0 }
2803 };
2804 /* ShowWindow(SW_MINIMIZE) for a visible restored MDI child window */
2805 static const struct message WmMinimizeMDIchildVisibleSeq[] = {
2806 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
2807 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_STATECHANGED },
2808 { WM_NCCALCSIZE, sent|wparam, 1 },
2809 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOCLIENTSIZE|SWP_STATECHANGED },
2810 { WM_MOVE, sent|defwinproc },
2811 { WM_SIZE, sent|defwinproc|wparam, SIZE_MINIMIZED },
2812 { WM_CHILDACTIVATE, sent|wparam|lparam|defwinproc, 0, 0 },
2813 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2814 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2815 /* FIXME: Wine creates an icon/title window while Windows doesn't */
2816 { WM_PARENTNOTIFY, sent|parent|wparam|optional, WM_CREATE }, /* MDI client */
2817 { 0 }
2818 };
2819 /* ShowWindow(SW_RESTORE) for a not visible MDI child window */
2820 static const struct message WmRestoreMDIchildInisibleSeq[] = {
2821 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
2822 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_STATECHANGED },
2823 { WM_NCCALCSIZE, sent|wparam, 1 },
2824 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, 0, 0 },
2825 { WM_CHILDACTIVATE, sent|wparam|lparam, 0, 0 },
2826 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_STATECHANGED },
2827 { WM_SIZE, sent|defwinproc|wparam, SIZE_RESTORED },
2828 /* in MDI frame */
2829 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
2830 { WM_NCCALCSIZE, sent|wparam, 1 },
2831 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
2832 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI frame */
2833 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 }, /* MDI child */
2834 { 0 }
2835 };
2836
2837 static HWND mdi_client;
2838 static WNDPROC old_mdi_client_proc;
2839
2840 static LRESULT WINAPI mdi_client_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2841 {
2842 struct message msg;
2843
2844 /* do not log painting messages */
2845 if (message != WM_PAINT &&
2846 message != WM_NCPAINT &&
2847 message != WM_SYNCPAINT &&
2848 message != WM_ERASEBKGND &&
2849 message != WM_NCHITTEST &&
2850 message != WM_GETTEXT &&
2851 message != WM_MDIGETACTIVE &&
2852 message != WM_GETICON &&
2853 message != WM_DEVICECHANGE)
2854 {
2855 trace("mdi client: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
2856
2857 switch (message)
2858 {
2859 case WM_WINDOWPOSCHANGING:
2860 case WM_WINDOWPOSCHANGED:
2861 {
2862 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2863
2864 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2865 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
2866 winpos->hwnd, winpos->hwndInsertAfter,
2867 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2868 dump_winpos_flags(winpos->flags);
2869
2870 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2871 * in the high word for internal purposes
2872 */
2873 wParam = winpos->flags & 0xffff;
2874 /* We are not interested in the flags that don't match under XP and Win9x */
2875 wParam &= ~(SWP_NOZORDER);
2876 break;
2877 }
2878 }
2879
2880 msg.message = message;
2881 msg.flags = sent|wparam|lparam;
2882 msg.wParam = wParam;
2883 msg.lParam = lParam;
2884 add_message(&msg);
2885 }
2886
2887 return CallWindowProcA(old_mdi_client_proc, hwnd, message, wParam, lParam);
2888 }
2889
2890 static LRESULT WINAPI mdi_child_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2891 {
2892 static long defwndproc_counter = 0;
2893 LRESULT ret;
2894 struct message msg;
2895
2896 /* do not log painting messages */
2897 if (message != WM_PAINT &&
2898 message != WM_NCPAINT &&
2899 message != WM_SYNCPAINT &&
2900 message != WM_ERASEBKGND &&
2901 message != WM_NCHITTEST &&
2902 message != WM_GETTEXT &&
2903 message != WM_GETICON &&
2904 message != WM_DEVICECHANGE)
2905 {
2906 trace("mdi child: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
2907
2908 switch (message)
2909 {
2910 case WM_WINDOWPOSCHANGING:
2911 case WM_WINDOWPOSCHANGED:
2912 {
2913 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2914
2915 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2916 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
2917 winpos->hwnd, winpos->hwndInsertAfter,
2918 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2919 dump_winpos_flags(winpos->flags);
2920
2921 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2922 * in the high word for internal purposes
2923 */
2924 wParam = winpos->flags & 0xffff;
2925 /* We are not interested in the flags that don't match under XP and Win9x */
2926 wParam &= ~(SWP_NOZORDER);
2927 break;
2928 }
2929
2930 case WM_MDIACTIVATE:
2931 {
2932 HWND active, client = GetParent(hwnd);
2933
2934 active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
2935
2936 if (hwnd == (HWND)lParam) /* if we are being activated */
2937 ok (active == (HWND)lParam, "new active %p != active %p\n", (HWND)lParam, active);
2938 else
2939 ok (active == (HWND)wParam, "old active %p != active %p\n", (HWND)wParam, active);
2940 break;
2941 }
2942 }
2943
2944 msg.message = message;
2945 msg.flags = sent|wparam|lparam;
2946 if (defwndproc_counter) msg.flags |= defwinproc;
2947 msg.wParam = wParam;
2948 msg.lParam = lParam;
2949 add_message(&msg);
2950 }
2951
2952 defwndproc_counter++;
2953 ret = DefMDIChildProcA(hwnd, message, wParam, lParam);
2954 defwndproc_counter--;
2955
2956 return ret;
2957 }
2958
2959 static LRESULT WINAPI mdi_frame_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
2960 {
2961 static long defwndproc_counter = 0;
2962 LRESULT ret;
2963 struct message msg;
2964
2965 /* do not log painting messages */
2966 if (message != WM_PAINT &&
2967 message != WM_NCPAINT &&
2968 message != WM_SYNCPAINT &&
2969 message != WM_ERASEBKGND &&
2970 message != WM_NCHITTEST &&
2971 message != WM_GETTEXT &&
2972 message != WM_GETICON &&
2973 message != WM_DEVICECHANGE)
2974 {
2975 trace("mdi frame: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
2976
2977 switch (message)
2978 {
2979 case WM_WINDOWPOSCHANGING:
2980 case WM_WINDOWPOSCHANGED:
2981 {
2982 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
2983
2984 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
2985 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
2986 winpos->hwnd, winpos->hwndInsertAfter,
2987 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
2988 dump_winpos_flags(winpos->flags);
2989
2990 /* Log only documented flags, win2k uses 0x1000 and 0x2000
2991 * in the high word for internal purposes
2992 */
2993 wParam = winpos->flags & 0xffff;
2994 /* We are not interested in the flags that don't match under XP and Win9x */
2995 wParam &= ~(SWP_NOZORDER);
2996 break;
2997 }
2998 }
2999
3000 msg.message = message;
3001 msg.flags = sent|wparam|lparam;
3002 if (defwndproc_counter) msg.flags |= defwinproc;
3003 msg.wParam = wParam;
3004 msg.lParam = lParam;
3005 add_message(&msg);
3006 }
3007
3008 defwndproc_counter++;
3009 ret = DefFrameProcA(hwnd, mdi_client, message, wParam, lParam);
3010 defwndproc_counter--;
3011
3012 return ret;
3013 }
3014
3015 static BOOL mdi_RegisterWindowClasses(void)
3016 {
3017 WNDCLASSA cls;
3018
3019 cls.style = 0;
3020 cls.lpfnWndProc = mdi_frame_wnd_proc;
3021 cls.cbClsExtra = 0;
3022 cls.cbWndExtra = 0;
3023 cls.hInstance = GetModuleHandleA(0);
3024 cls.hIcon = 0;
3025 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
3026 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
3027 cls.lpszMenuName = NULL;
3028 cls.lpszClassName = "MDI_frame_class";
3029 if (!RegisterClassA(&cls)) return FALSE;
3030
3031 cls.lpfnWndProc = mdi_child_wnd_proc;
3032 cls.lpszClassName = "MDI_child_class";
3033 if (!RegisterClassA(&cls)) return FALSE;
3034
3035 if (!GetClassInfoA(0, "MDIClient", &cls)) assert(0);
3036 old_mdi_client_proc = cls.lpfnWndProc;
3037 cls.hInstance = GetModuleHandleA(0);
3038 cls.lpfnWndProc = mdi_client_hook_proc;
3039 cls.lpszClassName = "MDI_client_class";
3040 if (!RegisterClassA(&cls)) assert(0);
3041
3042 return TRUE;
3043 }
3044
3045 static void test_mdi_messages(void)
3046 {
3047 MDICREATESTRUCTA mdi_cs;
3048 CLIENTCREATESTRUCT client_cs;
3049 HWND mdi_frame, mdi_child, mdi_child2, active_child;
3050 BOOL zoomed;
3051 HMENU hMenu = CreateMenu();
3052
3053 assert(mdi_RegisterWindowClasses());
3054
3055 flush_sequence();
3056
3057 trace("creating MDI frame window\n");
3058 mdi_frame = CreateWindowExA(0, "MDI_frame_class", "MDI frame window",
3059 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
3060 WS_MAXIMIZEBOX | WS_VISIBLE,
3061 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
3062 GetDesktopWindow(), hMenu,
3063 GetModuleHandleA(0), NULL);
3064 assert(mdi_frame);
3065 ok_sequence(WmCreateMDIframeSeq, "Create MDI frame window", FALSE);
3066
3067 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3068 ok(GetFocus() == mdi_frame, "wrong focus window %p\n", GetFocus());
3069
3070 trace("creating MDI client window\n");
3071 client_cs.hWindowMenu = 0;
3072 client_cs.idFirstChild = MDI_FIRST_CHILD_ID;
3073 mdi_client = CreateWindowExA(0, "MDI_client_class",
3074 NULL,
3075 WS_CHILD | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
3076 0, 0, 0, 0,
3077 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3078 assert(mdi_client);
3079 ok_sequence(WmCreateMDIclientSeq, "Create visible MDI client window", FALSE);
3080
3081 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3082 ok(GetFocus() == mdi_frame, "input focus should be on MDI frame not on %p\n", GetFocus());
3083
3084 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3085 ok(!active_child, "wrong active MDI child %p\n", active_child);
3086 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3087
3088 SetFocus(0);
3089 flush_sequence();
3090
3091 trace("creating invisible MDI child window\n");
3092 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3093 WS_CHILD,
3094 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3095 mdi_client, 0, GetModuleHandleA(0), NULL);
3096 assert(mdi_child);
3097
3098 flush_sequence();
3099 ShowWindow(mdi_child, SW_SHOWNORMAL);
3100 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOWNORMAL) MDI child window", FALSE);
3101
3102 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3103 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3104
3105 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3106 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3107
3108 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3109 ok(!active_child, "wrong active MDI child %p\n", active_child);
3110 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3111
3112 ShowWindow(mdi_child, SW_HIDE);
3113 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE) MDI child window", FALSE);
3114 flush_sequence();
3115
3116 ShowWindow(mdi_child, SW_SHOW);
3117 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW) MDI child window", FALSE);
3118
3119 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3120 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3121
3122 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3123 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3124
3125 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3126 ok(!active_child, "wrong active MDI child %p\n", active_child);
3127 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3128
3129 DestroyWindow(mdi_child);
3130 flush_sequence();
3131
3132 trace("creating visible MDI child window\n");
3133 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3134 WS_CHILD | WS_VISIBLE,
3135 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3136 mdi_client, 0, GetModuleHandleA(0), NULL);
3137 assert(mdi_child);
3138 ok_sequence(WmCreateMDIchildVisibleSeq, "Create visible MDI child window", FALSE);
3139
3140 ok(GetWindowLongA(mdi_child, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3141 ok(IsWindowVisible(mdi_child), "MDI child should be visible\n");
3142
3143 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3144 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3145
3146 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3147 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3148 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3149 flush_sequence();
3150
3151 DestroyWindow(mdi_child);
3152 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3153
3154 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3155 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3156
3157 /* Win2k: MDI client still returns a just destroyed child as active
3158 * Win9x: MDI client returns 0
3159 */
3160 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3161 ok(active_child == mdi_child || /* win2k */
3162 !active_child, /* win9x */
3163 "wrong active MDI child %p\n", active_child);
3164 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3165
3166 flush_sequence();
3167
3168 trace("creating invisible MDI child window\n");
3169 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3170 WS_CHILD,
3171 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3172 mdi_client, 0, GetModuleHandleA(0), NULL);
3173 assert(mdi_child2);
3174 ok_sequence(WmCreateMDIchildInvisibleSeq, "Create invisible MDI child window", FALSE);
3175
3176 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should not be visible\n");
3177 ok(!IsWindowVisible(mdi_child2), "MDI child should not be visible\n");
3178
3179 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3180 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3181
3182 /* Win2k: MDI client still returns a just destroyed child as active
3183 * Win9x: MDI client returns mdi_child2
3184 */
3185 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3186 ok(active_child == mdi_child || /* win2k */
3187 active_child == mdi_child2, /* win9x */
3188 "wrong active MDI child %p\n", active_child);
3189 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3190 flush_sequence();
3191
3192 ShowWindow(mdi_child2, SW_MAXIMIZE);
3193 ok_sequence(WmMaximizeMDIchildInvisibleSeq, "ShowWindow(SW_MAXIMIZE):invisible MDI child", FALSE);
3194
3195 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3196 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3197
3198 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3199 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3200 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3201 flush_sequence();
3202
3203 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3204 ok(GetFocus() == mdi_child2 || /* win2k */
3205 GetFocus() == 0, /* win9x */
3206 "wrong focus window %p\n", GetFocus());
3207
3208 SetFocus(0);
3209 flush_sequence();
3210
3211 ShowWindow(mdi_child2, SW_HIDE);
3212 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3213
3214 ShowWindow(mdi_child2, SW_RESTORE);
3215 ok_sequence(WmRestoreMDIchildInisibleSeq, "ShowWindow(SW_RESTORE):invisible MDI child", FALSE);
3216 flush_sequence();
3217
3218 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3219 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3220
3221 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3222 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3223 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3224 flush_sequence();
3225
3226 SetFocus(0);
3227 flush_sequence();
3228
3229 ShowWindow(mdi_child2, SW_HIDE);
3230 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3231
3232 ShowWindow(mdi_child2, SW_SHOW);
3233 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):MDI child", FALSE);
3234
3235 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3236 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3237
3238 ShowWindow(mdi_child2, SW_MAXIMIZE);
3239 ok_sequence(WmMaximizeMDIchildVisibleSeq, "ShowWindow(SW_MAXIMIZE):MDI child", FALSE);
3240
3241 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3242 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3243
3244 ShowWindow(mdi_child2, SW_RESTORE);
3245 ok_sequence(WmRestoreMDIchildVisibleSeq, "ShowWindow(SW_RESTORE):maximized MDI child", FALSE);
3246
3247 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3248 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3249
3250 ShowWindow(mdi_child2, SW_MINIMIZE);
3251 ok_sequence(WmMinimizeMDIchildVisibleSeq, "ShowWindow(SW_MINIMIZE):MDI child", TRUE);
3252
3253 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3254 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3255
3256 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3257 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3258 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3259 flush_sequence();
3260
3261 ShowWindow(mdi_child2, SW_RESTORE);
3262 ok_sequence(WmRestoreMDIchildVisibleSeq_2, "ShowWindow(SW_RESTORE):minimized MDI child", TRUE);
3263
3264 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3265 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3266
3267 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3268 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3269 ok(!zoomed, "wrong zoomed state %d\n", zoomed);
3270 flush_sequence();
3271
3272 SetFocus(0);
3273 flush_sequence();
3274
3275 ShowWindow(mdi_child2, SW_HIDE);
3276 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):MDI child", FALSE);
3277
3278 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3279 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3280
3281 DestroyWindow(mdi_child2);
3282 ok_sequence(WmDestroyMDIchildInvisibleSeq, "Destroy invisible MDI child window", FALSE);
3283
3284 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3285 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3286
3287 /* test for maximized MDI children */
3288 trace("creating maximized visible MDI child window 1\n");
3289 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3290 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3291 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3292 mdi_client, 0, GetModuleHandleA(0), NULL);
3293 assert(mdi_child);
3294 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window", TRUE);
3295 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3296
3297 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3298 ok(GetFocus() == mdi_child || /* win2k */
3299 GetFocus() == 0, /* win9x */
3300 "wrong focus window %p\n", GetFocus());
3301
3302 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3303 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3304 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3305 flush_sequence();
3306
3307 trace("creating maximized visible MDI child window 2\n");
3308 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3309 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3310 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3311 mdi_client, 0, GetModuleHandleA(0), NULL);
3312 assert(mdi_child2);
3313 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3314 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3315 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3316
3317 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3318 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3319
3320 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3321 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3322 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3323 flush_sequence();
3324
3325 trace("destroying maximized visible MDI child window 2\n");
3326 DestroyWindow(mdi_child2);
3327 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3328
3329 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3330
3331 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3332 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3333
3334 /* Win2k: MDI client still returns a just destroyed child as active
3335 * Win9x: MDI client returns 0
3336 */
3337 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3338 ok(active_child == mdi_child2 || /* win2k */
3339 !active_child, /* win9x */
3340 "wrong active MDI child %p\n", active_child);
3341 flush_sequence();
3342
3343 ShowWindow(mdi_child, SW_MAXIMIZE);
3344 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3345 flush_sequence();
3346
3347 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3348 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3349
3350 trace("re-creating maximized visible MDI child window 2\n");
3351 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3352 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3353 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3354 mdi_client, 0, GetModuleHandleA(0), NULL);
3355 assert(mdi_child2);
3356 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child 2 window", TRUE);
3357 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized\n");
3358 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized\n");
3359
3360 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3361 ok(GetFocus() == mdi_child2, "wrong focus window %p\n", GetFocus());
3362
3363 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3364 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3365 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3366 flush_sequence();
3367
3368 SendMessageA(mdi_child2, WM_SYSCOMMAND, SC_CLOSE, 0);
3369 ok_sequence(WmDestroyMDIchildVisibleMaxSeq2, "WM_SYSCOMMAND/SC_CLOSE on a visible maximized MDI child window", TRUE);
3370 ok(!IsWindow(mdi_child2), "MDI child 2 should be destroyed\n");
3371
3372 ok(IsZoomed(mdi_child), "1st MDI child should be maximized\n");
3373 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3374 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3375
3376 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3377 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3378 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3379 flush_sequence();
3380
3381 DestroyWindow(mdi_child);
3382 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible MDI child window", TRUE);
3383
3384 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3385 ok(GetFocus() == 0, "wrong focus window %p\n", GetFocus());
3386
3387 /* Win2k: MDI client still returns a just destroyed child as active
3388 * Win9x: MDI client returns 0
3389 */
3390 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3391 ok(active_child == mdi_child || /* win2k */
3392 !active_child, /* win9x */
3393 "wrong active MDI child %p\n", active_child);
3394 flush_sequence();
3395
3396 trace("creating maximized invisible MDI child window\n");
3397 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3398 WS_CHILD | WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME,
3399 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3400 mdi_client, 0, GetModuleHandleA(0), NULL);
3401 assert(mdi_child2);
3402 ok_sequence(WmCreateMDIchildInvisibleMaxSeq4, "Create maximized invisible MDI child window", FALSE);
3403 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3404 ok(!(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE), "MDI child should be not visible\n");
3405 ok(!IsWindowVisible(mdi_child2), "MDI child should be not visible\n");
3406
3407 /* Win2k: MDI client still returns a just destroyed child as active
3408 * Win9x: MDI client returns 0
3409 */
3410 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3411 ok(active_child == mdi_child || /* win2k */
3412 !active_child, /* win9x */
3413 "wrong active MDI child %p\n", active_child);
3414 flush_sequence();
3415
3416 trace("call ShowWindow(mdi_child, SW_MAXIMIZE)\n");
3417 ShowWindow(mdi_child2, SW_MAXIMIZE);
3418 ok_sequence(WmMaximizeMDIchildInvisibleSeq2, "ShowWindow(SW_MAXIMIZE):invisible maximized MDI child", FALSE);
3419 ok(IsZoomed(mdi_child2), "MDI child should be maximized\n");
3420 ok(GetWindowLongA(mdi_child2, GWL_STYLE) & WS_VISIBLE, "MDI child should be visible\n");
3421 ok(IsWindowVisible(mdi_child2), "MDI child should be visible\n");
3422
3423 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3424 ok(active_child == mdi_child2, "wrong active MDI child %p\n", active_child);
3425 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3426 flush_sequence();
3427
3428 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3429 flush_sequence();
3430
3431 /* end of test for maximized MDI children */
3432 SetFocus(0);
3433 flush_sequence();
3434 trace("creating maximized visible MDI child window 1(Switch test)\n");
3435 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3436 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3437 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3438 mdi_client, 0, GetModuleHandleA(0), NULL);
3439 assert(mdi_child);
3440 ok_sequence(WmCreateMDIchildVisibleMaxSeq1, "Create maximized visible 1st MDI child window(Switch test)", TRUE);
3441 ok(IsZoomed(mdi_child), "1st MDI child should be maximized(Switch test)\n");
3442
3443 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3444 ok(GetFocus() == mdi_child || /* win2k */
3445 GetFocus() == 0, /* win9x */
3446 "wrong focus window %p(Switch test)\n", GetFocus());
3447
3448 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3449 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3450 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3451 flush_sequence();
3452
3453 trace("creating maximized visible MDI child window 2(Switch test)\n");
3454 mdi_child2 = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3455 WS_CHILD | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE,
3456 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
3457 mdi_client, 0, GetModuleHandleA(0), NULL);
3458 assert(mdi_child2);
3459 ok_sequence(WmCreateMDIchildVisibleMaxSeq2, "Create maximized visible 2nd MDI child window (Switch test)", TRUE);
3460
3461 ok(IsZoomed(mdi_child2), "2nd MDI child should be maximized(Switch test)\n");
3462 ok(!IsZoomed(mdi_child), "1st MDI child should NOT be maximized(Switch test)\n");
3463
3464 ok(GetActiveWindow() == mdi_frame, "wrong active window %p(Switch test)\n", GetActiveWindow());
3465 ok(GetFocus() == mdi_child2, "wrong focus window %p(Switch test)\n", GetFocus());
3466
3467 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3468 ok(active_child == mdi_child2, "wrong active MDI child %p(Switch test)\n", active_child);
3469 ok(zoomed, "wrong zoomed state %d(Switch test)\n", zoomed);
3470 flush_sequence();
3471
3472 trace("Switch child window.\n");
3473 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child, 0);
3474 ok_sequence(WmSwitchChild, "Child did not switch correctly", TRUE);
3475 trace("end of test for switch maximized MDI children\n");
3476 flush_sequence();
3477
3478 /* Prepare for switching test of not maximized MDI children */
3479 ShowWindow( mdi_child, SW_NORMAL );
3480 ok(!IsZoomed(mdi_child), "wrong zoomed state for %p(Switch test)\n", mdi_child);
3481 ok(!IsZoomed(mdi_child2), "wrong zoomed state for %p(Switch test)\n", mdi_child2);
3482 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, 0);
3483 ok(active_child == mdi_child, "wrong active MDI child %p(Switch test)\n", active_child);
3484 flush_sequence();
3485
3486 SendMessageA(mdi_client, WM_MDIACTIVATE, (WPARAM)mdi_child2, 0);
3487 ok_sequence(WmSwitchNotMaximizedChild, "Not maximized child did not switch correctly", FALSE);
3488 trace("end of test for switch not maximized MDI children\n");
3489 flush_sequence();
3490
3491 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3492 flush_sequence();
3493
3494 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child2, 0);
3495 flush_sequence();
3496
3497 SetFocus(0);
3498 flush_sequence();
3499 /* end of tests for switch maximized/not maximized MDI children */
3500
3501 mdi_cs.szClass = "MDI_child_Class";
3502 mdi_cs.szTitle = "MDI child";
3503 mdi_cs.hOwner = GetModuleHandleA(0);
3504 mdi_cs.x = 0;
3505 mdi_cs.y = 0;
3506 mdi_cs.cx = CW_USEDEFAULT;
3507 mdi_cs.cy = CW_USEDEFAULT;
3508 mdi_cs.style = WS_CHILD | WS_SYSMENU | WS_VISIBLE | WS_MAXIMIZEBOX | WS_MAXIMIZE;
3509 mdi_cs.lParam = 0;
3510 mdi_child = (HWND)SendMessageA(mdi_client, WM_MDICREATE, 0, (LPARAM)&mdi_cs);
3511 ok(mdi_child != 0, "MDI child creation failed\n");
3512 ok_sequence(WmCreateMDIchildVisibleMaxSeq3, "WM_MDICREATE for maximized visible MDI child window", TRUE);
3513
3514 ok(GetMenuItemID(hMenu, GetMenuItemCount(hMenu) - 1) == SC_CLOSE, "SC_CLOSE menu item not found\n");
3515
3516 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3517 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3518
3519 ok(IsZoomed(mdi_child), "MDI child should be maximized\n");
3520 ok(GetActiveWindow() == mdi_frame, "wrong active window %p\n", GetActiveWindow());
3521 ok(GetFocus() == mdi_child, "wrong focus window %p\n", GetFocus());
3522
3523 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3524 ok(active_child == mdi_child, "wrong active MDI child %p\n", active_child);
3525 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3526 flush_sequence();
3527
3528 SendMessageA(mdi_client, WM_MDIDESTROY, (WPARAM)mdi_child, 0);
3529 ok_sequence(WmDestroyMDIchildVisibleMaxSeq1, "Destroy visible maximized MDI child window", TRUE);
3530
3531 ok(!IsWindow(mdi_child), "MDI child should be destroyed\n");
3532 active_child = (HWND)SendMessageA(mdi_client, WM_MDIGETACTIVE, 0, (LPARAM)&zoomed);
3533 ok(!active_child, "wrong active MDI child %p\n", active_child);
3534
3535 SetFocus(0);
3536 flush_sequence();
3537
3538 DestroyWindow(mdi_client);
3539 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3540
3541 /* test maximization of MDI child with invisible parent */
3542 client_cs.hWindowMenu = 0;
3543 mdi_client = CreateWindow("MDI_client_class",
3544 NULL,
3545 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL | WS_VISIBLE,
3546 0, 0, 660, 430,
3547 mdi_frame, 0, GetModuleHandleA(0), &client_cs);
3548 ok_sequence(WmCreateMDIclientSeq, "Create MDI client window", FALSE);
3549
3550 ShowWindow(mdi_client, SW_HIDE);
3551 ok_sequence(WmHideMDIclientSeq, "Hide MDI client window", FALSE);
3552
3553 mdi_child = CreateWindowExA(WS_EX_MDICHILD, "MDI_child_class", "MDI child",
3554 WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
3555 0, 0, 650, 440,
3556 mdi_client, 0, GetModuleHandleA(0), NULL);
3557 ok_sequence(WmCreateMDIchildInvisibleParentSeq, "Create MDI child window with invisible parent", FALSE);
3558
3559 SendMessage(mdi_client, WM_MDIMAXIMIZE, (WPARAM) mdi_child, 0);
3560 ok_sequence(WmMaximizeMDIchildInvisibleParentSeq, "Maximize MDI child window with invisible parent", TRUE);
3561 zoomed = IsZoomed(mdi_child);
3562 ok(zoomed, "wrong zoomed state %d\n", zoomed);
3563
3564 ShowWindow(mdi_client, SW_SHOW);
3565 ok_sequence(WmShowMDIclientSeq, "Show MDI client window", FALSE);
3566
3567 DestroyWindow(mdi_child);
3568 ok_sequence(WmDestroyMDIchildVisibleSeq, "Destroy visible maximized MDI child window", TRUE);
3569
3570 /* end of test for maximization of MDI child with invisible parent */
3571
3572 DestroyWindow(mdi_client);
3573 ok_sequence(WmDestroyMDIclientSeq, "Destroy MDI client window", FALSE);
3574
3575 DestroyWindow(mdi_frame);
3576 ok_sequence(WmDestroyMDIframeSeq, "Destroy MDI frame window", FALSE);
3577 }
3578 /************************* End of MDI test **********************************/
3579
3580 static void test_WM_SETREDRAW(HWND hwnd)
3581 {
3582 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
3583
3584 flush_events();
3585 flush_sequence();
3586
3587 SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
3588 ok_sequence(WmSetRedrawFalseSeq, "SetRedraw:FALSE", FALSE);
3589
3590 ok(!(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should NOT be set\n");
3591 ok(!IsWindowVisible(hwnd), "IsWindowVisible() should return FALSE\n");
3592
3593 flush_sequence();
3594 SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
3595 ok_sequence(WmSetRedrawTrueSeq, "SetRedraw:TRUE", FALSE);
3596
3597 ok(GetWindowLongA(hwnd, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
3598 ok(IsWindowVisible(hwnd), "IsWindowVisible() should return TRUE\n");
3599
3600 /* restore original WS_VISIBLE state */
3601 SetWindowLongA(hwnd, GWL_STYLE, style);
3602
3603 flush_events();
3604 flush_sequence();
3605 }
3606
3607 static INT_PTR CALLBACK TestModalDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
3608 {
3609 struct message msg;
3610
3611 trace("dialog: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
3612
3613 /* explicitly ignore WM_GETICON message */
3614 if (message == WM_GETICON) return 0;
3615
3616 switch (message)
3617 {
3618 /* ignore */
3619 case WM_MOUSEMOVE:
3620 case WM_SETCURSOR:
3621 case WM_DEVICECHANGE:
3622 return 0;
3623 case WM_NCHITTEST:
3624 return HTCLIENT;
3625
3626 case WM_WINDOWPOSCHANGING:
3627 case WM_WINDOWPOSCHANGED:
3628 {
3629 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
3630
3631 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
3632 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
3633 winpos->hwnd, winpos->hwndInsertAfter,
3634 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
3635 dump_winpos_flags(winpos->flags);
3636
3637 /* Log only documented flags, win2k uses 0x1000 and 0x2000
3638 * in the high word for internal purposes
3639 */
3640 wParam = winpos->flags & 0xffff;
3641 /* We are not interested in the flags that don't match under XP and Win9x */
3642 wParam &= ~(SWP_NOZORDER);
3643 break;
3644 }
3645 }
3646
3647 msg.message = message;
3648 msg.flags = sent|wparam|lparam;
3649 msg.wParam = wParam;
3650 msg.lParam = lParam;
3651 add_message(&msg);
3652
3653 if (message == WM_INITDIALOG) SetTimer( hwnd, 1, 100, NULL );
3654 if (message == WM_TIMER) EndDialog( hwnd, 0 );
3655 return 0;
3656 }
3657
3658 static void test_hv_scroll_1(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
3659 {
3660 DWORD style, exstyle;
3661 INT xmin, xmax;
3662 BOOL ret;
3663
3664 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
3665 style = GetWindowLongA(hwnd, GWL_STYLE);
3666 /* do not be confused by WS_DLGFRAME set */
3667 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
3668
3669 if (clear) ok(style & clear, "style %08x should be set\n", clear);
3670 if (set) ok(!(style & set), "style %08x should not be set\n", set);
3671
3672 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
3673 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
3674 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
3675 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollRange(SB_HORZ/SB_VERT) NC", FALSE);
3676 else
3677 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollRange(SB_HORZ/SB_VERT)", FALSE);
3678
3679 style = GetWindowLongA(hwnd, GWL_STYLE);
3680 if (set) ok(style & set, "style %08x should be set\n", set);
3681 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
3682
3683 /* a subsequent call should do nothing */
3684 ret = SetScrollRange(hwnd, ctl, min, max, FALSE);
3685 ok( ret, "SetScrollRange(%d) error %d\n", ctl, GetLastError());
3686 ok_sequence(WmEmptySeq, "SetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3687
3688 xmin = 0xdeadbeef;
3689 xmax = 0xdeadbeef;
3690 trace("Ignore GetScrollRange error below if you are on Win9x\n");
3691 ret = GetScrollRange(hwnd, ctl, &xmin, &xmax);
3692 ok( ret, "GetScrollRange(%d) error %d\n", ctl, GetLastError());
3693 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3694 ok(xmin == min, "unexpected min scroll value %d\n", xmin);
3695 ok(xmax == max, "unexpected max scroll value %d\n", xmax);
3696 }
3697
3698 static void test_hv_scroll_2(HWND hwnd, INT ctl, DWORD clear, DWORD set, INT min, INT max)
3699 {
3700 DWORD style, exstyle;
3701 SCROLLINFO si;
3702 BOOL ret;
3703
3704 exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
3705 style = GetWindowLongA(hwnd, GWL_STYLE);
3706 /* do not be confused by WS_DLGFRAME set */
3707 if ((style & WS_CAPTION) == WS_CAPTION) style &= ~WS_CAPTION;
3708
3709 if (clear) ok(style & clear, "style %08x should be set\n", clear);
3710 if (set) ok(!(style & set), "style %08x should not be set\n", set);
3711
3712 si.cbSize = sizeof(si);
3713 si.fMask = SIF_RANGE;
3714 si.nMin = min;
3715 si.nMax = max;
3716 SetScrollInfo(hwnd, ctl, &si, TRUE);
3717 if ((style & (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME)) || (exstyle & WS_EX_DLGMODALFRAME))
3718 ok_sequence(WmSetScrollRangeHV_NC_Seq, "SetScrollInfo(SB_HORZ/SB_VERT) NC", FALSE);
3719 else
3720 ok_sequence(WmSetScrollRangeHVSeq, "SetScrollInfo(SB_HORZ/SB_VERT)", FALSE);
3721
3722 style = GetWindowLongA(hwnd, GWL_STYLE);
3723 if (set) ok(style & set, "style %08x should be set\n", set);
3724 if (clear) ok(!(style & clear), "style %08x should not be set\n", clear);
3725
3726 /* a subsequent call should do nothing */
3727 SetScrollInfo(hwnd, ctl, &si, TRUE);
3728 if (style & WS_HSCROLL)
3729 ok_sequence(WmSetScrollRangeHSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3730 else if (style & WS_VSCROLL)
3731 ok_sequence(WmSetScrollRangeVSeq_empty, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3732 else
3733 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3734
3735 si.fMask = SIF_PAGE;
3736 si.nPage = 5;
3737 SetScrollInfo(hwnd, ctl, &si, FALSE);
3738 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3739
3740 si.fMask = SIF_POS;
3741 si.nPos = max - 1;
3742 SetScrollInfo(hwnd, ctl, &si, FALSE);
3743 ok_sequence(WmEmptySeq, "SetScrollInfo(SB_HORZ/SB_VERT) empty sequence", FALSE);
3744
3745 si.fMask = SIF_RANGE;
3746 si.nMin = 0xdeadbeef;
3747 si.nMax = 0xdeadbeef;
3748 ret = GetScrollInfo(hwnd, ctl, &si);
3749 ok( ret, "GetScrollInfo error %d\n", GetLastError());
3750 ok_sequence(WmEmptySeq, "GetScrollRange(SB_HORZ/SB_VERT) empty sequence", FALSE);
3751 ok(si.nMin == min, "unexpected min scroll value %d\n", si.nMin);
3752 ok(si.nMax == max, "unexpected max scroll value %d\n", si.nMax);
3753 }
3754
3755 /* Win9x sends WM_USER+xxx while and NT versions send SBM_xxx messages */
3756 static void test_scroll_messages(HWND hwnd)
3757 {
3758 SCROLLINFO si;
3759 INT min, max;
3760 BOOL ret;
3761
3762 flush_events();
3763 flush_sequence();
3764
3765 min = 0xdeadbeef;
3766 max = 0xdeadbeef;
3767 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
3768 ok( ret, "GetScrollRange error %d\n", GetLastError());
3769 if (sequence->message != WmGetScrollRangeSeq[0].message)
3770 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3771 /* values of min and max are undefined */
3772 flush_sequence();
3773
3774 ret = SetScrollRange(hwnd, SB_CTL, 10, 150, FALSE);
3775 ok( ret, "SetScrollRange error %d\n", GetLastError());
3776 if (sequence->message != WmSetScrollRangeSeq[0].message)
3777 trace("SetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3778 flush_sequence();
3779
3780 min = 0xdeadbeef;
3781 max = 0xdeadbeef;
3782 ret = GetScrollRange(hwnd, SB_CTL, &min, &max);
3783 ok( ret, "GetScrollRange error %d\n", GetLastError());
3784 if (sequence->message != WmGetScrollRangeSeq[0].message)
3785 trace("GetScrollRange(SB_CTL) generated unknown message %04x\n", sequence->message);
3786 /* values of min and max are undefined */
3787 flush_sequence();
3788
3789 si.cbSize = sizeof(si);
3790 si.fMask = SIF_RANGE;
3791 si.nMin = 20;
3792 si.nMax = 160;
3793 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
3794 if (sequence->message != WmSetScrollRangeSeq[0].message)
3795 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3796 flush_sequence();
3797
3798 si.fMask = SIF_PAGE;
3799 si.nPage = 10;
3800 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
3801 if (sequence->message != WmSetScrollRangeSeq[0].message)
3802 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3803 flush_sequence();
3804
3805 si.fMask = SIF_POS;
3806 si.nPos = 20;
3807 SetScrollInfo(hwnd, SB_CTL, &si, FALSE);
3808 if (sequence->message != WmSetScrollRangeSeq[0].message)
3809 trace("SetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3810 flush_sequence();
3811
3812 si.fMask = SIF_RANGE;
3813 si.nMin = 0xdeadbeef;
3814 si.nMax = 0xdeadbeef;
3815 ret = GetScrollInfo(hwnd, SB_CTL, &si);
3816 ok( ret, "GetScrollInfo error %d\n", GetLastError());
3817 if (sequence->message != WmGetScrollInfoSeq[0].message)
3818 trace("GetScrollInfo(SB_CTL) generated unknown message %04x\n", sequence->message);
3819 /* values of min and max are undefined */
3820 flush_sequence();
3821
3822 /* set WS_HSCROLL */
3823 test_hv_scroll_1(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
3824 /* clear WS_HSCROLL */
3825 test_hv_scroll_1(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
3826
3827 /* set WS_HSCROLL */
3828 test_hv_scroll_2(hwnd, SB_HORZ, 0, WS_HSCROLL, 10, 150);
3829 /* clear WS_HSCROLL */
3830 test_hv_scroll_2(hwnd, SB_HORZ, WS_HSCROLL, 0, 0, 0);
3831
3832 /* set WS_VSCROLL */
3833 test_hv_scroll_1(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
3834 /* clear WS_VSCROLL */
3835 test_hv_scroll_1(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
3836
3837 /* set WS_VSCROLL */
3838 test_hv_scroll_2(hwnd, SB_VERT, 0, WS_VSCROLL, 10, 150);
3839 /* clear WS_VSCROLL */
3840 test_hv_scroll_2(hwnd, SB_VERT, WS_VSCROLL, 0, 0, 0);
3841 }
3842
3843 static void test_showwindow(void)
3844 {
3845 HWND hwnd, hchild;
3846 RECT rc;
3847
3848 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
3849 100, 100, 200, 200, 0, 0, 0, NULL);
3850 ok (hwnd != 0, "Failed to create overlapped window\n");
3851 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
3852 0, 0, 10, 10, hwnd, 0, 0, NULL);
3853 ok (hchild != 0, "Failed to create child\n");
3854 flush_sequence();
3855
3856 /* ShowWindow( SW_SHOWNA) for invisible top level window */
3857 trace("calling ShowWindow( SW_SHOWNA) for invisible top level window\n");
3858 ok( ShowWindow(hwnd, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3859 ok_sequence(WmSHOWNATopInvisible, "ShowWindow(SW_SHOWNA) on invisible top level window", TRUE);
3860 trace("done\n");
3861
3862 /* ShowWindow( SW_SHOWNA) for now visible top level window */
3863 trace("calling ShowWindow( SW_SHOWNA) for now visible top level window\n");
3864 ok( ShowWindow(hwnd, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3865 ok_sequence(WmSHOWNATopVisible, "ShowWindow(SW_SHOWNA) on visible top level window", FALSE);
3866 trace("done\n");
3867 /* back to invisible */
3868 ShowWindow(hchild, SW_HIDE);
3869 ShowWindow(hwnd, SW_HIDE);
3870 flush_sequence();
3871 /* ShowWindow(SW_SHOWNA) with child and parent invisible */
3872 trace("calling ShowWindow( SW_SHOWNA) for invisible child with invisible parent\n");
3873 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3874 ok_sequence(WmSHOWNAChildInvisParInvis, "ShowWindow(SW_SHOWNA) invisible child and parent", FALSE);
3875 trace("done\n");
3876 /* ShowWindow(SW_SHOWNA) with child visible and parent invisible */
3877 ok( ShowWindow(hchild, SW_SHOW) != FALSE, "ShowWindow: window was invisible\n" );
3878 flush_sequence();
3879 trace("calling ShowWindow( SW_SHOWNA) for the visible child and invisible parent\n");
3880 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3881 ok_sequence(WmSHOWNAChildVisParInvis, "ShowWindow(SW_SHOWNA) visible child and invisible parent", FALSE);
3882 trace("done\n");
3883 /* ShowWindow(SW_SHOWNA) with child visible and parent visible */
3884 ShowWindow( hwnd, SW_SHOW);
3885 flush_sequence();
3886 trace("calling ShowWindow( SW_SHOWNA) for the visible child and parent\n");
3887 ok( ShowWindow(hchild, SW_SHOWNA) != FALSE, "ShowWindow: window was invisible\n" );
3888 ok_sequence(WmSHOWNAChildVisParVis, "ShowWindow(SW_SHOWNA) for the visible child and parent", FALSE);
3889 trace("done\n");
3890
3891 /* ShowWindow(SW_SHOWNA) with child invisible and parent visible */
3892 ShowWindow( hchild, SW_HIDE);
3893 flush_sequence();
3894 trace("calling ShowWindow( SW_SHOWNA) for the invisible child and visible parent\n");
3895 ok( ShowWindow(hchild, SW_SHOWNA) == FALSE, "ShowWindow: window was visible\n" );
3896 ok_sequence(WmSHOWNAChildInvisParVis, "ShowWindow(SW_SHOWNA) for the invisible child and visible parent", FALSE);
3897 trace("done\n");
3898
3899 SetCapture(hchild);
3900 ok(GetCapture() == hchild, "wrong capture window %p\n", GetCapture());
3901 DestroyWindow(hchild);
3902 ok(!GetCapture(), "wrong capture window %p\n", GetCapture());
3903
3904 DestroyWindow(hwnd);
3905 flush_sequence();
3906
3907 /* Popup windows */
3908 /* Test 1:
3909 * 1. Create invisible maximized popup window.
3910 * 2. Move and resize it.
3911 * 3. Show it maximized.
3912 */
3913 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3914 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
3915 100, 100, 200, 200, 0, 0, 0, NULL);
3916 ok (hwnd != 0, "Failed to create popup window\n");
3917 ok(IsZoomed(hwnd), "window should be maximized\n");
3918 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3919 trace("done\n");
3920
3921 GetWindowRect(hwnd, &rc);
3922 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
3923 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
3924 "Invalid maximized size before ShowWindow (%d,%d)-(%d,%d)\n",
3925 rc.left, rc.top, rc.right, rc.bottom);
3926 /* Reset window's size & position */
3927 SetWindowPos(hwnd, 0, 10, 10, 200, 200, SWP_NOZORDER | SWP_NOACTIVATE);
3928 ok(IsZoomed(hwnd), "window should be maximized\n");
3929 flush_sequence();
3930
3931 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
3932 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3933 ok(IsZoomed(hwnd), "window should be maximized\n");
3934 ok_sequence(WmShowMaxPopupResizedSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized and resized popup", FALSE);
3935 trace("done\n");
3936
3937 GetWindowRect(hwnd, &rc);
3938 ok( rc.right-rc.left == GetSystemMetrics(SM_CXSCREEN) &&
3939 rc.bottom-rc.top == GetSystemMetrics(SM_CYSCREEN),
3940 "Invalid maximized size after ShowWindow (%d,%d)-(%d,%d)\n",
3941 rc.left, rc.top, rc.right, rc.bottom);
3942 DestroyWindow(hwnd);
3943 flush_sequence();
3944
3945 /* Test 2:
3946 * 1. Create invisible maximized popup window.
3947 * 2. Show it maximized.
3948 */
3949 trace("calling CreateWindowExA( WS_MAXIMIZE ) for invisible maximized popup window\n");
3950 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE,
3951 100, 100, 200, 200, 0, 0, 0, NULL);
3952 ok (hwnd != 0, "Failed to create popup window\n");
3953 ok(IsZoomed(hwnd), "window should be maximized\n");
3954 ok_sequence(WmCreateInvisibleMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3955 trace("done\n");
3956
3957 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for invisible maximized popup window\n");
3958 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3959 ok(IsZoomed(hwnd), "window should be maximized\n");
3960 ok_sequence(WmShowMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):invisible maximized popup", FALSE);
3961 trace("done\n");
3962 DestroyWindow(hwnd);
3963 flush_sequence();
3964
3965 /* Test 3:
3966 * 1. Create visible maximized popup window.
3967 */
3968 trace("calling CreateWindowExA( WS_MAXIMIZE ) for maximized popup window\n");
3969 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_MAXIMIZE | WS_VISIBLE,
3970 100, 100, 200, 200, 0, 0, 0, NULL);
3971 ok (hwnd != 0, "Failed to create popup window\n");
3972 ok(IsZoomed(hwnd), "window should be maximized\n");
3973 ok_sequence(WmCreateMaxPopupSeq, "CreateWindow(WS_MAXIMIZED):popup", FALSE);
3974 trace("done\n");
3975 DestroyWindow(hwnd);
3976 flush_sequence();
3977
3978 /* Test 4:
3979 * 1. Create visible popup window.
3980 * 2. Maximize it.
3981 */
3982 trace("calling CreateWindowExA( WS_VISIBLE ) for popup window\n");
3983 hwnd = CreateWindowExA(0, "TestWindowClass", "Test popup", WS_POPUP | WS_VISIBLE,
3984 100, 100, 200, 200, 0, 0, 0, NULL);
3985 ok (hwnd != 0, "Failed to create popup window\n");
3986 ok(!IsZoomed(hwnd), "window should NOT be maximized\n");
3987 ok_sequence(WmCreatePopupSeq, "CreateWindow(WS_VISIBLE):popup", FALSE);
3988 trace("done\n");
3989
3990 trace("calling ShowWindow( SW_SHOWMAXIMIZE ) for visible popup window\n");
3991 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
3992 ok(IsZoomed(hwnd), "window should be maximized\n");
3993 ok_sequence(WmShowVisMaxPopupSeq, "ShowWindow(SW_SHOWMAXIMIZED):popup", FALSE);
3994 trace("done\n");
3995 DestroyWindow(hwnd);
3996 flush_sequence();
3997 }
3998
3999 static void test_sys_menu(void)
4000 {
4001 HWND hwnd;
4002 HMENU hmenu;
4003 UINT state;
4004
4005 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4006 100, 100, 200, 200, 0, 0, 0, NULL);
4007 ok (hwnd != 0, "Failed to create overlapped window\n");
4008
4009 flush_sequence();
4010
4011 /* test existing window without CS_NOCLOSE style */
4012 hmenu = GetSystemMenu(hwnd, FALSE);
4013 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4014
4015 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4016 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4017 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4018
4019 EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
4020 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4021
4022 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4023 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4024 ok((state & (MF_DISABLED | MF_GRAYED)) == MF_GRAYED, "wrong SC_CLOSE state %x\n", state);
4025
4026 EnableMenuItem(hmenu, SC_CLOSE, 0);
4027 ok_sequence(WmEmptySeq, "WmEnableMenuItem", FALSE);
4028
4029 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4030 ok(state != 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4031 ok(!(state & (MF_DISABLED | MF_GRAYED)), "wrong SC_CLOSE state %x\n", state);
4032
4033 /* test whether removing WS_SYSMENU destroys a system menu */
4034 SetWindowLongW(hwnd, GWL_STYLE, WS_POPUP);
4035 SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4036 flush_sequence();
4037 hmenu = GetSystemMenu(hwnd, FALSE);
4038 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4039
4040 DestroyWindow(hwnd);
4041
4042 /* test new window with CS_NOCLOSE style */
4043 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4044 100, 100, 200, 200, 0, 0, 0, NULL);
4045 ok (hwnd != 0, "Failed to create overlapped window\n");
4046
4047 hmenu = GetSystemMenu(hwnd, FALSE);
4048 ok(hmenu != 0, "GetSystemMenu error %d\n", GetLastError());
4049
4050 state = GetMenuState(hmenu, SC_CLOSE, MF_BYCOMMAND);
4051 ok(state == 0xffffffff, "wrong SC_CLOSE state %x\n", state);
4052
4053 DestroyWindow(hwnd);
4054
4055 /* test new window without WS_SYSMENU style */
4056 hwnd = CreateWindowExA(0, "NoCloseWindowClass", NULL, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU,
4057 100, 100, 200, 200, 0, 0, 0, NULL);
4058 ok(hwnd != 0, "Failed to create overlapped window\n");
4059
4060 hmenu = GetSystemMenu(hwnd, FALSE);
4061 ok(!hmenu, "GetSystemMenu error %d\n", GetLastError());
4062
4063 DestroyWindow(hwnd);
4064 }
4065
4066 /* For shown WS_OVERLAPPEDWINDOW */
4067 static const struct message WmSetIcon_1[] = {
4068 { WM_SETICON, sent },
4069 { 0x00AE, sent|defwinproc|optional }, /* XP */
4070 { WM_GETTEXT, sent|defwinproc|optional },
4071 { WM_GETTEXT, sent|defwinproc|optional }, /* XP sends a duplicate */
4072 { 0 }
4073 };
4074
4075 /* For WS_POPUP and hidden WS_OVERLAPPEDWINDOW */
4076 static const struct message WmSetIcon_2[] = {
4077 { WM_SETICON, sent },
4078 { 0 }
4079 };
4080
4081 /* Sending undocumented 0x3B message with wparam = 0x8000000b */
4082 static const struct message WmInitEndSession[] = {
4083 { 0x003B, sent },
4084 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4085 { 0 }
4086 };
4087
4088 /* Sending undocumented 0x3B message with wparam = 0x0000000b */
4089 static const struct message WmInitEndSession_2[] = {
4090 { 0x003B, sent },
4091 { WM_QUERYENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4092 { 0 }
4093 };
4094
4095 /* Sending undocumented 0x3B message with wparam = 0x80000008 */
4096 static const struct message WmInitEndSession_3[] = {
4097 { 0x003B, sent },
4098 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, ENDSESSION_LOGOFF },
4099 { 0 }
4100 };
4101
4102 /* Sending undocumented 0x3B message with wparam = 0x00000008 */
4103 static const struct message WmInitEndSession_4[] = {
4104 { 0x003B, sent },
4105 { WM_ENDSESSION, sent|defwinproc|wparam|lparam, 0, 0 },
4106 { 0 }
4107 };
4108
4109 /* Sending undocumented 0x3B message with wparam = 0x80000001 */
4110 static const struct message WmInitEndSession_5[] = {
4111 { 0x003B, sent },
4112 { WM_ENDSESSION, sent|defwinproc/*|wparam*/|lparam, 1, ENDSESSION_LOGOFF },
4113 { 0 }
4114 };
4115
4116 static const struct message WmZOrder[] = {
4117 { WM_WINDOWPOSCHANGING, sent|wparam, 0, 0 },
4118 { WM_GETMINMAXINFO, sent|defwinproc|wparam, 0, 0 },
4119 { HCBT_ACTIVATE, hook },
4120 { WM_WINDOWPOSCHANGING, sent|wparam, 3, 0 },
4121 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE, 0 },
4122 { WM_GETTEXT, sent|optional },
4123 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
4124 { WM_ACTIVATEAPP, sent|wparam, 1, 0 },
4125 { WM_NCACTIVATE, sent|wparam|lparam, 1, 0 },
4126 { WM_GETTEXT, sent|defwinproc|optional },
4127 { WM_GETTEXT, sent|defwinproc|optional },
4128 { WM_ACTIVATE, sent|wparam|lparam, 1, 0 },
4129 { HCBT_SETFOCUS, hook },
4130 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
4131 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4132 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
4133 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
4134 { WM_GETTEXT, sent|optional },
4135 { WM_NCCALCSIZE, sent|optional },
4136 { 0 }
4137 };
4138
4139 static void test_MsgWaitForMultipleObjects(HWND hwnd)
4140 {
4141 DWORD ret;
4142 MSG msg;
4143
4144 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4145 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4146
4147 PostMessageA(hwnd, WM_USER, 0, 0);
4148
4149 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4150 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4151
4152 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4153 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4154
4155 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4156 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4157
4158 PostMessageA(hwnd, WM_USER, 0, 0);
4159
4160 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4161 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4162
4163 ok(PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "PeekMessage should succeed\n");
4164 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4165
4166 /* shows QS_POSTMESSAGE flag is cleared in the PeekMessage call */
4167 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4168 ok(ret == WAIT_TIMEOUT, "MsgWaitForMultipleObjects returned %x\n", ret);
4169
4170 PostMessageA(hwnd, WM_USER, 0, 0);
4171
4172 /* new incoming message causes it to become signaled again */
4173 ret = MsgWaitForMultipleObjects(0, NULL, FALSE, 0, QS_POSTMESSAGE);
4174 ok(ret == WAIT_OBJECT_0, "MsgWaitForMultipleObjects returned %x\n", ret);
4175
4176 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4177 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4178 ok(PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n");
4179 ok(msg.message == WM_USER, "got %04x instead of WM_USER\n", msg.message);
4180 }
4181
4182 /* test if we receive the right sequence of messages */
4183 static void test_messages(void)
4184 {
4185 HWND hwnd, hparent, hchild;
4186 HWND hchild2, hbutton;
4187 HMENU hmenu;
4188 MSG msg;
4189 LRESULT res;
4190
4191 flush_sequence();
4192
4193 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4194 100, 100, 200, 200, 0, 0, 0, NULL);
4195 ok (hwnd != 0, "Failed to create overlapped window\n");
4196 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4197
4198 /* test ShowWindow(SW_HIDE) on a newly created invisible window */
4199 ok( ShowWindow(hwnd, SW_HIDE) == FALSE, "ShowWindow: window was visible\n" );
4200 ok_sequence(WmEmptySeq, "ShowWindow(SW_HIDE):overlapped, invisible", FALSE);
4201
4202 /* test WM_SETREDRAW on a not visible top level window */
4203 test_WM_SETREDRAW(hwnd);
4204
4205 SetWindowPos(hwnd, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4206 flush_events();
4207 ok_sequence(WmSWP_ShowOverlappedSeq, "SetWindowPos:SWP_SHOWWINDOW:overlapped", FALSE);
4208 ok(IsWindowVisible(hwnd), "window should be visible at this point\n");
4209
4210 ok(GetActiveWindow() == hwnd, "window should be active\n");
4211 ok(GetFocus() == hwnd, "window should have input focus\n");
4212 ShowWindow(hwnd, SW_HIDE);
4213 flush_events();
4214 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4215
4216 ShowWindow(hwnd, SW_SHOW);
4217 flush_events();
4218 ok_sequence(WmShowOverlappedSeq, "ShowWindow(SW_SHOW):overlapped", TRUE);
4219
4220 ShowWindow(hwnd, SW_HIDE);
4221 flush_events();
4222 ok_sequence(WmHideOverlappedSeq, "ShowWindow(SW_HIDE):overlapped", FALSE);
4223
4224 ShowWindow(hwnd, SW_SHOWMAXIMIZED);
4225 flush_events();
4226 ok_sequence(WmShowMaxOverlappedSeq, "ShowWindow(SW_SHOWMAXIMIZED):overlapped", TRUE);
4227
4228 ShowWindow(hwnd, SW_RESTORE);
4229 ok_sequence(WmShowRestoreMaxOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", FALSE);
4230 flush_events();
4231 flush_sequence();
4232
4233 ShowWindow(hwnd, SW_MINIMIZE);
4234 flush_events();
4235 ok_sequence(WmShowMinOverlappedSeq, "ShowWindow(SW_SHOWMINIMIZED):overlapped", TRUE);
4236 flush_sequence();
4237
4238 ShowWindow(hwnd, SW_RESTORE);
4239 flush_events();
4240 ok_sequence(WmShowRestoreMinOverlappedSeq, "ShowWindow(SW_RESTORE):overlapped", TRUE);
4241 flush_sequence();
4242
4243 ShowWindow(hwnd, SW_SHOW);
4244 flush_events();
4245 ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW):overlapped already visible", FALSE);
4246
4247 ok(GetActiveWindow() == hwnd, "window should be active\n");
4248 ok(GetFocus() == hwnd, "window should have input focus\n");
4249 SetWindowPos(hwnd, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4250 ok_sequence(WmSWP_HideOverlappedSeq, "SetWindowPos:SWP_HIDEWINDOW:overlapped", FALSE);
4251 ok(!IsWindowVisible(hwnd), "window should not be visible at this point\n");
4252 ok(GetActiveWindow() == hwnd, "window should still be active\n");
4253
4254 /* test WM_SETREDRAW on a visible top level window */
4255 ShowWindow(hwnd, SW_SHOW);
4256 flush_events();
4257 test_WM_SETREDRAW(hwnd);
4258
4259 trace("testing scroll APIs on a visible top level window %p\n", hwnd);
4260 test_scroll_messages(hwnd);
4261
4262 /* test resizing and moving */
4263 SetWindowPos( hwnd, 0, 0, 0, 300, 300, SWP_NOMOVE|SWP_NOACTIVATE );
4264 ok_sequence(WmSWP_ResizeSeq, "SetWindowPos:Resize", FALSE );
4265 flush_events();
4266 flush_sequence();
4267 SetWindowPos( hwnd, 0, 200, 200, 0, 0, SWP_NOSIZE|SWP_NOACTIVATE );
4268 ok_sequence(WmSWP_MoveSeq, "SetWindowPos:Move", FALSE );
4269 flush_events();
4270 flush_sequence();
4271 SetWindowPos( hwnd, 0, 200, 200, 250, 250, SWP_NOZORDER|SWP_NOACTIVATE );
4272 ok_sequence(WmSWP_ResizeNoZOrder, "SetWindowPos:WmSWP_ResizeNoZOrder", FALSE );
4273 flush_events();
4274 flush_sequence();
4275
4276 /* popups don't get WM_GETMINMAXINFO */
4277 SetWindowLongW( hwnd, GWL_STYLE, WS_VISIBLE|WS_POPUP );
4278 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED);
4279 flush_sequence();
4280 SetWindowPos( hwnd, 0, 0, 0, 200, 200, SWP_NOMOVE|SWP_NOACTIVATE );
4281 ok_sequence(WmSWP_ResizePopupSeq, "SetWindowPos:ResizePopup", FALSE );
4282
4283 DestroyWindow(hwnd);
4284 ok_sequence(WmDestroyOverlappedSeq, "DestroyWindow:overlapped", FALSE);
4285
4286 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4287 100, 100, 200, 200, 0, 0, 0, NULL);
4288 ok (hparent != 0, "Failed to create parent window\n");
4289 flush_sequence();
4290
4291 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_MAXIMIZE,
4292 0, 0, 10, 10, hparent, 0, 0, NULL);
4293 ok (hchild != 0, "Failed to create child window\n");
4294 ok_sequence(WmCreateMaximizedChildSeq, "CreateWindow:maximized child", FALSE);
4295 DestroyWindow(hchild);
4296 flush_sequence();
4297
4298 /* visible child window with a caption */
4299 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
4300 WS_CHILD | WS_VISIBLE | WS_CAPTION,
4301 0, 0, 10, 10, hparent, 0, 0, NULL);
4302 ok (hchild != 0, "Failed to create child window\n");
4303 ok_sequence(WmCreateVisibleChildSeq, "CreateWindow:visible child", FALSE);
4304
4305 trace("testing scroll APIs on a visible child window %p\n", hchild);
4306 test_scroll_messages(hchild);
4307
4308 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4309 ok_sequence(WmShowChildSeq_4, "SetWindowPos(SWP_SHOWWINDOW):child with a caption", FALSE);
4310
4311 DestroyWindow(hchild);
4312 flush_sequence();
4313
4314 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4315 0, 0, 10, 10, hparent, 0, 0, NULL);
4316 ok (hchild != 0, "Failed to create child window\n");
4317 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4318
4319 hchild2 = CreateWindowExA(0, "SimpleWindowClass", "Test child2", WS_CHILD,
4320 100, 100, 50, 50, hparent, 0, 0, NULL);
4321 ok (hchild2 != 0, "Failed to create child2 window\n");
4322 flush_sequence();
4323
4324 hbutton = CreateWindowExA(0, "TestWindowClass", "Test button", WS_CHILD,
4325 0, 100, 50, 50, hchild, 0, 0, NULL);
4326 ok (hbutton != 0, "Failed to create button window\n");
4327
4328 /* test WM_SETREDRAW on a not visible child window */
4329 test_WM_SETREDRAW(hchild);
4330
4331 ShowWindow(hchild, SW_SHOW);
4332 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4333
4334 /* check parent messages too */
4335 log_all_parent_messages++;
4336 ShowWindow(hchild, SW_HIDE);
4337 ok_sequence(WmHideChildSeq2, "ShowWindow(SW_HIDE):child", FALSE);
4338 log_all_parent_messages--;
4339
4340 ShowWindow(hchild, SW_SHOW);
4341 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4342
4343 ShowWindow(hchild, SW_HIDE);
4344 ok_sequence(WmHideChildSeq, "ShowWindow(SW_HIDE):child", FALSE);
4345
4346 ShowWindow(hchild, SW_SHOW);
4347 ok_sequence(WmShowChildSeq, "ShowWindow(SW_SHOW):child", FALSE);
4348
4349 /* test WM_SETREDRAW on a visible child window */
4350 test_WM_SETREDRAW(hchild);
4351
4352 log_all_parent_messages++;
4353 MoveWindow(hchild, 10, 10, 20, 20, TRUE);
4354 ok_sequence(WmResizingChildWithMoveWindowSeq, "MoveWindow:child", FALSE);
4355 log_all_parent_messages--;
4356
4357 ShowWindow(hchild, SW_HIDE);
4358 flush_sequence();
4359 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4360 ok_sequence(WmShowChildSeq_2, "SetWindowPos:show_child_2", FALSE);
4361
4362 ShowWindow(hchild, SW_HIDE);
4363 flush_sequence();
4364 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE);
4365 ok_sequence(WmShowChildSeq_3, "SetWindowPos:show_child_3", FALSE);
4366
4367 /* DestroyWindow sequence below expects that a child has focus */
4368 SetFocus(hchild);
4369 flush_sequence();
4370
4371 DestroyWindow(hchild);
4372 ok_sequence(WmDestroyChildSeq, "DestroyWindow:child", FALSE);
4373 DestroyWindow(hchild2);
4374 DestroyWindow(hbutton);
4375
4376 flush_sequence();
4377 hchild = CreateWindowExA(0, "TestWindowClass", "Test Child Popup", WS_CHILD | WS_POPUP,
4378 0, 0, 100, 100, hparent, 0, 0, NULL);
4379 ok (hchild != 0, "Failed to create child popup window\n");
4380 ok_sequence(WmCreateChildPopupSeq, "CreateWindow:child_popup", FALSE);
4381 DestroyWindow(hchild);
4382
4383 /* test what happens to a window which sets WS_VISIBLE in WM_CREATE */
4384 flush_sequence();
4385 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP,
4386 0, 0, 100, 100, hparent, 0, 0, NULL);
4387 ok (hchild != 0, "Failed to create popup window\n");
4388 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4389 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4390 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4391 flush_sequence();
4392 ShowWindow(hchild, SW_SHOW);
4393 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4394 flush_sequence();
4395 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4396 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4397 flush_sequence();
4398 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE);
4399 ok_sequence(WmShowVisiblePopupSeq_3, "SetWindowPos:show_visible_popup_3", TRUE);
4400 DestroyWindow(hchild);
4401
4402 /* this time add WS_VISIBLE for CreateWindowEx, but this fact actually
4403 * changes nothing in message sequences.
4404 */
4405 flush_sequence();
4406 hchild = CreateWindowExA(0, "TestPopupClass", "Test Popup", WS_POPUP | WS_VISIBLE,
4407 0, 0, 100, 100, hparent, 0, 0, NULL);
4408 ok (hchild != 0, "Failed to create popup window\n");
4409 ok_sequence(WmCreateInvisiblePopupSeq, "CreateWindow:invisible_popup", FALSE);
4410 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4411 ok(IsWindowVisible(hchild), "IsWindowVisible() should return TRUE\n");
4412 flush_sequence();
4413 ShowWindow(hchild, SW_SHOW);
4414 ok_sequence(WmEmptySeq, "ShowWindow:show_visible_popup", FALSE);
4415 flush_sequence();
4416 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4417 ok_sequence(WmShowVisiblePopupSeq_2, "SetWindowPos:show_visible_popup_2", FALSE);
4418 DestroyWindow(hchild);
4419
4420 flush_sequence();
4421 hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL, WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
4422 0, 0, 100, 100, hparent, 0, 0, NULL);
4423 ok(hwnd != 0, "Failed to create custom dialog window\n");
4424 ok_sequence(WmCreateCustomDialogSeq, "CreateCustomDialog", TRUE);
4425
4426 /*
4427 trace("testing scroll APIs on a visible dialog %p\n", hwnd);
4428 test_scroll_messages(hwnd);
4429 */
4430
4431 flush_sequence();
4432
4433 test_def_id = 1;
4434 SendMessage(hwnd, WM_NULL, 0, 0);
4435
4436 flush_sequence();
4437 after_end_dialog = 1;
4438 EndDialog( hwnd, 0 );
4439 ok_sequence(WmEndCustomDialogSeq, "EndCustomDialog", FALSE);
4440
4441 DestroyWindow(hwnd);
4442 after_end_dialog = 0;
4443 test_def_id = 0;
4444
4445 hwnd = CreateWindowExA(0, "TestDialogClass", NULL, WS_POPUP,
4446 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), NULL);
4447 ok(hwnd != 0, "Failed to create custom dialog window\n");
4448 flush_sequence();
4449 trace("call ShowWindow(%p, SW_SHOW)\n", hwnd);
4450 ShowWindow(hwnd, SW_SHOW);
4451 ok_sequence(WmShowCustomDialogSeq, "ShowCustomDialog", TRUE);
4452 DestroyWindow(hwnd);
4453
4454 flush_sequence();
4455 DialogBoxA( 0, "TEST_DIALOG", hparent, TestModalDlgProcA );
4456 ok_sequence(WmModalDialogSeq, "ModalDialog", TRUE);
4457
4458 DestroyWindow(hparent);
4459 flush_sequence();
4460
4461 /* Message sequence for SetMenu */
4462 ok(!DrawMenuBar(hwnd), "DrawMenuBar should return FALSE for a window without a menu\n");
4463 ok_sequence(WmEmptySeq, "DrawMenuBar for a window without a menu", FALSE);
4464
4465 hmenu = CreateMenu();
4466 ok (hmenu != 0, "Failed to create menu\n");
4467 ok (InsertMenuA(hmenu, -1, MF_BYPOSITION, 0x1000, "foo"), "InsertMenu failed\n");
4468 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
4469 100, 100, 200, 200, 0, hmenu, 0, NULL);
4470 ok_sequence(WmCreateOverlappedSeq, "CreateWindow:overlapped", FALSE);
4471 ok (SetMenu(hwnd, 0), "SetMenu\n");
4472 ok_sequence(WmSetMenuNonVisibleSizeChangeSeq, "SetMenu:NonVisibleSizeChange", FALSE);
4473 ok (SetMenu(hwnd, 0), "SetMenu\n");
4474 ok_sequence(WmSetMenuNonVisibleNoSizeChangeSeq, "SetMenu:NonVisibleNoSizeChange", FALSE);
4475 ShowWindow(hwnd, SW_SHOW);
4476 UpdateWindow( hwnd );
4477 flush_events();
4478 flush_sequence();
4479 ok (SetMenu(hwnd, 0), "SetMenu\n");
4480 ok_sequence(WmSetMenuVisibleNoSizeChangeSeq, "SetMenu:VisibleNoSizeChange", FALSE);
4481 ok (SetMenu(hwnd, hmenu), "SetMenu\n");
4482 ok_sequence(WmSetMenuVisibleSizeChangeSeq, "SetMenu:VisibleSizeChange", FALSE);
4483
4484 UpdateWindow( hwnd );
4485 flush_events();
4486 flush_sequence();
4487 ok(DrawMenuBar(hwnd), "DrawMenuBar\n");
4488 flush_events();
4489 ok_sequence(WmDrawMenuBarSeq, "DrawMenuBar", FALSE);
4490
4491 DestroyWindow(hwnd);
4492 flush_sequence();
4493
4494 /* Message sequence for EnableWindow */
4495 hparent = CreateWindowExA(0, "TestWindowClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
4496 100, 100, 200, 200, 0, 0, 0, NULL);
4497 ok (hparent != 0, "Failed to create parent window\n");
4498 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
4499 0, 0, 10, 10, hparent, 0, 0, NULL);
4500 ok (hchild != 0, "Failed to create child window\n");
4501
4502 SetFocus(hchild);
4503 flush_events();
4504 flush_sequence();
4505
4506 EnableWindow(hparent, FALSE);
4507 ok_sequence(WmEnableWindowSeq_1, "EnableWindow(FALSE)", FALSE);
4508
4509 EnableWindow(hparent, TRUE);
4510 ok_sequence(WmEnableWindowSeq_2, "EnableWindow(TRUE)", FALSE);
4511
4512 flush_events();
4513 flush_sequence();
4514
4515 test_MsgWaitForMultipleObjects(hparent);
4516
4517 /* the following test causes an exception in user.exe under win9x */
4518 if (!PostMessageW( hparent, WM_USER, 0, 0 ))
4519 {
4520 DestroyWindow(hparent);
4521 flush_sequence();
4522 return;
4523 }
4524 PostMessageW( hparent, WM_USER+1, 0, 0 );
4525 /* PeekMessage(NULL) fails, but still removes the message */
4526 SetLastError(0xdeadbeef);
4527 ok( !PeekMessageW( NULL, 0, 0, 0, PM_REMOVE ), "PeekMessage(NULL) should fail\n" );
4528 ok( GetLastError() == ERROR_NOACCESS || /* Win2k */
4529 GetLastError() == 0xdeadbeef, /* NT4 */
4530 "last error is %d\n", GetLastError() );
4531 ok( PeekMessageW( &msg, 0, 0, 0, PM_REMOVE ), "PeekMessage should succeed\n" );
4532 ok( msg.message == WM_USER+1, "got %x instead of WM_USER+1\n", msg.message );
4533
4534 DestroyWindow(hchild);
4535 DestroyWindow(hparent);
4536 flush_sequence();
4537
4538 /* Message sequences for WM_SETICON */
4539 trace("testing WM_SETICON\n");
4540 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
4541 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4542 NULL, NULL, 0);
4543 ShowWindow(hwnd, SW_SHOW);
4544 UpdateWindow(hwnd);
4545 flush_events();
4546 flush_sequence();
4547 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4548 ok_sequence(WmSetIcon_1, "WM_SETICON for shown window with caption", FALSE);
4549
4550 ShowWindow(hwnd, SW_HIDE);
4551 flush_events();
4552 flush_sequence();
4553 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4554 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window with caption", FALSE);
4555 DestroyWindow(hwnd);
4556 flush_sequence();
4557
4558 hwnd = CreateWindowExA(0, "TestPopupClass", NULL, WS_POPUP,
4559 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
4560 NULL, NULL, 0);
4561 ShowWindow(hwnd, SW_SHOW);
4562 UpdateWindow(hwnd);
4563 flush_events();
4564 flush_sequence();
4565 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4566 ok_sequence(WmSetIcon_2, "WM_SETICON for shown window without caption", FALSE);
4567
4568 ShowWindow(hwnd, SW_HIDE);
4569 flush_events();
4570 flush_sequence();
4571 SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(0, IDI_APPLICATION));
4572 ok_sequence(WmSetIcon_2, "WM_SETICON for hidden window without caption", FALSE);
4573
4574 flush_sequence();
4575 res = SendMessage(hwnd, 0x3B, 0x8000000b, 0);
4576 if (!res)
4577 {
4578 todo_wine win_skip( "Message 0x3b not supported\n" );
4579 goto done;
4580 }
4581 ok_sequence(WmInitEndSession, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x8000000b", TRUE);
4582 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x8000000b, 0) should have returned 1 instead of %ld\n", res);
4583 res = SendMessage(hwnd, 0x3B, 0x0000000b, 0);
4584 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000b", TRUE);
4585 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000b, 0) should have returned 1 instead of %ld\n", res);
4586 res = SendMessage(hwnd, 0x3B, 0x0000000f, 0);
4587 ok_sequence(WmInitEndSession_2, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x0000000f", TRUE);
4588 ok(res == 1, "SendMessage(hwnd, 0x3B, 0x0000000f, 0) should have returned 1 instead of %ld\n", res);
4589
4590 flush_sequence();
4591 res = SendMessage(hwnd, 0x3B, 0x80000008, 0);
4592 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000008", TRUE);
4593 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000008, 0) should have returned 2 instead of %ld\n", res);
4594 res = SendMessage(hwnd, 0x3B, 0x00000008, 0);
4595 ok_sequence(WmInitEndSession_4, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x00000008", TRUE);
4596 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x00000008, 0) should have returned 2 instead of %ld\n", res);
4597
4598 res = SendMessage(hwnd, 0x3B, 0x80000004, 0);
4599 ok_sequence(WmInitEndSession_3, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000004", TRUE);
4600 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000004, 0) should have returned 2 instead of %ld\n", res);
4601
4602 res = SendMessage(hwnd, 0x3B, 0x80000001, 0);
4603 ok_sequence(WmInitEndSession_5, "Handling of undocumented 0x3B message by DefWindowProc wparam=0x80000001", TRUE);
4604 ok(res == 2, "SendMessage(hwnd, 0x3B, 0x80000001, 0) should have returned 2 instead of %ld\n", res);
4605
4606 done:
4607 DestroyWindow(hwnd);
4608 flush_sequence();
4609 }
4610
4611 static void test_setwindowpos(void)
4612 {
4613 HWND hwnd;
4614 RECT rc;
4615 LRESULT res;
4616 const INT winX = 100;
4617 const INT winY = 100;
4618 const INT sysX = GetSystemMetrics(SM_CXMINTRACK);
4619
4620 hwnd = CreateWindowExA(0, "TestWindowClass", NULL, 0,
4621 0, 0, winX, winY, 0,
4622 NULL, NULL, 0);
4623
4624 GetWindowRect(hwnd, &rc);
4625 expect(sysX, rc.right);
4626 expect(winY, rc.bottom);
4627
4628 flush_events();
4629 flush_sequence();
4630 res = SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, winX, winY, 0);
4631 ok_sequence(WmZOrder, "Z-Order", TRUE);
4632 ok(res == TRUE, "SetWindowPos expected TRUE, got %ld\n", res);
4633
4634 GetWindowRect(hwnd, &rc);
4635 expect(sysX, rc.right);
4636 expect(winY, rc.bottom);
4637 DestroyWindow(hwnd);
4638 }
4639
4640 static void invisible_parent_tests(void)
4641 {
4642 HWND hparent, hchild;
4643
4644 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
4645 100, 100, 200, 200, 0, 0, 0, NULL);
4646 ok (hparent != 0, "Failed to create parent window\n");
4647 flush_sequence();
4648
4649 /* test showing child with hidden parent */
4650
4651 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4652 0, 0, 10, 10, hparent, 0, 0, NULL);
4653 ok (hchild != 0, "Failed to create child window\n");
4654 ok_sequence(WmCreateChildSeq, "CreateWindow:child", FALSE);
4655
4656 ShowWindow( hchild, SW_MINIMIZE );
4657 ok_sequence(WmShowChildInvisibleParentSeq_1, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
4658 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4659 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4660
4661 /* repeat */
4662 flush_events();
4663 flush_sequence();
4664 ShowWindow( hchild, SW_MINIMIZE );
4665 ok_sequence(WmShowChildInvisibleParentSeq_1r, "ShowWindow(SW_MINIMIZE) child with invisible parent", FALSE);
4666
4667 DestroyWindow(hchild);
4668 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4669 0, 0, 10, 10, hparent, 0, 0, NULL);
4670 flush_sequence();
4671
4672 ShowWindow( hchild, SW_MAXIMIZE );
4673 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
4674 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4675 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4676
4677 /* repeat */
4678 flush_events();
4679 flush_sequence();
4680 ShowWindow( hchild, SW_MAXIMIZE );
4681 ok_sequence(WmShowChildInvisibleParentSeq_2r, "ShowWindow(SW_MAXIMIZE) child with invisible parent", FALSE);
4682
4683 DestroyWindow(hchild);
4684 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4685 0, 0, 10, 10, hparent, 0, 0, NULL);
4686 flush_sequence();
4687
4688 ShowWindow( hchild, SW_RESTORE );
4689 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_RESTORE) child with invisible parent", FALSE);
4690 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4691 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4692
4693 DestroyWindow(hchild);
4694 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4695 0, 0, 10, 10, hparent, 0, 0, NULL);
4696 flush_sequence();
4697
4698 ShowWindow( hchild, SW_SHOWMINIMIZED );
4699 ok_sequence(WmShowChildInvisibleParentSeq_3, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
4700 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4701 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4702
4703 /* repeat */
4704 flush_events();
4705 flush_sequence();
4706 ShowWindow( hchild, SW_SHOWMINIMIZED );
4707 ok_sequence(WmShowChildInvisibleParentSeq_3r, "ShowWindow(SW_SHOWMINIMIZED) child with invisible parent", FALSE);
4708
4709 DestroyWindow(hchild);
4710 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4711 0, 0, 10, 10, hparent, 0, 0, NULL);
4712 flush_sequence();
4713
4714 /* same as ShowWindow( hchild, SW_MAXIMIZE ); */
4715 ShowWindow( hchild, SW_SHOWMAXIMIZED );
4716 ok_sequence(WmShowChildInvisibleParentSeq_2, "ShowWindow(SW_SHOWMAXIMIZED) child with invisible parent", FALSE);
4717 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4718 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4719
4720 DestroyWindow(hchild);
4721 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4722 0, 0, 10, 10, hparent, 0, 0, NULL);
4723 flush_sequence();
4724
4725 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
4726 ok_sequence(WmShowChildInvisibleParentSeq_4, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
4727 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4728 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4729
4730 /* repeat */
4731 flush_events();
4732 flush_sequence();
4733 ShowWindow( hchild, SW_SHOWMINNOACTIVE );
4734 ok_sequence(WmShowChildInvisibleParentSeq_4r, "ShowWindow(SW_SHOWMINNOACTIVE) child with invisible parent", FALSE);
4735
4736 DestroyWindow(hchild);
4737 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4738 0, 0, 10, 10, hparent, 0, 0, NULL);
4739 flush_sequence();
4740
4741 /* FIXME: looks like XP SP2 doesn't know about SW_FORCEMINIMIZE at all */
4742 ShowWindow( hchild, SW_FORCEMINIMIZE );
4743 ok_sequence(WmEmptySeq, "ShowWindow(SW_FORCEMINIMIZE) child with invisible parent", TRUE);
4744 todo_wine {
4745 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
4746 }
4747 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4748
4749 DestroyWindow(hchild);
4750 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4751 0, 0, 10, 10, hparent, 0, 0, NULL);
4752 flush_sequence();
4753
4754 ShowWindow( hchild, SW_SHOWNA );
4755 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
4756 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4757 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4758
4759 /* repeat */
4760 flush_events();
4761 flush_sequence();
4762 ShowWindow( hchild, SW_SHOWNA );
4763 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOWNA) child with invisible parent", FALSE);
4764
4765 DestroyWindow(hchild);
4766 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD,
4767 0, 0, 10, 10, hparent, 0, 0, NULL);
4768 flush_sequence();
4769
4770 ShowWindow( hchild, SW_SHOW );
4771 ok_sequence(WmShowChildInvisibleParentSeq_5, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
4772 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4773 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4774
4775 /* repeat */
4776 flush_events();
4777 flush_sequence();
4778 ShowWindow( hchild, SW_SHOW );
4779 ok_sequence(WmEmptySeq, "ShowWindow(SW_SHOW) child with invisible parent", FALSE);
4780
4781 ShowWindow( hchild, SW_HIDE );
4782 ok_sequence(WmHideChildInvisibleParentSeq, "ShowWindow:hide child with invisible parent", FALSE);
4783 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should be not set\n");
4784 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4785
4786 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4787 ok_sequence(WmShowChildInvisibleParentSeq_6, "SetWindowPos:show child with invisible parent", FALSE);
4788 ok(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE, "WS_VISIBLE should be set\n");
4789 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4790
4791 SetWindowPos(hchild, 0,0,0,0,0, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4792 ok_sequence(WmHideChildInvisibleParentSeq_2, "SetWindowPos:hide child with invisible parent", FALSE);
4793 ok(!(GetWindowLongA(hchild, GWL_STYLE) & WS_VISIBLE), "WS_VISIBLE should not be set\n");
4794 ok(!IsWindowVisible(hchild), "IsWindowVisible() should return FALSE\n");
4795
4796 SetWindowPos(hchild, 0,0,0,0,0, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
4797 flush_sequence();
4798 DestroyWindow(hchild);
4799 ok_sequence(WmDestroyInvisibleChildSeq, "DestroyInvisibleChildSeq", FALSE);
4800
4801 DestroyWindow(hparent);
4802 flush_sequence();
4803 }
4804
4805 /****************** button message test *************************/
4806 static const struct message WmSetFocusButtonSeq[] =
4807 {
4808 { HCBT_SETFOCUS, hook },
4809 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
4810 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4811 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4812 { WM_SETFOCUS, sent|wparam, 0 },
4813 { WM_CTLCOLORBTN, sent|defwinproc },
4814 { 0 }
4815 };
4816 static const struct message WmKillFocusButtonSeq[] =
4817 {
4818 { HCBT_SETFOCUS, hook },
4819 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4820 { WM_KILLFOCUS, sent|wparam, 0 },
4821 { WM_CTLCOLORBTN, sent|defwinproc },
4822 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
4823 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
4824 { 0 }
4825 };
4826 static const struct message WmSetFocusStaticSeq[] =
4827 {
4828 { HCBT_SETFOCUS, hook },
4829 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
4830 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4831 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4832 { WM_SETFOCUS, sent|wparam, 0 },
4833 { WM_CTLCOLORSTATIC, sent|defwinproc },
4834 { 0 }
4835 };
4836 static const struct message WmKillFocusStaticSeq[] =
4837 {
4838 { HCBT_SETFOCUS, hook },
4839 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4840 { WM_KILLFOCUS, sent|wparam, 0 },
4841 { WM_CTLCOLORSTATIC, sent|defwinproc },
4842 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
4843 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
4844 { 0 }
4845 };
4846 static const struct message WmLButtonDownSeq[] =
4847 {
4848 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
4849 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
4850 { HCBT_SETFOCUS, hook },
4851 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
4852 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
4853 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4854 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
4855 { WM_CTLCOLORBTN, sent|defwinproc },
4856 { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
4857 { WM_CTLCOLORBTN, sent|defwinproc },
4858 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4859 { 0 }
4860 };
4861 static const struct message WmLButtonUpSeq[] =
4862 {
4863 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
4864 { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
4865 { WM_CTLCOLORBTN, sent|defwinproc },
4866 { EVENT_OBJECT_STATECHANGE, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
4867 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
4868 { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
4869 { 0 }
4870 };
4871 static const struct message WmSetFontButtonSeq[] =
4872 {
4873 { WM_SETFONT, sent },
4874 { WM_PAINT, sent },
4875 { WM_ERASEBKGND, sent|defwinproc|optional },
4876 { WM_CTLCOLORBTN, sent|defwinproc },
4877 { 0 }
4878 };
4879
4880 static WNDPROC old_button_proc;
4881
4882 static LRESULT CALLBACK button_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
4883 {
4884 static long defwndproc_counter = 0;
4885 LRESULT ret;
4886 struct message msg;
4887
4888 trace("button: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
4889
4890 /* explicitly ignore WM_GETICON message */
4891 if (message == WM_GETICON) return 0;
4892
4893 msg.message = message;
4894 msg.flags = sent|wparam|lparam;
4895 if (defwndproc_counter) msg.flags |= defwinproc;
4896 msg.wParam = wParam;
4897 msg.lParam = lParam;
4898 add_message(&msg);
4899
4900 if (message == BM_SETSTATE)
4901 ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
4902
4903 defwndproc_counter++;
4904 ret = CallWindowProcA(old_button_proc, hwnd, message, wParam, lParam);
4905 defwndproc_counter--;
4906
4907 return ret;
4908 }
4909
4910 static void subclass_button(void)
4911 {
4912 WNDCLASSA cls;
4913
4914 if (!GetClassInfoA(0, "button", &cls)) assert(0);
4915
4916 old_button_proc = cls.lpfnWndProc;
4917
4918 cls.hInstance = GetModuleHandle(0);
4919 cls.lpfnWndProc = button_hook_proc;
4920 cls.lpszClassName = "my_button_class";
4921 UnregisterClass(cls.lpszClassName, cls.hInstance);
4922 if (!RegisterClassA(&cls)) assert(0);
4923 }
4924
4925 static void test_button_messages(void)
4926 {
4927 static const struct
4928 {
4929 DWORD style;
4930 DWORD dlg_code;
4931 const struct message *setfocus;
4932 const struct message *killfocus;
4933 } button[] = {
4934 { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
4935 WmSetFocusButtonSeq, WmKillFocusButtonSeq },
4936 { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
4937 WmSetFocusButtonSeq, WmKillFocusButtonSeq },
4938 { BS_CHECKBOX, DLGC_BUTTON,
4939 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4940 { BS_AUTOCHECKBOX, DLGC_BUTTON,
4941 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4942 { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
4943 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4944 { BS_3STATE, DLGC_BUTTON,
4945 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4946 { BS_AUTO3STATE, DLGC_BUTTON,
4947 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4948 { BS_GROUPBOX, DLGC_STATIC,
4949 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4950 { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
4951 WmSetFocusButtonSeq, WmKillFocusButtonSeq },
4952 { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
4953 WmSetFocusStaticSeq, WmKillFocusStaticSeq },
4954 { BS_OWNERDRAW, DLGC_BUTTON,
4955 WmSetFocusButtonSeq, WmKillFocusButtonSeq }
4956 };
4957 unsigned int i;
4958 HWND hwnd;
4959 DWORD dlg_code;
4960 HFONT zfont;
4961
4962 subclass_button();
4963
4964 for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
4965 {
4966 hwnd = CreateWindowExA(0, "my_button_class", "test", button[i].style | WS_POPUP,
4967 0, 0, 50, 14, 0, 0, 0, NULL);
4968 ok(hwnd != 0, "Failed to create button window\n");
4969
4970 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
4971 ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
4972
4973 ShowWindow(hwnd, SW_SHOW);
4974 UpdateWindow(hwnd);
4975 SetFocus(0);
4976 flush_sequence();
4977
4978 trace("button style %08x\n", button[i].style);
4979 SetFocus(hwnd);
4980 ok_sequence(button[i].setfocus, "SetFocus(hwnd) on a button", FALSE);
4981
4982 SetFocus(0);
4983 ok_sequence(button[i].killfocus, "SetFocus(0) on a button", FALSE);
4984
4985 DestroyWindow(hwnd);
4986 }
4987
4988 hwnd = CreateWindowExA(0, "my_button_class", "test", BS_PUSHBUTTON | WS_POPUP | WS_VISIBLE,
4989 0, 0, 50, 14, 0, 0, 0, NULL);
4990 ok(hwnd != 0, "Failed to create button window\n");
4991
4992 SetFocus(0);
4993 flush_events();
4994 flush_sequence();
4995
4996 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
4997 ok_sequence(WmLButtonDownSeq, "WM_LBUTTONDOWN on a button", FALSE);
4998
4999 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
5000 ok_sequence(WmLButtonUpSeq, "WM_LBUTTONUP on a button", FALSE);
5001
5002 flush_sequence();
5003 zfont = (HFONT)GetStockObject(SYSTEM_FONT);
5004 SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
5005 UpdateWindow(hwnd);
5006 ok_sequence(WmSetFontButtonSeq, "WM_SETFONT on a button", FALSE);
5007
5008 DestroyWindow(hwnd);
5009 }
5010
5011 /****************** static message test *************************/
5012 static const struct message WmSetFontStaticSeq[] =
5013 {
5014 { WM_SETFONT, sent },
5015 { WM_PAINT, sent|defwinproc },
5016 { WM_ERASEBKGND, sent|defwinproc|optional },
5017 { WM_CTLCOLORSTATIC, sent|defwinproc },
5018 { 0 }
5019 };
5020
5021 static WNDPROC old_static_proc;
5022
5023 static LRESULT CALLBACK static_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5024 {
5025 static long defwndproc_counter = 0;
5026 LRESULT ret;
5027 struct message msg;
5028
5029 trace("static: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
5030
5031 /* explicitly ignore WM_GETICON message */
5032 if (message == WM_GETICON) return 0;
5033
5034 msg.message = message;
5035 msg.flags = sent|wparam|lparam;
5036 if (defwndproc_counter) msg.flags |= defwinproc;
5037 msg.wParam = wParam;
5038 msg.lParam = lParam;
5039 add_message(&msg);
5040
5041 defwndproc_counter++;
5042 ret = CallWindowProcA(old_static_proc, hwnd, message, wParam, lParam);
5043 defwndproc_counter--;
5044
5045 return ret;
5046 }
5047
5048 static void subclass_static(void)
5049 {
5050 WNDCLASSA cls;
5051
5052 if (!GetClassInfoA(0, "static", &cls)) assert(0);
5053
5054 old_static_proc = cls.lpfnWndProc;
5055
5056 cls.hInstance = GetModuleHandle(0);
5057 cls.lpfnWndProc = static_hook_proc;
5058 cls.lpszClassName = "my_static_class";
5059 UnregisterClass(cls.lpszClassName, cls.hInstance);
5060 if (!RegisterClassA(&cls)) assert(0);
5061 }
5062
5063 static void test_static_messages(void)
5064 {
5065 /* FIXME: make as comprehensive as the button message test */
5066 static const struct
5067 {
5068 DWORD style;
5069 DWORD dlg_code;
5070 const struct message *setfont;
5071 } static_ctrl[] = {
5072 { SS_LEFT, DLGC_STATIC,
5073 WmSetFontStaticSeq }
5074 };
5075 unsigned int i;
5076 HWND hwnd;
5077 DWORD dlg_code;
5078
5079 subclass_static();
5080
5081 for (i = 0; i < sizeof(static_ctrl)/sizeof(static_ctrl[0]); i++)
5082 {
5083 hwnd = CreateWindowExA(0, "my_static_class", "test", static_ctrl[i].style | WS_POPUP,
5084 0, 0, 50, 14, 0, 0, 0, NULL);
5085 ok(hwnd != 0, "Failed to create static window\n");
5086
5087 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
5088 ok(dlg_code == static_ctrl[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
5089
5090 ShowWindow(hwnd, SW_SHOW);
5091 UpdateWindow(hwnd);
5092 SetFocus(0);
5093 flush_sequence();
5094
5095 trace("static style %08x\n", static_ctrl[i].style);
5096 SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
5097 ok_sequence(static_ctrl[i].setfont, "WM_SETFONT on a static", FALSE);
5098
5099 DestroyWindow(hwnd);
5100 }
5101 }
5102
5103 /****************** ComboBox message test *************************/
5104 #define ID_COMBOBOX 0x000f
5105
5106 static const struct message WmKeyDownComboSeq[] =
5107 {
5108 { WM_KEYDOWN, sent|wparam|lparam, VK_DOWN, 0 },
5109 { WM_COMMAND, sent|wparam|defwinproc, MAKEWPARAM(1000, LBN_SELCHANGE) },
5110 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELENDOK) },
5111 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_COMBOBOX, CBN_SELCHANGE) },
5112 { WM_CTLCOLOREDIT, sent|parent },
5113 { WM_KEYUP, sent|wparam|lparam, VK_DOWN, 0 },
5114 { 0 }
5115 };
5116
5117 static WNDPROC old_combobox_proc;
5118
5119 static LRESULT CALLBACK combobox_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5120 {
5121 static long defwndproc_counter = 0;
5122 LRESULT ret;
5123 struct message msg;
5124
5125 /* do not log painting messages */
5126 if (message != WM_PAINT &&
5127 message != WM_NCPAINT &&
5128 message != WM_SYNCPAINT &&
5129 message != WM_ERASEBKGND &&
5130 message != WM_NCHITTEST &&
5131 message != WM_GETTEXT &&
5132 message != WM_GETICON &&
5133 message != WM_DEVICECHANGE)
5134 {
5135 trace("combo: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
5136
5137 msg.message = message;
5138 msg.flags = sent|wparam|lparam;
5139 if (defwndproc_counter) msg.flags |= defwinproc;
5140 msg.wParam = wParam;
5141 msg.lParam = lParam;
5142 add_message(&msg);
5143 }
5144
5145 defwndproc_counter++;
5146 ret = CallWindowProcA(old_combobox_proc, hwnd, message, wParam, lParam);
5147 defwndproc_counter--;
5148
5149 return ret;
5150 }
5151
5152 static void subclass_combobox(void)
5153 {
5154 WNDCLASSA cls;
5155
5156 if (!GetClassInfoA(0, "ComboBox", &cls)) assert(0);
5157
5158 old_combobox_proc = cls.lpfnWndProc;
5159
5160 cls.hInstance = GetModuleHandle(0);
5161 cls.lpfnWndProc = combobox_hook_proc;
5162 cls.lpszClassName = "my_combobox_class";
5163 UnregisterClass(cls.lpszClassName, cls.hInstance);
5164 if (!RegisterClassA(&cls)) assert(0);
5165 }
5166
5167 static void test_combobox_messages(void)
5168 {
5169 HWND parent, combo;
5170 LRESULT ret;
5171
5172 subclass_combobox();
5173
5174 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
5175 100, 100, 200, 200, 0, 0, 0, NULL);
5176 ok(parent != 0, "Failed to create parent window\n");
5177 flush_sequence();
5178
5179 combo = CreateWindowEx(0, "my_combobox_class", "test", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | CBS_HASSTRINGS,
5180 0, 0, 100, 150, parent, (HMENU)ID_COMBOBOX, 0, NULL);
5181 ok(combo != 0, "Failed to create combobox window\n");
5182
5183 UpdateWindow(combo);
5184
5185 ret = SendMessage(combo, WM_GETDLGCODE, 0, 0);
5186 ok(ret == (DLGC_WANTCHARS | DLGC_WANTARROWS), "wrong dlg_code %08lx\n", ret);
5187
5188 ret = SendMessage(combo, CB_ADDSTRING, 0, (LPARAM)"item 0");
5189 ok(ret == 0, "expected 0, got %ld\n", ret);
5190 ret = SendMessage(combo, CB_ADDSTRING, 0, (LPARAM)"item 1");
5191 ok(ret == 1, "expected 1, got %ld\n", ret);
5192 ret = SendMessage(combo, CB_ADDSTRING, 0, (LPARAM)"item 2");
5193 ok(ret == 2, "expected 2, got %ld\n", ret);
5194
5195 SendMessage(combo, CB_SETCURSEL, 0, 0);
5196 SetFocus(combo);
5197 flush_sequence();
5198
5199 log_all_parent_messages++;
5200 SendMessage(combo, WM_KEYDOWN, VK_DOWN, 0);
5201 SendMessage(combo, WM_KEYUP, VK_DOWN, 0);
5202 log_all_parent_messages--;
5203 ok_sequence(WmKeyDownComboSeq, "WM_KEYDOWN/VK_DOWN on a ComboBox", FALSE);
5204
5205 DestroyWindow(combo);
5206 DestroyWindow(parent);
5207 }
5208
5209 /****************** WM_IME_KEYDOWN message test *******************/
5210
5211 static const struct message WmImeKeydownMsgSeq_0[] =
5212 {
5213 { WM_IME_KEYDOWN, wparam, VK_RETURN },
5214 { WM_CHAR, wparam, 'A' },
5215 { 0 }
5216 };
5217
5218 static const struct message WmImeKeydownMsgSeq_1[] =
5219 {
5220 { WM_KEYDOWN, optional|wparam, VK_RETURN },
5221 { WM_CHAR, optional|wparam, VK_RETURN },
5222 { 0 }
5223 };
5224
5225 static LRESULT WINAPI wmime_keydown_procA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
5226 {
5227 struct message msg;
5228
5229 trace("wmime_keydown_procA: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
5230
5231 msg.message = message;
5232 msg.flags = wparam|lparam;
5233 msg.wParam = wParam;
5234 msg.lParam = lParam;
5235 add_message(&msg);
5236
5237 return DefWindowProcA(hwnd, message, wParam, lParam);
5238 }
5239
5240 static void register_wmime_keydown_class(void)
5241 {
5242 WNDCLASSA cls;
5243
5244 ZeroMemory(&cls, sizeof(WNDCLASSA));
5245 cls.lpfnWndProc = wmime_keydown_procA;
5246 cls.hInstance = GetModuleHandleA(0);
5247 cls.lpszClassName = "wmime_keydown_class";
5248 if (!RegisterClassA(&cls)) assert(0);
5249 }
5250
5251 void test_wmime_keydown_message(void)
5252 {
5253 HWND hwnd;
5254 MSG msg;
5255
5256 trace("Message sequences by WM_IME_KEYDOWN\n");
5257
5258 register_wmime_keydown_class();
5259 hwnd = CreateWindowExA(0, "wmime_keydown_class", NULL, WS_OVERLAPPEDWINDOW,
5260 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
5261 NULL, NULL, 0);
5262 flush_events();
5263 flush_sequence();
5264
5265 SendMessage(hwnd, WM_IME_KEYDOWN, VK_RETURN, 0x1c0001);
5266 SendMessage(hwnd, WM_CHAR, 'A', 1);
5267 ok_sequence(WmImeKeydownMsgSeq_0, "WM_IME_KEYDOWN 0", FALSE);
5268
5269 while ( PeekMessage(&msg, 0, 0, 0, PM_REMOVE) )
5270 {
5271 TranslateMessage(&msg);
5272 DispatchMessage(&msg);
5273 }
5274 ok_sequence(WmImeKeydownMsgSeq_1, "WM_IME_KEYDOWN 1", FALSE);
5275
5276 DestroyWindow(hwnd);
5277 }
5278
5279 /************* painting message test ********************/
5280
5281 void dump_region(HRGN hrgn)
5282 {
5283 DWORD i, size;
5284 RGNDATA *data = NULL;
5285 RECT *rect;
5286
5287 if (!hrgn)
5288 {
5289 printf( "null region\n" );
5290 return;
5291 }
5292 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
5293 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
5294 GetRegionData( hrgn, size, data );
5295 printf("%d rects:", data->rdh.nCount );
5296 for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
5297 printf( " (%d,%d)-(%d,%d)", rect->left, rect->top, rect->right, rect->bottom );
5298 printf("\n");
5299 HeapFree( GetProcessHeap(), 0, data );
5300 }
5301
5302 static void check_update_rgn( HWND hwnd, HRGN hrgn )
5303 {
5304 INT ret;
5305 RECT r1, r2;
5306 HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
5307 HRGN update = CreateRectRgn( 0, 0, 0, 0 );
5308
5309 ret = GetUpdateRgn( hwnd, update, FALSE );
5310 ok( ret != ERROR, "GetUpdateRgn failed\n" );
5311 if (ret == NULLREGION)
5312 {
5313 ok( !hrgn, "Update region shouldn't be empty\n" );
5314 }
5315 else
5316 {
5317 if (CombineRgn( tmp, hrgn, update, RGN_XOR ) != NULLREGION)
5318 {
5319 ok( 0, "Regions are different\n" );
5320 if (winetest_debug > 0)
5321 {
5322 printf( "Update region: " );
5323 dump_region( update );
5324 printf( "Wanted region: " );
5325 dump_region( hrgn );
5326 }
5327 }
5328 }
5329 GetRgnBox( update, &r1 );
5330 GetUpdateRect( hwnd, &r2, FALSE );
5331 ok( r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom,
5332 "Rectangles are different: %d,%d-%d,%d / %d,%d-%d,%d\n",
5333 r1.left, r1.top, r1.right, r1.bottom, r2.left, r2.top, r2.right, r2.bottom );
5334
5335 DeleteObject( tmp );
5336 DeleteObject( update );
5337 }
5338
5339 static const struct message WmInvalidateRgn[] = {
5340 { WM_NCPAINT, sent },
5341 { WM_GETTEXT, sent|defwinproc|optional },
5342 { 0 }
5343 };
5344
5345 static const struct message WmGetUpdateRect[] = {
5346 { WM_NCPAINT, sent },
5347 { WM_GETTEXT, sent|defwinproc|optional },
5348 { WM_PAINT, sent },
5349 { 0 }
5350 };
5351
5352 static const struct message WmInvalidateFull[] = {
5353 { WM_NCPAINT, sent|wparam, 1 },
5354 { WM_GETTEXT, sent|defwinproc|optional },
5355 { 0 }
5356 };
5357
5358 static const struct message WmInvalidateErase[] = {
5359 { WM_NCPAINT, sent|wparam, 1 },
5360 { WM_GETTEXT, sent|defwinproc|optional },
5361 { WM_ERASEBKGND, sent },
5362 { 0 }
5363 };
5364
5365 static const struct message WmInvalidatePaint[] = {
5366 { WM_PAINT, sent },
5367 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
5368 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5369 { 0 }
5370 };
5371
5372 static const struct message WmInvalidateErasePaint[] = {
5373 { WM_PAINT, sent },
5374 { WM_NCPAINT, sent|wparam|beginpaint, 1 },
5375 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5376 { WM_ERASEBKGND, sent|beginpaint },
5377 { 0 }
5378 };
5379
5380 static const struct message WmInvalidateErasePaint2[] = {
5381 { WM_PAINT, sent },
5382 { WM_NCPAINT, sent|beginpaint },
5383 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5384 { WM_ERASEBKGND, sent|beginpaint },
5385 { 0 }
5386 };
5387
5388 static const struct message WmErase[] = {
5389 { WM_ERASEBKGND, sent },
5390 { 0 }
5391 };
5392
5393 static const struct message WmPaint[] = {
5394 { WM_PAINT, sent },
5395 { 0 }
5396 };
5397
5398 static const struct message WmParentOnlyPaint[] = {
5399 { WM_PAINT, sent|parent },
5400 { 0 }
5401 };
5402
5403 static const struct message WmInvalidateParent[] = {
5404 { WM_NCPAINT, sent|parent },
5405 { WM_GETTEXT, sent|defwinproc|parent|optional },
5406 { WM_ERASEBKGND, sent|parent },
5407 { 0 }
5408 };
5409
5410 static const struct message WmInvalidateParentChild[] = {
5411 { WM_NCPAINT, sent|parent },
5412 { WM_GETTEXT, sent|defwinproc|parent|optional },
5413 { WM_ERASEBKGND, sent|parent },
5414 { WM_NCPAINT, sent },
5415 { WM_GETTEXT, sent|defwinproc|optional },
5416 { WM_ERASEBKGND, sent },
5417 { 0 }
5418 };
5419
5420 static const struct message WmInvalidateParentChild2[] = {
5421 { WM_ERASEBKGND, sent|parent },
5422 { WM_NCPAINT, sent },
5423 { WM_GETTEXT, sent|defwinproc|optional },
5424 { WM_ERASEBKGND, sent },
5425 { 0 }
5426 };
5427
5428 static const struct message WmParentPaint[] = {
5429 { WM_PAINT, sent|parent },
5430 { WM_PAINT, sent },
5431 { 0 }
5432 };
5433
5434 static const struct message WmParentPaintNc[] = {
5435 { WM_PAINT, sent|parent },
5436 { WM_PAINT, sent },
5437 { WM_NCPAINT, sent|beginpaint },
5438 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5439 { WM_ERASEBKGND, sent|beginpaint },
5440 { 0 }
5441 };
5442
5443 static const struct message WmChildPaintNc[] = {
5444 { WM_PAINT, sent },
5445 { WM_NCPAINT, sent|beginpaint },
5446 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5447 { WM_ERASEBKGND, sent|beginpaint },
5448 { 0 }
5449 };
5450
5451 static const struct message WmParentErasePaint[] = {
5452 { WM_PAINT, sent|parent },
5453 { WM_NCPAINT, sent|parent|beginpaint },
5454 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
5455 { WM_ERASEBKGND, sent|parent|beginpaint },
5456 { WM_PAINT, sent },
5457 { WM_NCPAINT, sent|beginpaint },
5458 { WM_GETTEXT, sent|beginpaint|defwinproc|optional },
5459 { WM_ERASEBKGND, sent|beginpaint },
5460 { 0 }
5461 };
5462
5463 static const struct message WmParentOnlyNcPaint[] = {
5464 { WM_PAINT, sent|parent },
5465 { WM_NCPAINT, sent|parent|beginpaint },
5466 { WM_GETTEXT, sent|parent|beginpaint|defwinproc|optional },
5467 { 0 }
5468 };
5469
5470 static const struct message WmSetParentStyle[] = {
5471 { WM_STYLECHANGING, sent|parent },
5472 { WM_STYLECHANGED, sent|parent },
5473 { 0 }
5474 };
5475
5476 static void test_paint_messages(void)
5477 {
5478 BOOL ret;
5479 RECT rect;
5480 POINT pt;
5481 MSG msg;
5482 HWND hparent, hchild;
5483 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
5484 HRGN hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
5485 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
5486 100, 100, 200, 200, 0, 0, 0, NULL);
5487 ok (hwnd != 0, "Failed to create overlapped window\n");
5488
5489 ShowWindow( hwnd, SW_SHOW );
5490 UpdateWindow( hwnd );
5491 flush_events();
5492 flush_sequence();
5493
5494 check_update_rgn( hwnd, 0 );
5495 SetRectRgn( hrgn, 10, 10, 20, 20 );
5496 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5497 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5498 check_update_rgn( hwnd, hrgn );
5499 SetRectRgn( hrgn2, 20, 20, 30, 30 );
5500 ret = RedrawWindow( hwnd, NULL, hrgn2, RDW_INVALIDATE );
5501 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5502 CombineRgn( hrgn, hrgn, hrgn2, RGN_OR );
5503 check_update_rgn( hwnd, hrgn );
5504 /* validate everything */
5505 ret = RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
5506 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5507 check_update_rgn( hwnd, 0 );
5508
5509 /* test empty region */
5510 SetRectRgn( hrgn, 10, 10, 10, 15 );
5511 ret = RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5512 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5513 check_update_rgn( hwnd, 0 );
5514 /* test empty rect */
5515 SetRect( &rect, 10, 10, 10, 15 );
5516 ret = RedrawWindow( hwnd, &rect, NULL, RDW_INVALIDATE );
5517 ok(ret, "RedrawWindow returned %d instead of TRUE\n", ret);
5518 check_update_rgn( hwnd, 0 );
5519
5520 /* flush pending messages */
5521 flush_events();
5522 flush_sequence();
5523
5524 GetClientRect( hwnd, &rect );
5525 SetRectRgn( hrgn, 0, 0, rect.right - rect.left, rect.bottom - rect.top );
5526 /* MSDN: if hwnd parameter is NULL, InvalidateRect invalidates and redraws
5527 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
5528 */
5529 trace("testing InvalidateRect(0, NULL, FALSE)\n");
5530 SetRectEmpty( &rect );
5531 ok(InvalidateRect(0, &rect, FALSE), "InvalidateRect(0, &rc, FALSE) should fail\n");
5532 check_update_rgn( hwnd, hrgn );
5533 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5534 flush_events();
5535 ok_sequence( WmPaint, "Paint", FALSE );
5536 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
5537 check_update_rgn( hwnd, 0 );
5538
5539 /* MSDN: if hwnd parameter is NULL, ValidateRect invalidates and redraws
5540 * all windows and sends WM_ERASEBKGND and WM_NCPAINT.
5541 */
5542 trace("testing ValidateRect(0, NULL)\n");
5543 SetRectEmpty( &rect );
5544 ok(ValidateRect(0, &rect), "ValidateRect(0, &rc) should not fail\n");
5545 check_update_rgn( hwnd, hrgn );
5546 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5547 flush_events();
5548 ok_sequence( WmPaint, "Paint", FALSE );
5549 RedrawWindow( hwnd, NULL, NULL, RDW_VALIDATE );
5550 check_update_rgn( hwnd, 0 );
5551
5552 trace("testing InvalidateRgn(0, NULL, FALSE)\n");
5553 SetLastError(0xdeadbeef);
5554 ok(!InvalidateRgn(0, NULL, FALSE), "InvalidateRgn(0, NULL, FALSE) should fail\n");
5555 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || GetLastError() == 0xdeadbeef,
5556 "wrong error code %d\n", GetLastError());
5557 check_update_rgn( hwnd, 0 );
5558 flush_events();
5559 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
5560
5561 trace("testing ValidateRgn(0, NULL)\n");
5562 SetLastError(0xdeadbeef);
5563 ok(!ValidateRgn(0, NULL), "ValidateRgn(0, NULL) should fail\n");
5564 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error code %d\n", GetLastError());
5565 check_update_rgn( hwnd, 0 );
5566 flush_events();
5567 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
5568
5569 /* now with frame */
5570 SetRectRgn( hrgn, -5, -5, 20, 20 );
5571
5572 /* flush pending messages */
5573 flush_events();
5574 flush_sequence();
5575 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5576 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
5577
5578 SetRectRgn( hrgn, 0, 0, 20, 20 ); /* GetUpdateRgn clips to client area */
5579 check_update_rgn( hwnd, hrgn );
5580
5581 flush_sequence();
5582 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
5583 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
5584
5585 flush_sequence();
5586 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW );
5587 ok_sequence( WmInvalidateFull, "InvalidateFull", FALSE );
5588
5589 GetClientRect( hwnd, &rect );
5590 SetRectRgn( hrgn, rect.left, rect.top, rect.right, rect.bottom );
5591 check_update_rgn( hwnd, hrgn );
5592
5593 flush_sequence();
5594 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW );
5595 ok_sequence( WmInvalidateErase, "InvalidateErase", FALSE );
5596
5597 flush_sequence();
5598 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASENOW | RDW_UPDATENOW );
5599 ok_sequence( WmInvalidatePaint, "InvalidatePaint", FALSE );
5600 check_update_rgn( hwnd, 0 );
5601
5602 flush_sequence();
5603 RedrawWindow( hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_UPDATENOW );
5604 ok_sequence( WmInvalidateErasePaint, "InvalidateErasePaint", FALSE );
5605 check_update_rgn( hwnd, 0 );
5606
5607 flush_sequence();
5608 SetRectRgn( hrgn, 0, 0, 100, 100 );
5609 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE );
5610 SetRectRgn( hrgn, 0, 0, 50, 100 );
5611 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE );
5612 SetRectRgn( hrgn, 50, 0, 100, 100 );
5613 check_update_rgn( hwnd, hrgn );
5614 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
5615 ok_sequence( WmEmptySeq, "EmptySeq", FALSE ); /* must not generate messages, everything is valid */
5616 check_update_rgn( hwnd, 0 );
5617
5618 flush_sequence();
5619 SetRectRgn( hrgn, 0, 0, 100, 100 );
5620 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
5621 SetRectRgn( hrgn, 0, 0, 100, 50 );
5622 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_ERASENOW );
5623 ok_sequence( WmErase, "Erase", FALSE );
5624 SetRectRgn( hrgn, 0, 50, 100, 100 );
5625 check_update_rgn( hwnd, hrgn );
5626
5627 flush_sequence();
5628 SetRectRgn( hrgn, 0, 0, 100, 100 );
5629 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_ERASE );
5630 SetRectRgn( hrgn, 0, 0, 50, 50 );
5631 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOERASE | RDW_UPDATENOW );
5632 ok_sequence( WmPaint, "Paint", FALSE );
5633
5634 flush_sequence();
5635 SetRectRgn( hrgn, -4, -4, -2, -2 );
5636 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5637 SetRectRgn( hrgn, -200, -200, -198, -198 );
5638 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME | RDW_ERASENOW );
5639 ok_sequence( WmEmptySeq, "EmptySeq", FALSE );
5640
5641 flush_sequence();
5642 SetRectRgn( hrgn, -4, -4, -2, -2 );
5643 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5644 SetRectRgn( hrgn, -4, -4, -3, -3 );
5645 RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOFRAME );
5646 SetRectRgn( hrgn, 0, 0, 1, 1 );
5647 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_UPDATENOW );
5648 ok_sequence( WmPaint, "Paint", FALSE );
5649
5650 flush_sequence();
5651 SetRectRgn( hrgn, -4, -4, -1, -1 );
5652 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5653 RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW );
5654 /* make sure no WM_PAINT was generated */
5655 flush_events();
5656 ok_sequence( WmInvalidateRgn, "InvalidateRgn", FALSE );
5657
5658 flush_sequence();
5659 SetRectRgn( hrgn, -4, -4, -1, -1 );
5660 RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | RDW_FRAME );
5661 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
5662 {
5663 if (msg.hwnd == hwnd && msg.message == WM_PAINT)
5664 {
5665 /* GetUpdateRgn must return empty region since only nonclient area is invalidated */
5666 INT ret = GetUpdateRgn( hwnd, hrgn, FALSE );
5667 ok( ret == NULLREGION, "Invalid GetUpdateRgn result %d\n", ret );
5668 ret = GetUpdateRect( hwnd, &rect, FALSE );
5669 ok( ret, "Invalid GetUpdateRect result %d\n", ret );
5670 /* this will send WM_NCPAINT and validate the non client area */
5671 ret = GetUpdateRect( hwnd, &rect, TRUE );
5672 ok( !ret, "Invalid GetUpdateRect result %d\n", ret );
5673 }
5674 DispatchMessage( &msg );
5675 }
5676 ok_sequence( WmGetUpdateRect, "GetUpdateRect", FALSE );
5677
5678 DestroyWindow( hwnd );
5679
5680 /* now test with a child window */
5681
5682 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW,
5683 100, 100, 200, 200, 0, 0, 0, NULL);
5684 ok (hparent != 0, "Failed to create parent window\n");
5685
5686 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE | WS_BORDER,
5687 10, 10, 100, 100, hparent, 0, 0, NULL);
5688 ok (hchild != 0, "Failed to create child window\n");
5689
5690 ShowWindow( hparent, SW_SHOW );
5691 UpdateWindow( hparent );
5692 UpdateWindow( hchild );
5693 flush_events();
5694 flush_sequence();
5695 log_all_parent_messages++;
5696
5697 SetRect( &rect, 0, 0, 50, 50 );
5698 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5699 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
5700 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild", FALSE );
5701
5702 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5703 pt.x = pt.y = 0;
5704 MapWindowPoints( hchild, hparent, &pt, 1 );
5705 SetRectRgn( hrgn, 0, 0, 50 - pt.x, 50 - pt.y );
5706 check_update_rgn( hchild, hrgn );
5707 SetRectRgn( hrgn, 0, 0, 50, 50 );
5708 check_update_rgn( hparent, hrgn );
5709 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5710 ok_sequence( WmInvalidateParent, "InvalidateParent", FALSE );
5711 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
5712 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
5713
5714 flush_events();
5715 ok_sequence( WmParentPaintNc, "WmParentPaintNc", FALSE );
5716
5717 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5718 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5719 ok_sequence( WmInvalidateParent, "InvalidateParent2", FALSE );
5720 RedrawWindow( hchild, NULL, 0, RDW_ERASENOW );
5721 ok_sequence( WmEmptySeq, "EraseNow child", FALSE );
5722
5723 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
5724 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW | RDW_ALLCHILDREN );
5725 ok_sequence( WmInvalidateParentChild2, "InvalidateParentChild2", FALSE );
5726
5727 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
5728 flush_sequence();
5729 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5730 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5731 ok_sequence( WmInvalidateParentChild, "InvalidateParentChild3", FALSE );
5732
5733 /* flush all paint messages */
5734 flush_events();
5735 flush_sequence();
5736
5737 /* RDW_UPDATENOW on child with WS_CLIPCHILDREN doesn't change corresponding parent area */
5738 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN );
5739 SetRectRgn( hrgn, 0, 0, 50, 50 );
5740 check_update_rgn( hparent, hrgn );
5741 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5742 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5743 SetRectRgn( hrgn, 0, 0, 50, 50 );
5744 check_update_rgn( hparent, hrgn );
5745
5746 /* flush all paint messages */
5747 flush_events();
5748 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
5749 flush_sequence();
5750
5751 /* RDW_UPDATENOW on child without WS_CLIPCHILDREN will validate corresponding parent area */
5752 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5753 SetRectRgn( hrgn, 0, 0, 50, 50 );
5754 check_update_rgn( hparent, hrgn );
5755 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5756 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5757 SetRectRgn( hrgn2, 10, 10, 50, 50 );
5758 CombineRgn( hrgn, hrgn, hrgn2, RGN_DIFF );
5759 check_update_rgn( hparent, hrgn );
5760 /* flush all paint messages */
5761 flush_events();
5762 flush_sequence();
5763
5764 /* same as above but parent gets completely validated */
5765 SetRect( &rect, 20, 20, 30, 30 );
5766 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5767 SetRectRgn( hrgn, 20, 20, 30, 30 );
5768 check_update_rgn( hparent, hrgn );
5769 RedrawWindow( hchild, NULL, 0, RDW_UPDATENOW );
5770 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5771 check_update_rgn( hparent, 0 ); /* no update region */
5772 flush_events();
5773 ok_sequence( WmEmptySeq, "WmEmpty", FALSE ); /* and no paint messages */
5774
5775 /* make sure RDW_VALIDATE on child doesn't have the same effect */
5776 flush_sequence();
5777 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5778 SetRectRgn( hrgn, 20, 20, 30, 30 );
5779 check_update_rgn( hparent, hrgn );
5780 RedrawWindow( hchild, NULL, 0, RDW_VALIDATE | RDW_NOERASE );
5781 SetRectRgn( hrgn, 20, 20, 30, 30 );
5782 check_update_rgn( hparent, hrgn );
5783
5784 /* same as above but normal WM_PAINT doesn't validate parent */
5785 flush_sequence();
5786 SetRect( &rect, 20, 20, 30, 30 );
5787 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5788 SetRectRgn( hrgn, 20, 20, 30, 30 );
5789 check_update_rgn( hparent, hrgn );
5790 /* no WM_PAINT in child while parent still pending */
5791 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5792 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
5793 while (PeekMessage( &msg, hparent, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5794 ok_sequence( WmParentErasePaint, "WmParentErasePaint", FALSE );
5795
5796 flush_sequence();
5797 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5798 /* no WM_PAINT in child while parent still pending */
5799 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5800 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
5801 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOCHILDREN );
5802 /* now that parent is valid child should get WM_PAINT */
5803 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5804 ok_sequence( WmInvalidateErasePaint2, "WmInvalidateErasePaint2", FALSE );
5805 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5806 ok_sequence( WmEmptySeq, "No other message", FALSE );
5807
5808 /* same thing with WS_CLIPCHILDREN in parent */
5809 flush_sequence();
5810 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) | WS_CLIPCHILDREN );
5811 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
5812 /* changing style invalidates non client area, but we need to invalidate something else to see it */
5813 RedrawWindow( hparent, &rect, 0, RDW_UPDATENOW );
5814 ok_sequence( WmEmptySeq, "No message", FALSE );
5815 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_UPDATENOW );
5816 ok_sequence( WmParentOnlyNcPaint, "WmParentOnlyNcPaint", FALSE );
5817
5818 flush_sequence();
5819 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN );
5820 SetRectRgn( hrgn, 20, 20, 30, 30 );
5821 check_update_rgn( hparent, hrgn );
5822 /* no WM_PAINT in child while parent still pending */
5823 while (PeekMessage( &msg, hchild, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5824 ok_sequence( WmEmptySeq, "No WM_PAINT", FALSE );
5825 /* WM_PAINT in parent first */
5826 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
5827 ok_sequence( WmParentPaintNc, "WmParentPaintNc2", FALSE );
5828
5829 /* no RDW_ERASE in parent still causes RDW_ERASE and RDW_FRAME in child */
5830 flush_sequence();
5831 SetRect( &rect, 0, 0, 30, 30 );
5832 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN );
5833 SetRectRgn( hrgn, 0, 0, 30, 30 );
5834 check_update_rgn( hparent, hrgn );
5835 flush_events();
5836 ok_sequence( WmParentPaintNc, "WmParentPaintNc3", FALSE );
5837
5838 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
5839 flush_sequence();
5840 SetRect( &rect, -10, 0, 30, 30 );
5841 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
5842 SetRect( &rect, 0, 0, 20, 20 );
5843 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
5844 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
5845 ok_sequence( WmChildPaintNc, "WmChildPaintNc", FALSE );
5846
5847 /* validate doesn't cause RDW_NOERASE or RDW_NOFRAME in child */
5848 flush_sequence();
5849 SetRect( &rect, -10, 0, 30, 30 );
5850 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE );
5851 SetRect( &rect, 0, 0, 100, 100 );
5852 RedrawWindow( hparent, &rect, 0, RDW_VALIDATE | RDW_ALLCHILDREN );
5853 RedrawWindow( hparent, NULL, 0, RDW_UPDATENOW );
5854 ok_sequence( WmEmptySeq, "WmChildPaintNc2", FALSE );
5855 RedrawWindow( hparent, NULL, 0, RDW_ERASENOW );
5856 ok_sequence( WmEmptySeq, "WmChildPaintNc3", FALSE );
5857
5858 /* test RDW_INTERNALPAINT behavior */
5859
5860 flush_sequence();
5861 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_NOCHILDREN );
5862 flush_events();
5863 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
5864
5865 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT | RDW_ALLCHILDREN );
5866 flush_events();
5867 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
5868
5869 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
5870 flush_events();
5871 ok_sequence( WmParentOnlyPaint, "WmParentOnlyPaint", FALSE );
5872
5873 assert( GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN );
5874 UpdateWindow( hparent );
5875 flush_events();
5876 flush_sequence();
5877 trace("testing SWP_FRAMECHANGED on parent with WS_CLIPCHILDREN\n");
5878 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5879 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
5880 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5881 flush_events();
5882 ok_sequence(WmSWP_FrameChanged_clip, "SetWindowPos:FrameChanged_clip", FALSE );
5883
5884 UpdateWindow( hparent );
5885 flush_events();
5886 flush_sequence();
5887 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent with WS_CLIPCHILDREN\n");
5888 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5889 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
5890 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5891 flush_events();
5892 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
5893
5894 SetWindowLong( hparent, GWL_STYLE, GetWindowLong(hparent,GWL_STYLE) & ~WS_CLIPCHILDREN );
5895 ok_sequence( WmSetParentStyle, "WmSetParentStyle", FALSE );
5896 RedrawWindow( hparent, NULL, 0, RDW_INTERNALPAINT );
5897 flush_events();
5898 ok_sequence( WmParentPaint, "WmParentPaint", FALSE );
5899
5900 assert( !(GetWindowLong(hparent, GWL_STYLE) & WS_CLIPCHILDREN) );
5901 UpdateWindow( hparent );
5902 flush_events();
5903 flush_sequence();
5904 trace("testing SWP_FRAMECHANGED on parent without WS_CLIPCHILDREN\n");
5905 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5906 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
5907 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5908 flush_events();
5909 ok_sequence(WmSWP_FrameChanged_noclip, "SetWindowPos:FrameChanged_noclip", FALSE );
5910
5911 UpdateWindow( hparent );
5912 flush_events();
5913 flush_sequence();
5914 trace("testing SWP_FRAMECHANGED|SWP_DEFERERASE on parent without WS_CLIPCHILDREN\n");
5915 RedrawWindow( hchild, NULL, 0, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME );
5916 SetWindowPos( hparent, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_DEFERERASE |
5917 SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
5918 flush_events();
5919 ok_sequence(WmSWP_FrameChangedDeferErase, "SetWindowPos:FrameChangedDeferErase", FALSE );
5920
5921 ok(GetWindowLong( hparent, GWL_STYLE ) & WS_VISIBLE, "parent should be visible\n");
5922 ok(GetWindowLong( hchild, GWL_STYLE ) & WS_VISIBLE, "child should be visible\n");
5923
5924 UpdateWindow( hparent );
5925 flush_events();
5926 flush_sequence();
5927 trace("testing SetWindowPos(-10000, -10000) on child\n");
5928 SetWindowPos( hchild, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
5929 check_update_rgn( hchild, 0 );
5930 flush_events();
5931
5932 #if 0 /* this one doesn't pass under Wine yet */
5933 UpdateWindow( hparent );
5934 flush_events();
5935 flush_sequence();
5936 trace("testing ShowWindow(SW_MINIMIZE) on child\n");
5937 ShowWindow( hchild, SW_MINIMIZE );
5938 check_update_rgn( hchild, 0 );
5939 flush_events();
5940 #endif
5941
5942 UpdateWindow( hparent );
5943 flush_events();
5944 flush_sequence();
5945 trace("testing SetWindowPos(-10000, -10000) on parent\n");
5946 SetWindowPos( hparent, 0, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER );
5947 check_update_rgn( hparent, 0 );
5948 flush_events();
5949
5950 log_all_parent_messages--;
5951 DestroyWindow( hparent );
5952 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
5953
5954 /* tests for moving windows off-screen (needs simple WS_POPUP windows) */
5955
5956 hparent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_POPUP | WS_VISIBLE,
5957 100, 100, 200, 200, 0, 0, 0, NULL);
5958 ok (hparent != 0, "Failed to create parent window\n");
5959
5960 hchild = CreateWindowExA(0, "TestWindowClass", "Test child", WS_CHILD | WS_VISIBLE,
5961 10, 10, 100, 100, hparent, 0, 0, NULL);
5962 ok (hchild != 0, "Failed to create child window\n");
5963
5964 ShowWindow( hparent, SW_SHOW );
5965 UpdateWindow( hparent );
5966 UpdateWindow( hchild );
5967 flush_events();
5968 flush_sequence();
5969
5970 /* moving child outside of parent boundaries changes update region */
5971 SetRect( &rect, 0, 0, 40, 40 );
5972 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
5973 SetRectRgn( hrgn, 0, 0, 40, 40 );
5974 check_update_rgn( hchild, hrgn );
5975 MoveWindow( hchild, -10, 10, 100, 100, FALSE );
5976 SetRectRgn( hrgn, 10, 0, 40, 40 );
5977 check_update_rgn( hchild, hrgn );
5978 MoveWindow( hchild, -10, -10, 100, 100, FALSE );
5979 SetRectRgn( hrgn, 10, 10, 40, 40 );
5980 check_update_rgn( hchild, hrgn );
5981
5982 /* moving parent off-screen does too */
5983 SetRect( &rect, 0, 0, 100, 100 );
5984 RedrawWindow( hparent, &rect, 0, RDW_INVALIDATE | RDW_ERASE | RDW_NOCHILDREN );
5985 SetRectRgn( hrgn, 0, 0, 100, 100 );
5986 check_update_rgn( hparent, hrgn );
5987 SetRectRgn( hrgn, 10, 10, 40, 40 );
5988 check_update_rgn( hchild, hrgn );
5989 MoveWindow( hparent, -20, -20, 200, 200, FALSE );
5990 SetRectRgn( hrgn, 20, 20, 100, 100 );
5991 check_update_rgn( hparent, hrgn );
5992 SetRectRgn( hrgn, 30, 30, 40, 40 );
5993 check_update_rgn( hchild, hrgn );
5994
5995 /* invalidated region is cropped by the parent rects */
5996 SetRect( &rect, 0, 0, 50, 50 );
5997 RedrawWindow( hchild, &rect, 0, RDW_INVALIDATE | RDW_ERASE );
5998 SetRectRgn( hrgn, 30, 30, 50, 50 );
5999 check_update_rgn( hchild, hrgn );
6000
6001 DestroyWindow( hparent );
6002 ok(!IsWindow(hchild), "child must be destroyed with its parent\n");
6003 flush_sequence();
6004
6005 DeleteObject( hrgn );
6006 DeleteObject( hrgn2 );
6007 }
6008
6009 struct wnd_event
6010 {
6011 HWND hwnd;
6012 HANDLE event;
6013 };
6014
6015 static DWORD WINAPI thread_proc(void *param)
6016 {
6017 MSG msg;
6018 struct wnd_event *wnd_event = (struct wnd_event *)param;
6019
6020 wnd_event->hwnd = CreateWindowExA(0, "TestWindowClass", "window caption text", WS_OVERLAPPEDWINDOW,
6021 100, 100, 200, 200, 0, 0, 0, NULL);
6022 ok(wnd_event->hwnd != 0, "Failed to create overlapped window\n");
6023
6024 SetEvent(wnd_event->event);
6025
6026 while (GetMessage(&msg, 0, 0, 0))
6027 {
6028 TranslateMessage(&msg);
6029 DispatchMessage(&msg);
6030 }
6031
6032 ok(IsWindow(wnd_event->hwnd), "window should still exist\n");
6033
6034 return 0;
6035 }
6036
6037 static void test_interthread_messages(void)
6038 {
6039 HANDLE hThread;
6040 DWORD tid;
6041 WNDPROC proc;
6042 MSG msg;
6043 char buf[256];
6044 int len, expected_len;
6045 struct wnd_event wnd_event;
6046 BOOL ret;
6047
6048 wnd_event.event = CreateEventW(NULL, 0, 0, NULL);
6049 if (!wnd_event.event)
6050 {
6051 trace("skipping interthread message test under win9x\n");
6052 return;
6053 }
6054
6055 hThread = CreateThread(NULL, 0, thread_proc, &wnd_event, 0, &tid);
6056 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
6057
6058 ok(WaitForSingleObject(wnd_event.event, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
6059
6060 CloseHandle(wnd_event.event);
6061
6062 SetLastError(0xdeadbeef);
6063 ok(!DestroyWindow(wnd_event.hwnd), "DestroyWindow succeded\n");
6064 ok(GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == 0xdeadbeef,
6065 "wrong error code %d\n", GetLastError());
6066
6067 proc = (WNDPROC)GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
6068 ok(proc != NULL, "GetWindowLongPtrA(GWLP_WNDPROC) error %d\n", GetLastError());
6069
6070 expected_len = lstrlenA("window caption text");
6071 memset(buf, 0, sizeof(buf));
6072 SetLastError(0xdeadbeef);
6073 len = CallWindowProcA(proc, wnd_event.hwnd, WM_GETTEXT, sizeof(buf), (LPARAM)buf);
6074 ok(len == expected_len, "CallWindowProcA(WM_GETTEXT) error %d, len %d, expected len %d\n", GetLastError(), len, expected_len);
6075 ok(!lstrcmpA(buf, "window caption text"), "window text mismatch\n");
6076
6077 msg.hwnd = wnd_event.hwnd;
6078 msg.message = WM_GETTEXT;
6079 msg.wParam = sizeof(buf);
6080 msg.lParam = (LPARAM)buf;
6081 memset(buf, 0, sizeof(buf));
6082 SetLastError(0xdeadbeef);
6083 len = DispatchMessageA(&msg);
6084 ok((!len && GetLastError() == ERROR_MESSAGE_SYNC_ONLY) || broken(len), /* nt4 */
6085 "DispatchMessageA(WM_GETTEXT) succeded on another thread window: ret %d, error %d\n", len, GetLastError());
6086
6087 /* the following test causes an exception in user.exe under win9x */
6088 msg.hwnd = wnd_event.hwnd;
6089 msg.message = WM_TIMER;
6090 msg.wParam = 0;
6091 msg.lParam = GetWindowLongPtrA(wnd_event.hwnd, GWLP_WNDPROC);
6092 SetLastError(0xdeadbeef);
6093 len = DispatchMessageA(&msg);
6094 ok(!len && GetLastError() == 0xdeadbeef,
6095 "DispatchMessageA(WM_TIMER) failed on another thread window: ret %d, error %d\n", len, GetLastError());
6096
6097 ret = PostMessageA(wnd_event.hwnd, WM_QUIT, 0, 0);
6098 ok( ret, "PostMessageA(WM_QUIT) error %d\n", GetLastError());
6099
6100 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
6101 CloseHandle(hThread);
6102
6103 ok(!IsWindow(wnd_event.hwnd), "window should be destroyed on thread exit\n");
6104 }
6105
6106
6107 static const struct message WmVkN[] = {
6108 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6109 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6110 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
6111 { WM_CHAR, wparam|lparam, 'n', 1 },
6112 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1002,1), 0 },
6113 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6114 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6115 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6116 { 0 }
6117 };
6118 static const struct message WmShiftVkN[] = {
6119 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
6120 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
6121 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
6122 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6123 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6124 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
6125 { WM_CHAR, wparam|lparam, 'N', 1 },
6126 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1001,1), 0 },
6127 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6128 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6129 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6130 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
6131 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
6132 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
6133 { 0 }
6134 };
6135 static const struct message WmCtrlVkN[] = {
6136 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6137 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6138 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6139 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6140 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6141 { WM_KEYDOWN, sent|wparam|lparam, 'N', 1 },
6142 { WM_CHAR, wparam|lparam, 0x000e, 1 },
6143 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
6144 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6145 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6146 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6147 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6148 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6149 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6150 { 0 }
6151 };
6152 static const struct message WmCtrlVkN_2[] = {
6153 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6154 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6155 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6156 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6157 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6158 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1000,1), 0 },
6159 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6160 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6161 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6162 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6163 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6164 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6165 { 0 }
6166 };
6167 static const struct message WmAltVkN[] = {
6168 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6169 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6170 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6171 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6172 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
6173 { WM_SYSKEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
6174 { WM_SYSCHAR, wparam|lparam, 'n', 0x20000001 },
6175 { WM_SYSCHAR, sent|wparam|lparam, 'n', 0x20000001 },
6176 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 'n' },
6177 { HCBT_SYSCOMMAND, hook },
6178 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
6179 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6180 { 0x00AE, sent|defwinproc|optional }, /* XP */
6181 { WM_GETTEXT, sent|defwinproc|optional }, /* XP */
6182 { WM_INITMENU, sent|defwinproc },
6183 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6184 { WM_MENUCHAR, sent|defwinproc|wparam, MAKEWPARAM('n',MF_SYSMENU) },
6185 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
6186 { WM_CAPTURECHANGED, sent|defwinproc },
6187 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,0xffff) },
6188 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6189 { WM_EXITMENULOOP, sent|defwinproc },
6190 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) }, /* Win95 bug */
6191 { WM_EXITMENULOOP, sent|defwinproc|optional }, /* Win95 bug */
6192 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6193 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
6194 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6195 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6196 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6197 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6198 { 0 }
6199 };
6200 static const struct message WmAltVkN_2[] = {
6201 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6202 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6203 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6204 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6205 { WM_SYSKEYDOWN, wparam|lparam, 'N', 0x20000001 },
6206 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1003,1), 0 },
6207 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6208 { WM_SYSKEYUP, wparam|lparam, 'N', 0xe0000001 },
6209 { WM_SYSKEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6210 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6211 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6212 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6213 { 0 }
6214 };
6215 static const struct message WmCtrlAltVkN[] = {
6216 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6217 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6218 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6219 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6220 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6221 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6222 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6223 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
6224 { WM_KEYDOWN, sent|wparam|lparam, 'N', 0x20000001 },
6225 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6226 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
6227 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6228 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6229 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6230 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6231 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6232 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6233 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6234 { 0 }
6235 };
6236 static const struct message WmCtrlShiftVkN[] = {
6237 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6238 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6239 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6240 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 1 }, /* XP */
6241 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 1 },
6242 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 1 },
6243 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
6244 { WM_KEYDOWN, wparam|lparam, 'N', 1 },
6245 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1004,1), 0 },
6246 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
6247 { WM_KEYUP, wparam|lparam, 'N', 0xc0000001 },
6248 { WM_KEYUP, sent|wparam|lparam, 'N', 0xc0000001 },
6249 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xc0000001 }, /* XP */
6250 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xc0000001 },
6251 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xc0000001 },
6252 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6253 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6254 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6255 { 0 }
6256 };
6257 static const struct message WmCtrlAltShiftVkN[] = {
6258 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 1 }, /* XP */
6259 { WM_KEYDOWN, wparam|lparam, VK_CONTROL, 1 },
6260 { WM_KEYDOWN, sent|wparam|lparam, VK_CONTROL, 1 },
6261 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6262 { WM_KEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6263 { WM_KEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6264 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0x20000001 }, /* XP */
6265 { WM_KEYDOWN, wparam|lparam, VK_SHIFT, 0x20000001 },
6266 { WM_KEYDOWN, sent|wparam|lparam, VK_SHIFT, 0x20000001 },
6267 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0x20000001 }, /* XP */
6268 { WM_KEYDOWN, wparam|lparam, 'N', 0x20000001 },
6269 { WM_COMMAND, sent|wparam|lparam, MAKEWPARAM(1005,1), 0 },
6270 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xe0000001 }, /* XP */
6271 { WM_KEYUP, wparam|lparam, 'N', 0xe0000001 },
6272 { WM_KEYUP, sent|wparam|lparam, 'N', 0xe0000001 },
6273 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_SHIFT, 0xe0000001 }, /* XP */
6274 { WM_KEYUP, wparam|lparam, VK_SHIFT, 0xe0000001 },
6275 { WM_KEYUP, sent|wparam|lparam, VK_SHIFT, 0xe0000001 },
6276 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6277 { WM_KEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6278 { WM_KEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6279 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_CONTROL, 0xc0000001 }, /* XP */
6280 { WM_KEYUP, wparam|lparam, VK_CONTROL, 0xc0000001 },
6281 { WM_KEYUP, sent|wparam|lparam, VK_CONTROL, 0xc0000001 },
6282 { 0 }
6283 };
6284 static const struct message WmAltPressRelease[] = {
6285 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6286 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6287 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6288 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6289 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6290 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6291 { WM_SYSCOMMAND, sent|defwinproc|wparam|lparam, SC_KEYMENU, 0 },
6292 { HCBT_SYSCOMMAND, hook },
6293 { WM_ENTERMENULOOP, sent|defwinproc|wparam|lparam, 0, 0 },
6294 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
6295 { WM_INITMENU, sent|defwinproc },
6296 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6297 { WM_MENUSELECT, sent|defwinproc|wparam, MAKEWPARAM(0,MF_SYSMENU|MF_POPUP|MF_HILITE) },
6298 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
6299
6300 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x30000001 }, /* XP */
6301
6302 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6303 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0, },
6304 { WM_CAPTURECHANGED, sent|defwinproc },
6305 { WM_MENUSELECT, sent|defwinproc|wparam|optional, MAKEWPARAM(0,0xffff) },
6306 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_SYSMENU, 0 },
6307 { WM_EXITMENULOOP, sent|defwinproc },
6308 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6309 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6310 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6311 { 0 }
6312 };
6313 static const struct message WmAltMouseButton[] = {
6314 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 }, /* XP */
6315 { WM_SYSKEYDOWN, wparam|lparam, VK_MENU, 0x20000001 },
6316 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
6317 { WM_MOUSEMOVE, wparam|optional, 0, 0 },
6318 { WM_MOUSEMOVE, sent|wparam|optional, 0, 0 },
6319 { WM_LBUTTONDOWN, wparam, MK_LBUTTON, 0 },
6320 { WM_LBUTTONDOWN, sent|wparam, MK_LBUTTON, 0 },
6321 { WM_LBUTTONUP, wparam, 0, 0 },
6322 { WM_LBUTTONUP, sent|wparam, 0, 0 },
6323 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xc0000001 }, /* XP */
6324 { WM_SYSKEYUP, wparam|lparam, VK_MENU, 0xc0000001 },
6325 { WM_SYSKEYUP, sent|wparam|lparam, VK_MENU, 0xc0000001 },
6326 { 0 }
6327 };
6328 static const struct message WmF1Seq[] = {
6329 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 1 }, /* XP */
6330 { WM_KEYDOWN, wparam|lparam, VK_F1, 1 },
6331 { WM_KEYDOWN, sent|wparam|lparam, VK_F1, 0x00000001 },
6332 { WM_KEYF1, wparam|lparam, 0, 0 },
6333 { WM_KEYF1, sent|wparam|lparam, 0, 0 },
6334 { WM_HELP, sent|defwinproc },
6335 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_F1, 0xc0000001 }, /* XP */
6336 { WM_KEYUP, wparam|lparam, VK_F1, 0xc0000001 },
6337 { WM_KEYUP, sent|wparam|lparam, VK_F1, 0xc0000001 },
6338 { 0 }
6339 };
6340 static const struct message WmVkAppsSeq[] = {
6341 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 1 }, /* XP */
6342 { WM_KEYDOWN, wparam|lparam, VK_APPS, 1 },
6343 { WM_KEYDOWN, sent|wparam|lparam, VK_APPS, 0x00000001 },
6344 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_APPS, 0xc0000001 }, /* XP */
6345 { WM_KEYUP, wparam|lparam, VK_APPS, 0xc0000001 },
6346 { WM_KEYUP, sent|wparam|lparam, VK_APPS, 0xc0000001 },
6347 { WM_CONTEXTMENU, lparam, /*hwnd*/0, (LPARAM)-1 },
6348 { WM_CONTEXTMENU, sent|lparam, /*hwnd*/0, (LPARAM)-1 },
6349 { 0 }
6350 };
6351
6352 static void pump_msg_loop(HWND hwnd, HACCEL hAccel)
6353 {
6354 MSG msg;
6355
6356 while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
6357 {
6358 struct message log_msg;
6359
6360 trace("accel: %p, %04x, %08lx, %08lx\n", msg.hwnd, msg.message, msg.wParam, msg.lParam);
6361
6362 /* ignore some unwanted messages */
6363 if (msg.message == WM_MOUSEMOVE ||
6364 msg.message == WM_GETICON ||
6365 msg.message == WM_DEVICECHANGE)
6366 continue;
6367
6368 log_msg.message = msg.message;
6369 log_msg.flags = wparam|lparam;
6370 log_msg.wParam = msg.wParam;
6371 log_msg.lParam = msg.lParam;
6372 add_message(&log_msg);
6373
6374 if (!hAccel || !TranslateAccelerator(hwnd, hAccel, &msg))
6375 {
6376 TranslateMessage(&msg);
6377 DispatchMessage(&msg);
6378 }
6379 }
6380 }
6381
6382 static void test_accelerators(void)
6383 {
6384 RECT rc;
6385 SHORT state;
6386 HACCEL hAccel;
6387 HWND hwnd = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
6388 100, 100, 200, 200, 0, 0, 0, NULL);
6389 BOOL ret;
6390
6391 assert(hwnd != 0);
6392 UpdateWindow(hwnd);
6393 flush_events();
6394 flush_sequence();
6395
6396 SetFocus(hwnd);
6397 ok(GetFocus() == hwnd, "wrong focus window %p\n", GetFocus());
6398
6399 state = GetKeyState(VK_SHIFT);
6400 ok(!(state & 0x8000), "wrong Shift state %04x\n", state);
6401 state = GetKeyState(VK_CAPITAL);
6402 ok(state == 0, "wrong CapsLock state %04x\n", state);
6403
6404 hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(1));
6405 assert(hAccel != 0);
6406
6407 flush_events();
6408 pump_msg_loop(hwnd, 0);
6409 flush_sequence();
6410
6411 trace("testing VK_N press/release\n");
6412 flush_sequence();
6413 keybd_event('N', 0, 0, 0);
6414 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6415 pump_msg_loop(hwnd, hAccel);
6416 ok_sequence(WmVkN, "VK_N press/release", FALSE);
6417
6418 trace("testing Shift+VK_N press/release\n");
6419 flush_sequence();
6420 keybd_event(VK_SHIFT, 0, 0, 0);
6421 keybd_event('N', 0, 0, 0);
6422 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6423 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6424 pump_msg_loop(hwnd, hAccel);
6425 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
6426
6427 trace("testing Ctrl+VK_N press/release\n");
6428 flush_sequence();
6429 keybd_event(VK_CONTROL, 0, 0, 0);
6430 keybd_event('N', 0, 0, 0);
6431 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6432 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6433 pump_msg_loop(hwnd, hAccel);
6434 ok_sequence(WmCtrlVkN, "Ctrl+VK_N press/release", FALSE);
6435
6436 trace("testing Alt+VK_N press/release\n");
6437 flush_sequence();
6438 keybd_event(VK_MENU, 0, 0, 0);
6439 keybd_event('N', 0, 0, 0);
6440 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6441 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6442 pump_msg_loop(hwnd, hAccel);
6443 ok_sequence(WmAltVkN, "Alt+VK_N press/release", FALSE);
6444
6445 trace("testing Ctrl+Alt+VK_N press/release 1\n");
6446 flush_sequence();
6447 keybd_event(VK_CONTROL, 0, 0, 0);
6448 keybd_event(VK_MENU, 0, 0, 0);
6449 keybd_event('N', 0, 0, 0);
6450 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6451 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6452 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6453 pump_msg_loop(hwnd, hAccel);
6454 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 1", FALSE);
6455
6456 ret = DestroyAcceleratorTable(hAccel);
6457 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
6458
6459 hAccel = LoadAccelerators(GetModuleHandleA(0), MAKEINTRESOURCE(2));
6460 assert(hAccel != 0);
6461
6462 trace("testing VK_N press/release\n");
6463 flush_sequence();
6464 keybd_event('N', 0, 0, 0);
6465 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6466 pump_msg_loop(hwnd, hAccel);
6467 ok_sequence(WmVkN, "VK_N press/release", FALSE);
6468
6469 trace("testing Shift+VK_N press/release\n");
6470 flush_sequence();
6471 keybd_event(VK_SHIFT, 0, 0, 0);
6472 keybd_event('N', 0, 0, 0);
6473 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6474 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6475 pump_msg_loop(hwnd, hAccel);
6476 ok_sequence(WmShiftVkN, "Shift+VK_N press/release", FALSE);
6477
6478 trace("testing Ctrl+VK_N press/release 2\n");
6479 flush_sequence();
6480 keybd_event(VK_CONTROL, 0, 0, 0);
6481 keybd_event('N', 0, 0, 0);
6482 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6483 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6484 pump_msg_loop(hwnd, hAccel);
6485 ok_sequence(WmCtrlVkN_2, "Ctrl+VK_N press/release 2", FALSE);
6486
6487 trace("testing Alt+VK_N press/release 2\n");
6488 flush_sequence();
6489 keybd_event(VK_MENU, 0, 0, 0);
6490 keybd_event('N', 0, 0, 0);
6491 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6492 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6493 pump_msg_loop(hwnd, hAccel);
6494 ok_sequence(WmAltVkN_2, "Alt+VK_N press/release 2", FALSE);
6495
6496 trace("testing Ctrl+Alt+VK_N press/release 2\n");
6497 flush_sequence();
6498 keybd_event(VK_CONTROL, 0, 0, 0);
6499 keybd_event(VK_MENU, 0, 0, 0);
6500 keybd_event('N', 0, 0, 0);
6501 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6502 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6503 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6504 pump_msg_loop(hwnd, hAccel);
6505 ok_sequence(WmCtrlAltVkN, "Ctrl+Alt+VK_N press/release 2", FALSE);
6506
6507 trace("testing Ctrl+Shift+VK_N press/release\n");
6508 flush_sequence();
6509 keybd_event(VK_CONTROL, 0, 0, 0);
6510 keybd_event(VK_SHIFT, 0, 0, 0);
6511 keybd_event('N', 0, 0, 0);
6512 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6513 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6514 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6515 pump_msg_loop(hwnd, hAccel);
6516 ok_sequence(WmCtrlShiftVkN, "Ctrl+Shift+VK_N press/release", FALSE);
6517
6518 trace("testing Ctrl+Alt+Shift+VK_N press/release\n");
6519 flush_sequence();
6520 keybd_event(VK_CONTROL, 0, 0, 0);
6521 keybd_event(VK_MENU, 0, 0, 0);
6522 keybd_event(VK_SHIFT, 0, 0, 0);
6523 keybd_event('N', 0, 0, 0);
6524 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
6525 keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
6526 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6527 keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
6528 pump_msg_loop(hwnd, hAccel);
6529 ok_sequence(WmCtrlAltShiftVkN, "Ctrl+Alt+Shift+VK_N press/release", FALSE);
6530
6531 ret = DestroyAcceleratorTable(hAccel);
6532 ok( ret, "DestroyAcceleratorTable error %d\n", GetLastError());
6533
6534 trace("testing Alt press/release\n");
6535 flush_sequence();
6536 keybd_event(VK_MENU, 0, 0, 0);
6537 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6538 keybd_event(VK_MENU, 0, 0, 0);
6539 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6540 pump_msg_loop(hwnd, 0);
6541 /* this test doesn't pass in Wine for managed windows */
6542 ok_sequence(WmAltPressRelease, "Alt press/release", TRUE);
6543
6544 trace("testing Alt+MouseButton press/release\n");
6545 /* first, move mouse pointer inside of the window client area */
6546 GetClientRect(hwnd, &rc);
6547 MapWindowPoints(hwnd, 0, (LPPOINT)&rc, 2);
6548 rc.left += (rc.right - rc.left)/2;
6549 rc.top += (rc.bottom - rc.top)/2;
6550 SetCursorPos(rc.left, rc.top);
6551
6552 flush_events();
6553 flush_sequence();
6554 keybd_event(VK_MENU, 0, 0, 0);
6555 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
6556 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
6557 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
6558 pump_msg_loop(hwnd, 0);
6559 ok_sequence(WmAltMouseButton, "Alt+MouseButton press/release", FALSE);
6560
6561 trace("testing VK_F1 press/release\n");
6562 keybd_event(VK_F1, 0, 0, 0);
6563 keybd_event(VK_F1, 0, KEYEVENTF_KEYUP, 0);
6564 pump_msg_loop(hwnd, 0);
6565 ok_sequence(WmF1Seq, "F1 press/release", FALSE);
6566
6567 trace("testing VK_APPS press/release\n");
6568 keybd_event(VK_APPS, 0, 0, 0);
6569 keybd_event(VK_APPS, 0, KEYEVENTF_KEYUP, 0);
6570 pump_msg_loop(hwnd, 0);
6571 ok_sequence(WmVkAppsSeq, "VK_APPS press/release", FALSE);
6572
6573 DestroyWindow(hwnd);
6574 }
6575
6576 /************* window procedures ********************/
6577
6578 static LRESULT MsgCheckProc (BOOL unicode, HWND hwnd, UINT message,
6579 WPARAM wParam, LPARAM lParam)
6580 {
6581 static long defwndproc_counter = 0;
6582 static long beginpaint_counter = 0;
6583 LRESULT ret;
6584 struct message msg;
6585
6586 trace("%p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6587
6588 /* explicitly ignore WM_GETICON message */
6589 if (message == WM_GETICON) return 0;
6590
6591 switch (message)
6592 {
6593 case WM_ENABLE:
6594 {
6595 LONG style = GetWindowLongA(hwnd, GWL_STYLE);
6596 ok((BOOL)wParam == !(style & WS_DISABLED),
6597 "wrong WS_DISABLED state: %ld != %d\n", wParam, !(style & WS_DISABLED));
6598 break;
6599 }
6600
6601 case WM_CAPTURECHANGED:
6602 if (test_DestroyWindow_flag)
6603 {
6604 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
6605 if (style & WS_CHILD)
6606 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
6607 else if (style & WS_POPUP)
6608 lParam = WND_POPUP_ID;
6609 else
6610 lParam = WND_PARENT_ID;
6611 }
6612 break;
6613
6614 case WM_NCDESTROY:
6615 {
6616 HWND capture;
6617
6618 ok(!GetWindow(hwnd, GW_CHILD), "children should be unlinked at this point\n");
6619 capture = GetCapture();
6620 if (capture)
6621 {
6622 ok(capture == hwnd, "capture should NOT be released at this point (capture %p)\n", capture);
6623 trace("current capture %p, releasing...\n", capture);
6624 ReleaseCapture();
6625 }
6626 }
6627 /* fall through */
6628 case WM_DESTROY:
6629 if (pGetAncestor)
6630 ok(pGetAncestor(hwnd, GA_PARENT) != 0, "parent should NOT be unlinked at this point\n");
6631 if (test_DestroyWindow_flag)
6632 {
6633 DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
6634 if (style & WS_CHILD)
6635 lParam = GetWindowLongPtrA(hwnd, GWLP_ID);
6636 else if (style & WS_POPUP)
6637 lParam = WND_POPUP_ID;
6638 else
6639 lParam = WND_PARENT_ID;
6640 }
6641 break;
6642
6643 /* test_accelerators() depends on this */
6644 case WM_NCHITTEST:
6645 return HTCLIENT;
6646
6647 /* ignore */
6648 case WM_MOUSEMOVE:
6649 case WM_SETCURSOR:
6650 case WM_DEVICECHANGE:
6651 return 0;
6652
6653 case WM_WINDOWPOSCHANGING:
6654 case WM_WINDOWPOSCHANGED:
6655 {
6656 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6657
6658 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6659 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
6660 winpos->hwnd, winpos->hwndInsertAfter,
6661 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6662 dump_winpos_flags(winpos->flags);
6663
6664 /* Log only documented flags, win2k uses 0x1000 and 0x2000
6665 * in the high word for internal purposes
6666 */
6667 wParam = winpos->flags & 0xffff;
6668 /* We are not interested in the flags that don't match under XP and Win9x */
6669 wParam &= ~(SWP_NOZORDER);
6670 break;
6671 }
6672 }
6673
6674 msg.message = message;
6675 msg.flags = sent|wparam|lparam;
6676 if (defwndproc_counter) msg.flags |= defwinproc;
6677 if (beginpaint_counter) msg.flags |= beginpaint;
6678 msg.wParam = wParam;
6679 msg.lParam = lParam;
6680 add_message(&msg);
6681
6682 if (message == WM_GETMINMAXINFO && (GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
6683 {
6684 HWND parent = GetParent(hwnd);
6685 RECT rc;
6686 MINMAXINFO *minmax = (MINMAXINFO *)lParam;
6687
6688 GetClientRect(parent, &rc);
6689 trace("parent %p client size = (%d x %d)\n", parent, rc.right, rc.bottom);
6690 trace("Reserved=%d,%d MaxSize=%d,%d MaxPos=%d,%d MinTrack=%d,%d MaxTrack=%d,%d\n",
6691 minmax->ptReserved.x, minmax->ptReserved.y,
6692 minmax->ptMaxSize.x, minmax->ptMaxSize.y,
6693 minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
6694 minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
6695 minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
6696
6697 ok(minmax->ptMaxSize.x == rc.right, "default width of maximized child %d != %d\n",
6698 minmax->ptMaxSize.x, rc.right);
6699 ok(minmax->ptMaxSize.y == rc.bottom, "default height of maximized child %d != %d\n",
6700 minmax->ptMaxSize.y, rc.bottom);
6701 }
6702
6703 if (message == WM_PAINT)
6704 {
6705 PAINTSTRUCT ps;
6706 beginpaint_counter++;
6707 BeginPaint( hwnd, &ps );
6708 beginpaint_counter--;
6709 EndPaint( hwnd, &ps );
6710 return 0;
6711 }
6712
6713 defwndproc_counter++;
6714 ret = unicode ? DefWindowProcW(hwnd, message, wParam, lParam)
6715 : DefWindowProcA(hwnd, message, wParam, lParam);
6716 defwndproc_counter--;
6717
6718 return ret;
6719 }
6720
6721 static LRESULT WINAPI MsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6722 {
6723 return MsgCheckProc (FALSE, hwnd, message, wParam, lParam);
6724 }
6725
6726 static LRESULT WINAPI MsgCheckProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6727 {
6728 return MsgCheckProc (TRUE, hwnd, message, wParam, lParam);
6729 }
6730
6731 static LRESULT WINAPI PopupMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6732 {
6733 static long defwndproc_counter = 0;
6734 LRESULT ret;
6735 struct message msg;
6736
6737 trace("popup: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6738
6739 switch (message)
6740 {
6741 case WM_GETICON:
6742 /* explicitly ignore WM_GETICON message */
6743 return 0;
6744 case WM_QUERYENDSESSION:
6745 case WM_ENDSESSION:
6746 lParam &= ~0x01; /* Vista adds a 0x01 flag */
6747 break;
6748 }
6749
6750 msg.message = message;
6751 msg.flags = sent|wparam|lparam;
6752 if (defwndproc_counter) msg.flags |= defwinproc;
6753 msg.wParam = wParam;
6754 msg.lParam = lParam;
6755 add_message(&msg);
6756
6757 if (message == WM_CREATE)
6758 {
6759 DWORD style = GetWindowLongA(hwnd, GWL_STYLE) | WS_VISIBLE;
6760 SetWindowLongA(hwnd, GWL_STYLE, style);
6761 }
6762
6763 defwndproc_counter++;
6764 ret = DefWindowProcA(hwnd, message, wParam, lParam);
6765 defwndproc_counter--;
6766
6767 return ret;
6768 }
6769
6770 static LRESULT WINAPI ParentMsgCheckProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6771 {
6772 static long defwndproc_counter = 0;
6773 static long beginpaint_counter = 0;
6774 LRESULT ret;
6775 struct message msg;
6776 LPARAM logged_lParam;
6777
6778 trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6779
6780 /* explicitly ignore WM_GETICON message */
6781 if (message == WM_GETICON) return 0;
6782
6783 logged_lParam=lParam;
6784 if (log_all_parent_messages ||
6785 message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
6786 message == WM_SETFOCUS || message == WM_KILLFOCUS ||
6787 message == WM_ENABLE || message == WM_ENTERIDLE ||
6788 message == WM_DRAWITEM ||
6789 message == WM_IME_SETCONTEXT)
6790 {
6791 switch (message)
6792 {
6793 /* ignore */
6794 case WM_NCHITTEST:
6795 return HTCLIENT;
6796 case WM_SETCURSOR:
6797 case WM_MOUSEMOVE:
6798 return 0;
6799
6800 case WM_ERASEBKGND:
6801 {
6802 RECT rc;
6803 INT ret = GetClipBox((HDC)wParam, &rc);
6804
6805 trace("WM_ERASEBKGND: GetClipBox()=%d, (%d,%d-%d,%d)\n",
6806 ret, rc.left, rc.top, rc.right, rc.bottom);
6807 break;
6808 }
6809
6810 case WM_WINDOWPOSCHANGING:
6811 case WM_WINDOWPOSCHANGED:
6812 {
6813 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6814
6815 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6816 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
6817 winpos->hwnd, winpos->hwndInsertAfter,
6818 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6819 dump_winpos_flags(winpos->flags);
6820
6821 /* Log only documented flags, win2k uses 0x1000 and 0x2000
6822 * in the high word for internal purposes
6823 */
6824 wParam = winpos->flags & 0xffff;
6825 /* We are not interested in the flags that don't match under XP and Win9x */
6826 wParam &= ~(SWP_NOZORDER);
6827 break;
6828 }
6829
6830 case WM_DRAWITEM:
6831 {
6832 /* encode DRAWITEMSTRUCT into an LPARAM */
6833 DRAW_ITEM_STRUCT di;
6834 DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT *)lParam;
6835
6836 trace("WM_DRAWITEM: type %x, ctl_id %x, item_id %x, action %x, state %x\n",
6837 dis->CtlType, dis->CtlID, dis->itemID, dis->itemAction, dis->itemState);
6838
6839 di.u.item.type = dis->CtlType;
6840 di.u.item.ctl_id = dis->CtlID;
6841 di.u.item.item_id = dis->itemID;
6842 di.u.item.action = dis->itemAction;
6843 di.u.item.state = dis->itemState;
6844
6845 logged_lParam = di.u.lp;
6846 break;
6847 }
6848 }
6849
6850 msg.message = message;
6851 msg.flags = sent|parent|wparam|lparam;
6852 if (defwndproc_counter) msg.flags |= defwinproc;
6853 if (beginpaint_counter) msg.flags |= beginpaint;
6854 msg.wParam = wParam;
6855 msg.lParam = logged_lParam;
6856 add_message(&msg);
6857 }
6858
6859 if (message == WM_PAINT)
6860 {
6861 PAINTSTRUCT ps;
6862 beginpaint_counter++;
6863 BeginPaint( hwnd, &ps );
6864 beginpaint_counter--;
6865 EndPaint( hwnd, &ps );
6866 return 0;
6867 }
6868
6869 defwndproc_counter++;
6870 ret = DefWindowProcA(hwnd, message, wParam, lParam);
6871 defwndproc_counter--;
6872
6873 return ret;
6874 }
6875
6876 static LRESULT WINAPI TestDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6877 {
6878 static long defwndproc_counter = 0;
6879 LRESULT ret;
6880 struct message msg;
6881
6882 trace("dialog: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
6883
6884 /* explicitly ignore WM_GETICON message */
6885 if (message == WM_GETICON) return 0;
6886
6887 if (test_def_id)
6888 {
6889 DefDlgProcA(hwnd, DM_SETDEFID, 1, 0);
6890 ret = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
6891 if (after_end_dialog)
6892 ok( ret == 0, "DM_GETDEFID should return 0 after EndDialog, got %lx\n", ret );
6893 else
6894 ok(HIWORD(ret) == DC_HASDEFID, "DM_GETDEFID should return DC_HASDEFID, got %lx\n", ret);
6895 }
6896
6897 switch (message)
6898 {
6899 case WM_WINDOWPOSCHANGING:
6900 case WM_WINDOWPOSCHANGED:
6901 {
6902 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
6903
6904 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
6905 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
6906 winpos->hwnd, winpos->hwndInsertAfter,
6907 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
6908 dump_winpos_flags(winpos->flags);
6909
6910 /* Log only documented flags, win2k uses 0x1000 and 0x2000
6911 * in the high word for internal purposes
6912 */
6913 wParam = winpos->flags & 0xffff;
6914 /* We are not interested in the flags that don't match under XP and Win9x */
6915 wParam &= ~(SWP_NOZORDER);
6916 break;
6917 }
6918 }
6919
6920 msg.message = message;
6921 msg.flags = sent|wparam|lparam;
6922 if (defwndproc_counter) msg.flags |= defwinproc;
6923 msg.wParam = wParam;
6924 msg.lParam = lParam;
6925 add_message(&msg);
6926
6927 defwndproc_counter++;
6928 ret = DefDlgProcA(hwnd, message, wParam, lParam);
6929 defwndproc_counter--;
6930
6931 return ret;
6932 }
6933
6934 static void dump_winpos_flags(UINT flags)
6935 {
6936 if (!winetest_debug) return;
6937
6938 if (flags & SWP_SHOWWINDOW) printf("|SWP_SHOWWINDOW");
6939 if (flags & SWP_HIDEWINDOW) printf("|SWP_HIDEWINDOW");
6940 if (flags & SWP_NOACTIVATE) printf("|SWP_NOACTIVATE");
6941 if (flags & SWP_FRAMECHANGED) printf("|SWP_FRAMECHANGED");
6942 if (flags & SWP_NOCOPYBITS) printf("|SWP_NOCOPYBITS");
6943 if (flags & SWP_NOOWNERZORDER) printf("|SWP_NOOWNERZORDER");
6944 if (flags & SWP_NOSENDCHANGING) printf("|SWP_NOSENDCHANGING");
6945 if (flags & SWP_DEFERERASE) printf("|SWP_DEFERERASE");
6946 if (flags & SWP_ASYNCWINDOWPOS) printf("|SWP_ASYNCWINDOWPOS");
6947 if (flags & SWP_NOZORDER) printf("|SWP_NOZORDER");
6948 if (flags & SWP_NOREDRAW) printf("|SWP_NOREDRAW");
6949 if (flags & SWP_NOSIZE) printf("|SWP_NOSIZE");
6950 if (flags & SWP_NOMOVE) printf("|SWP_NOMOVE");
6951 if (flags & SWP_NOCLIENTSIZE) printf("|SWP_NOCLIENTSIZE");
6952 if (flags & SWP_NOCLIENTMOVE) printf("|SWP_NOCLIENTMOVE");
6953
6954 #define DUMPED_FLAGS \
6955 (SWP_NOSIZE | \
6956 SWP_NOMOVE | \
6957 SWP_NOZORDER | \
6958 SWP_NOREDRAW | \
6959 SWP_NOACTIVATE | \
6960 SWP_FRAMECHANGED | \
6961 SWP_SHOWWINDOW | \
6962 SWP_HIDEWINDOW | \
6963 SWP_NOCOPYBITS | \
6964 SWP_NOOWNERZORDER | \
6965 SWP_NOSENDCHANGING | \
6966 SWP_DEFERERASE | \
6967 SWP_ASYNCWINDOWPOS | \
6968 SWP_NOCLIENTSIZE | \
6969 SWP_NOCLIENTMOVE)
6970
6971 if(flags & ~DUMPED_FLAGS) printf("|0x%04x", flags & ~DUMPED_FLAGS);
6972 printf("\n");
6973 #undef DUMPED_FLAGS
6974 }
6975
6976 static LRESULT WINAPI ShowWindowProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
6977 {
6978 static long defwndproc_counter = 0;
6979 LRESULT ret;
6980 struct message msg;
6981
6982 /* log only specific messages we are interested in */
6983 switch (message)
6984 {
6985 #if 0 /* probably log these as well */
6986 case WM_ACTIVATE:
6987 case WM_SETFOCUS:
6988 case WM_KILLFOCUS:
6989 #endif
6990 case WM_SHOWWINDOW:
6991 trace("WM_SHOWWINDOW %ld\n", wParam);
6992 break;
6993 case WM_SIZE:
6994 trace("WM_SIZE %ld\n", wParam);
6995 break;
6996 case WM_MOVE:
6997 trace("WM_MOVE\n");
6998 break;
6999 case WM_GETMINMAXINFO:
7000 trace("WM_GETMINMAXINFO\n");
7001 break;
7002
7003 case WM_WINDOWPOSCHANGING:
7004 case WM_WINDOWPOSCHANGED:
7005 {
7006 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
7007
7008 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
7009 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
7010 winpos->hwnd, winpos->hwndInsertAfter,
7011 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
7012 trace("flags: ");
7013 dump_winpos_flags(winpos->flags);
7014
7015 /* Log only documented flags, win2k uses 0x1000 and 0x2000
7016 * in the high word for internal purposes
7017 */
7018 wParam = winpos->flags & 0xffff;
7019 /* We are not interested in the flags that don't match under XP and Win9x */
7020 wParam &= ~(SWP_NOZORDER);
7021 break;
7022 }
7023
7024 default: /* ignore */
7025 /*trace("showwindow: %p, %04x, %08x, %08lx\n", hwnd, message, wParam, lParam);*/
7026 return DefWindowProcA(hwnd, message, wParam, lParam);
7027 }
7028
7029 msg.message = message;
7030 msg.flags = sent|wparam|lparam;
7031 if (defwndproc_counter) msg.flags |= defwinproc;
7032 msg.wParam = wParam;
7033 msg.lParam = lParam;
7034 add_message(&msg);
7035
7036 defwndproc_counter++;
7037 ret = DefWindowProcA(hwnd, message, wParam, lParam);
7038 defwndproc_counter--;
7039
7040 return ret;
7041 }
7042
7043 LRESULT WINAPI PaintLoopProcA(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
7044 {
7045 switch (msg)
7046 {
7047 case WM_CREATE: return 0;
7048 case WM_PAINT:
7049 {
7050 MSG msg2;
7051 static int i = 0;
7052
7053 i++;
7054 if (PeekMessageA(&msg2, 0, 0, 0, 1))
7055 {
7056 TranslateMessage(&msg2);
7057 DispatchMessage(&msg2);
7058 }
7059 i--;
7060 if ( i == 0)
7061 paint_loop_done = 1;
7062 return DefWindowProcA(hWnd,msg,wParam,lParam);
7063 }
7064 }
7065 return DefWindowProcA(hWnd,msg,wParam,lParam);
7066 }
7067
7068 static BOOL RegisterWindowClasses(void)
7069 {
7070 WNDCLASSA cls;
7071 WNDCLASSW clsW;
7072
7073 cls.style = 0;
7074 cls.lpfnWndProc = MsgCheckProcA;
7075 cls.cbClsExtra = 0;
7076 cls.cbWndExtra = 0;
7077 cls.hInstance = GetModuleHandleA(0);
7078 cls.hIcon = 0;
7079 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
7080 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
7081 cls.lpszMenuName = NULL;
7082 cls.lpszClassName = "TestWindowClass";
7083 if(!RegisterClassA(&cls)) return FALSE;
7084
7085 cls.lpfnWndProc = ShowWindowProcA;
7086 cls.lpszClassName = "ShowWindowClass";
7087 if(!RegisterClassA(&cls)) return FALSE;
7088
7089 cls.lpfnWndProc = PopupMsgCheckProcA;
7090 cls.lpszClassName = "TestPopupClass";
7091 if(!RegisterClassA(&cls)) return FALSE;
7092
7093 cls.lpfnWndProc = ParentMsgCheckProcA;
7094 cls.lpszClassName = "TestParentClass";
7095 if(!RegisterClassA(&cls)) return FALSE;
7096
7097 cls.lpfnWndProc = DefWindowProcA;
7098 cls.lpszClassName = "SimpleWindowClass";
7099 if(!RegisterClassA(&cls)) return FALSE;
7100
7101 cls.lpfnWndProc = PaintLoopProcA;
7102 cls.lpszClassName = "PaintLoopWindowClass";
7103 if(!RegisterClassA(&cls)) return FALSE;
7104
7105 cls.style = CS_NOCLOSE;
7106 cls.lpszClassName = "NoCloseWindowClass";
7107 if(!RegisterClassA(&cls)) return FALSE;
7108
7109 ok(GetClassInfoA(0, "#32770", &cls), "GetClassInfo failed\n");
7110 cls.style = 0;
7111 cls.hInstance = GetModuleHandleA(0);
7112 cls.hbrBackground = 0;
7113 cls.lpfnWndProc = TestDlgProcA;
7114 cls.lpszClassName = "TestDialogClass";
7115 if(!RegisterClassA(&cls)) return FALSE;
7116
7117 clsW.style = 0;
7118 clsW.lpfnWndProc = MsgCheckProcW;
7119 clsW.cbClsExtra = 0;
7120 clsW.cbWndExtra = 0;
7121 clsW.hInstance = GetModuleHandleW(0);
7122 clsW.hIcon = 0;
7123 clsW.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
7124 clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
7125 clsW.lpszMenuName = NULL;
7126 clsW.lpszClassName = testWindowClassW;
7127 RegisterClassW(&clsW); /* ignore error, this fails on Win9x */
7128
7129 return TRUE;
7130 }
7131
7132 static BOOL is_our_logged_class(HWND hwnd)
7133 {
7134 char buf[256];
7135
7136 if (GetClassNameA(hwnd, buf, sizeof(buf)))
7137 {
7138 if (!lstrcmpiA(buf, "TestWindowClass") ||
7139 !lstrcmpiA(buf, "ShowWindowClass") ||
7140 !lstrcmpiA(buf, "TestParentClass") ||
7141 !lstrcmpiA(buf, "TestPopupClass") ||
7142 !lstrcmpiA(buf, "SimpleWindowClass") ||
7143 !lstrcmpiA(buf, "TestDialogClass") ||
7144 !lstrcmpiA(buf, "MDI_frame_class") ||
7145 !lstrcmpiA(buf, "MDI_client_class") ||
7146 !lstrcmpiA(buf, "MDI_child_class") ||
7147 !lstrcmpiA(buf, "my_button_class") ||
7148 !lstrcmpiA(buf, "my_edit_class") ||
7149 !lstrcmpiA(buf, "static") ||
7150 !lstrcmpiA(buf, "ListBox") ||
7151 !lstrcmpiA(buf, "ComboBox") ||
7152 !lstrcmpiA(buf, "MyDialogClass") ||
7153 !lstrcmpiA(buf, "#32770") ||
7154 !lstrcmpiA(buf, "#32768"))
7155 return TRUE;
7156 trace("ignoring window class %s\n", buf);
7157 }
7158 return FALSE;
7159 }
7160
7161 static HHOOK hCBT_hook;
7162 static DWORD cbt_hook_thread_id;
7163
7164 static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
7165 {
7166 static const char * const CBT_code_name[10] = {
7167 "HCBT_MOVESIZE",
7168 "HCBT_MINMAX",
7169 "HCBT_QS",
7170 "HCBT_CREATEWND",
7171 "HCBT_DESTROYWND",
7172 "HCBT_ACTIVATE",
7173 "HCBT_CLICKSKIPPED",
7174 "HCBT_KEYSKIPPED",
7175 "HCBT_SYSCOMMAND",
7176 "HCBT_SETFOCUS" };
7177 const char *code_name = (nCode >= 0 && nCode <= HCBT_SETFOCUS) ? CBT_code_name[nCode] : "Unknown";
7178 HWND hwnd;
7179
7180 trace("CBT: %d (%s), %08lx, %08lx\n", nCode, code_name, wParam, lParam);
7181
7182 ok(cbt_hook_thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
7183
7184 if (nCode == HCBT_CLICKSKIPPED)
7185 {
7186 /* ignore this event, XP sends it a lot when switching focus between windows */
7187 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
7188 }
7189
7190 if (nCode == HCBT_SYSCOMMAND || nCode == HCBT_KEYSKIPPED)
7191 {
7192 struct message msg;
7193
7194 msg.message = nCode;
7195 msg.flags = hook|wparam|lparam;
7196 msg.wParam = wParam;
7197 msg.lParam = lParam;
7198 add_message(&msg);
7199
7200 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
7201 }
7202
7203 if (nCode == HCBT_DESTROYWND)
7204 {
7205 if (test_DestroyWindow_flag)
7206 {
7207 DWORD style = GetWindowLongA((HWND)wParam, GWL_STYLE);
7208 if (style & WS_CHILD)
7209 lParam = GetWindowLongPtrA((HWND)wParam, GWLP_ID);
7210 else if (style & WS_POPUP)
7211 lParam = WND_POPUP_ID;
7212 else
7213 lParam = WND_PARENT_ID;
7214 }
7215 }
7216
7217 /* Log also SetFocus(0) calls */
7218 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
7219
7220 if (is_our_logged_class(hwnd))
7221 {
7222 struct message msg;
7223
7224 msg.message = nCode;
7225 msg.flags = hook|wparam|lparam;
7226 msg.wParam = wParam;
7227 msg.lParam = lParam;
7228 add_message(&msg);
7229 }
7230 return CallNextHookEx(hCBT_hook, nCode, wParam, lParam);
7231 }
7232
7233 static void CALLBACK win_event_proc(HWINEVENTHOOK hevent,
7234 DWORD event,
7235 HWND hwnd,
7236 LONG object_id,
7237 LONG child_id,
7238 DWORD thread_id,
7239 DWORD event_time)
7240 {
7241 trace("WEH:%p,event %08x,hwnd %p,obj %08x,id %08x,thread %08x,time %08x\n",
7242 hevent, event, hwnd, object_id, child_id, thread_id, event_time);
7243
7244 ok(thread_id == GetCurrentThreadId(), "we didn't ask for events from other threads\n");
7245
7246 /* ignore mouse cursor events */
7247 if (object_id == OBJID_CURSOR) return;
7248
7249 if (!hwnd || is_our_logged_class(hwnd))
7250 {
7251 struct message msg;
7252
7253 msg.message = event;
7254 msg.flags = winevent_hook|wparam|lparam;
7255 msg.wParam = object_id;
7256 msg.lParam = child_id;
7257 add_message(&msg);
7258 }
7259 }
7260
7261 static const WCHAR wszUnicode[] = {'U','n','i','c','o','d','e',0};
7262 static const WCHAR wszAnsi[] = {'U',0};
7263
7264 static LRESULT CALLBACK MsgConversionProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
7265 {
7266 switch (uMsg)
7267 {
7268 case CB_FINDSTRINGEXACT:
7269 trace("String: %p\n", (LPCWSTR)lParam);
7270 if (!lstrcmpW((LPCWSTR)lParam, wszUnicode))
7271 return 1;
7272 if (!lstrcmpW((LPCWSTR)lParam, wszAnsi))
7273 return 0;
7274 return -1;
7275 }
7276 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
7277 }
7278
7279 static const struct message WmGetTextLengthAfromW[] = {
7280 { WM_GETTEXTLENGTH, sent },
7281 { WM_GETTEXT, sent|optional },
7282 { 0 }
7283 };
7284
7285 static const WCHAR dummy_window_text[] = {'d','u','m','m','y',' ','t','e','x','t',0};
7286
7287 /* dummy window proc for WM_GETTEXTLENGTH test */
7288 static LRESULT CALLBACK get_text_len_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
7289 {
7290 switch(msg)
7291 {
7292 case WM_GETTEXTLENGTH:
7293 return lstrlenW(dummy_window_text) + 37; /* some random length */
7294 case WM_GETTEXT:
7295 lstrcpynW( (LPWSTR)lp, dummy_window_text, wp );
7296 return lstrlenW( (LPWSTR)lp );
7297 default:
7298 return DefWindowProcW( hwnd, msg, wp, lp );
7299 }
7300 }
7301
7302 static void test_message_conversion(void)
7303 {
7304 static const WCHAR wszMsgConversionClass[] =
7305 {'M','s','g','C','o','n','v','e','r','s','i','o','n','C','l','a','s','s',0};
7306 WNDCLASSW cls;
7307 LRESULT lRes;
7308 HWND hwnd;
7309 WNDPROC wndproc, newproc;
7310 BOOL ret;
7311
7312 cls.style = 0;
7313 cls.lpfnWndProc = MsgConversionProcW;
7314 cls.cbClsExtra = 0;
7315 cls.cbWndExtra = 0;
7316 cls.hInstance = GetModuleHandleW(NULL);
7317 cls.hIcon = NULL;
7318 cls.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
7319 cls.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
7320 cls.lpszMenuName = NULL;
7321 cls.lpszClassName = wszMsgConversionClass;
7322 /* this call will fail on Win9x, but that doesn't matter as this test is
7323 * meaningless on those platforms */
7324 if(!RegisterClassW(&cls)) return;
7325
7326 hwnd = CreateWindowExW(0, wszMsgConversionClass, NULL, WS_OVERLAPPED,
7327 100, 100, 200, 200, 0, 0, 0, NULL);
7328 ok(hwnd != NULL, "Window creation failed\n");
7329
7330 /* {W, A} -> A */
7331
7332 wndproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
7333 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7334 ok(lRes == 0, "String should have been converted\n");
7335 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7336 ok(lRes == 1, "String shouldn't have been converted\n");
7337
7338 /* {W, A} -> W */
7339
7340 wndproc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
7341 lRes = CallWindowProcA(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7342 ok(lRes == 1, "String shouldn't have been converted\n");
7343 lRes = CallWindowProcW(wndproc, hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7344 ok(lRes == 1, "String shouldn't have been converted\n");
7345
7346 /* Synchronous messages */
7347
7348 lRes = SendMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7349 ok(lRes == 0, "String should have been converted\n");
7350 lRes = SendMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7351 ok(lRes == 1, "String shouldn't have been converted\n");
7352
7353 /* Asynchronous messages */
7354
7355 SetLastError(0);
7356 lRes = PostMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7357 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7358 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7359 SetLastError(0);
7360 lRes = PostMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7361 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7362 "PostMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7363 SetLastError(0);
7364 lRes = PostThreadMessageA(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7365 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7366 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7367 SetLastError(0);
7368 lRes = PostThreadMessageW(GetCurrentThreadId(), CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7369 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7370 "PosThreadtMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7371 SetLastError(0);
7372 lRes = SendNotifyMessageA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7373 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7374 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7375 SetLastError(0);
7376 lRes = SendNotifyMessageW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode);
7377 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7378 "SendNotifyMessage on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7379 SetLastError(0);
7380 lRes = SendMessageCallbackA(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
7381 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7382 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7383 SetLastError(0);
7384 lRes = SendMessageCallbackW(hwnd, CB_FINDSTRINGEXACT, 0, (LPARAM)wszUnicode, NULL, 0);
7385 ok(lRes == 0 && (GetLastError() == ERROR_MESSAGE_SYNC_ONLY || GetLastError() == ERROR_INVALID_PARAMETER),
7386 "SendMessageCallback on sync only message returned %ld, last error %d\n", lRes, GetLastError());
7387
7388 /* Check WM_GETTEXTLENGTH A->W behaviour, whether WM_GETTEXT is also sent or not */
7389
7390 hwnd = CreateWindowW (testWindowClassW, wszUnicode,
7391 WS_OVERLAPPEDWINDOW,
7392 100, 100, 200, 200, 0, 0, 0, NULL);
7393 assert(hwnd);
7394 flush_sequence();
7395 lRes = SendMessageA (hwnd, WM_GETTEXTLENGTH, 0, 0);
7396 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
7397 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
7398 "got bad length %ld\n", lRes );
7399
7400 flush_sequence();
7401 lRes = CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ),
7402 hwnd, WM_GETTEXTLENGTH, 0, 0);
7403 ok_sequence(WmGetTextLengthAfromW, "ANSI WM_GETTEXTLENGTH to Unicode window", FALSE);
7404 ok( lRes == WideCharToMultiByte( CP_ACP, 0, wszUnicode, lstrlenW(wszUnicode), NULL, 0, NULL, NULL ),
7405 "got bad length %ld\n", lRes );
7406
7407 wndproc = (WNDPROC)SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)get_text_len_proc );
7408 newproc = (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC );
7409 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
7410 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
7411 NULL, 0, NULL, NULL ) ||
7412 broken(lRes == lstrlenW(dummy_window_text) + 37),
7413 "got bad length %ld\n", lRes );
7414
7415 SetWindowLongPtrW( hwnd, GWLP_WNDPROC, (LONG_PTR)wndproc ); /* restore old wnd proc */
7416 lRes = CallWindowProcA( newproc, hwnd, WM_GETTEXTLENGTH, 0, 0 );
7417 ok( lRes == WideCharToMultiByte( CP_ACP, 0, dummy_window_text, lstrlenW(dummy_window_text),
7418 NULL, 0, NULL, NULL ) ||
7419 broken(lRes == lstrlenW(dummy_window_text) + 37),
7420 "got bad length %ld\n", lRes );
7421
7422 ret = DestroyWindow(hwnd);
7423 ok( ret, "DestroyWindow() error %d\n", GetLastError());
7424 }
7425
7426 struct timer_info
7427 {
7428 HWND hWnd;
7429 HANDLE handles[2];
7430 DWORD id;
7431 };
7432
7433 static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
7434 {
7435 }
7436
7437 #define TIMER_ID 0x19
7438
7439 static DWORD WINAPI timer_thread_proc(LPVOID x)
7440 {
7441 struct timer_info *info = x;
7442 DWORD r;
7443
7444 r = KillTimer(info->hWnd, 0x19);
7445 ok(r,"KillTimer failed in thread\n");
7446 r = SetTimer(info->hWnd,TIMER_ID,10000,tfunc);
7447 ok(r,"SetTimer failed in thread\n");
7448 ok(r==TIMER_ID,"SetTimer id different\n");
7449 r = SetEvent(info->handles[0]);
7450 ok(r,"SetEvent failed in thread\n");
7451 return 0;
7452 }
7453
7454 static void test_timers(void)
7455 {
7456 struct timer_info info;
7457 DWORD id;
7458
7459 info.hWnd = CreateWindow ("TestWindowClass", NULL,
7460 WS_OVERLAPPEDWINDOW ,
7461 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
7462 NULL, NULL, 0);
7463
7464 info.id = SetTimer(info.hWnd,TIMER_ID,10000,tfunc);
7465 ok(info.id, "SetTimer failed\n");
7466 ok(info.id==TIMER_ID, "SetTimer timer ID different\n");
7467 info.handles[0] = CreateEvent(NULL,0,0,NULL);
7468 info.handles[1] = CreateThread(NULL,0,timer_thread_proc,&info,0,&id);
7469
7470 WaitForMultipleObjects(2, info.handles, FALSE, INFINITE);
7471
7472 WaitForSingleObject(info.handles[1], INFINITE);
7473
7474 CloseHandle(info.handles[0]);
7475 CloseHandle(info.handles[1]);
7476
7477 ok( KillTimer(info.hWnd, TIMER_ID), "KillTimer failed\n");
7478
7479 ok(DestroyWindow(info.hWnd), "failed to destroy window\n");
7480 }
7481
7482 static int count = 0;
7483 static VOID CALLBACK callback_count(
7484 HWND hwnd,
7485 UINT uMsg,
7486 UINT_PTR idEvent,
7487 DWORD dwTime
7488 )
7489 {
7490 count++;
7491 }
7492
7493 static void test_timers_no_wnd(void)
7494 {
7495 UINT_PTR id, id2;
7496 MSG msg;
7497
7498 count = 0;
7499 id = SetTimer(NULL, 0, 100, callback_count);
7500 ok(id != 0, "did not get id from SetTimer.\n");
7501 id2 = SetTimer(NULL, id, 200, callback_count);
7502 ok(id2 == id, "did not get same id from SetTimer when replacing (%li expected %li).\n", id2, id);
7503 Sleep(150);
7504 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
7505 ok(count == 0, "did not get zero count as expected (%i).\n", count);
7506 Sleep(150);
7507 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
7508 ok(count == 1, "did not get one count as expected (%i).\n", count);
7509 KillTimer(NULL, id);
7510 Sleep(250);
7511 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
7512 ok(count == 1, "killing replaced timer did not work (%i).\n", count);
7513 }
7514
7515 /* Various win events with arbitrary parameters */
7516 static const struct message WmWinEventsSeq[] = {
7517 { EVENT_SYSTEM_SOUND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
7518 { EVENT_SYSTEM_ALERT, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7519 { EVENT_SYSTEM_FOREGROUND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
7520 { EVENT_SYSTEM_MENUSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
7521 { EVENT_SYSTEM_MENUEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
7522 { EVENT_SYSTEM_MENUPOPUPSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
7523 { EVENT_SYSTEM_MENUPOPUPEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
7524 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
7525 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
7526 /* our win event hook ignores OBJID_CURSOR events */
7527 /*{ EVENT_SYSTEM_MOVESIZESTART, winevent_hook|wparam|lparam, OBJID_CURSOR, 9 },*/
7528 { EVENT_SYSTEM_MOVESIZEEND, winevent_hook|wparam|lparam, OBJID_ALERT, 10 },
7529 { EVENT_SYSTEM_CONTEXTHELPSTART, winevent_hook|wparam|lparam, OBJID_SOUND, 11 },
7530 { EVENT_SYSTEM_CONTEXTHELPEND, winevent_hook|wparam|lparam, OBJID_QUERYCLASSNAMEIDX, 12 },
7531 { EVENT_SYSTEM_DRAGDROPSTART, winevent_hook|wparam|lparam, OBJID_NATIVEOM, 13 },
7532 { EVENT_SYSTEM_DRAGDROPEND, winevent_hook|wparam|lparam, OBJID_WINDOW, 0 },
7533 { EVENT_SYSTEM_DIALOGSTART, winevent_hook|wparam|lparam, OBJID_SYSMENU, 1 },
7534 { EVENT_SYSTEM_DIALOGEND, winevent_hook|wparam|lparam, OBJID_TITLEBAR, 2 },
7535 { EVENT_SYSTEM_SCROLLINGSTART, winevent_hook|wparam|lparam, OBJID_MENU, 3 },
7536 { EVENT_SYSTEM_SCROLLINGEND, winevent_hook|wparam|lparam, OBJID_CLIENT, 4 },
7537 { EVENT_SYSTEM_SWITCHSTART, winevent_hook|wparam|lparam, OBJID_VSCROLL, 5 },
7538 { EVENT_SYSTEM_SWITCHEND, winevent_hook|wparam|lparam, OBJID_HSCROLL, 6 },
7539 { EVENT_SYSTEM_MINIMIZESTART, winevent_hook|wparam|lparam, OBJID_SIZEGRIP, 7 },
7540 { EVENT_SYSTEM_MINIMIZEEND, winevent_hook|wparam|lparam, OBJID_CARET, 8 },
7541 { 0 }
7542 };
7543 static const struct message WmWinEventCaretSeq[] = {
7544 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
7545 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
7546 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 2 */
7547 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1 */
7548 { 0 }
7549 };
7550 static const struct message WmWinEventCaretSeq_2[] = {
7551 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
7552 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
7553 { EVENT_OBJECT_NAMECHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 }, /* hook 1/2 */
7554 { 0 }
7555 };
7556 static const struct message WmWinEventAlertSeq[] = {
7557 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 0 },
7558 { 0 }
7559 };
7560 static const struct message WmWinEventAlertSeq_2[] = {
7561 /* create window in the thread proc */
7562 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_WINDOW, 2 },
7563 /* our test event */
7564 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_ALERT, 2 },
7565 { 0 }
7566 };
7567 static const struct message WmGlobalHookSeq_1[] = {
7568 /* create window in the thread proc */
7569 { HCBT_CREATEWND, hook|lparam, 0, 2 },
7570 /* our test events */
7571 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 },
7572 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 },
7573 { 0 }
7574 };
7575 static const struct message WmGlobalHookSeq_2[] = {
7576 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 0 }, /* old local hook */
7577 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_NEXTWINDOW, 2 }, /* new global hook */
7578 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 0 }, /* old local hook */
7579 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_PREVWINDOW, 2 }, /* new global hook */
7580 { 0 }
7581 };
7582
7583 static const struct message WmMouseLLHookSeq[] = {
7584 { WM_MOUSEMOVE, hook },
7585 { WM_LBUTTONUP, hook },
7586 { WM_MOUSEMOVE, hook },
7587 { 0 }
7588 };
7589
7590 static void CALLBACK win_event_global_hook_proc(HWINEVENTHOOK hevent,
7591 DWORD event,
7592 HWND hwnd,
7593 LONG object_id,
7594 LONG child_id,
7595 DWORD thread_id,
7596 DWORD event_time)
7597 {
7598 char buf[256];
7599
7600 trace("WEH_2:%p,event %08x,hwnd %p,obj %08x,id %08x,thread %08x,time %08x\n",
7601 hevent, event, hwnd, object_id, child_id, thread_id, event_time);
7602
7603 if (GetClassNameA(hwnd, buf, sizeof(buf)))
7604 {
7605 if (!lstrcmpiA(buf, "TestWindowClass") ||
7606 !lstrcmpiA(buf, "static"))
7607 {
7608 struct message msg;
7609
7610 msg.message = event;
7611 msg.flags = winevent_hook|wparam|lparam;
7612 msg.wParam = object_id;
7613 msg.lParam = (thread_id == GetCurrentThreadId()) ? child_id : (child_id + 2);
7614 add_message(&msg);
7615 }
7616 }
7617 }
7618
7619 static HHOOK hCBT_global_hook;
7620 static DWORD cbt_global_hook_thread_id;
7621
7622 static LRESULT CALLBACK cbt_global_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
7623 {
7624 HWND hwnd;
7625 char buf[256];
7626
7627 trace("CBT_2: %d, %08lx, %08lx\n", nCode, wParam, lParam);
7628
7629 if (nCode == HCBT_SYSCOMMAND)
7630 {
7631 struct message msg;
7632
7633 msg.message = nCode;
7634 msg.flags = hook|wparam|lparam;
7635 msg.wParam = wParam;
7636 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
7637 add_message(&msg);
7638
7639 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
7640 }
7641 /* WH_MOUSE_LL hook */
7642 if (nCode == HC_ACTION)
7643 {
7644 MSLLHOOKSTRUCT *mhll = (MSLLHOOKSTRUCT *)lParam;
7645
7646 /* we can't test for real mouse events */
7647 if (mhll->flags & LLMHF_INJECTED)
7648 {
7649 struct message msg;
7650
7651 memset (&msg, 0, sizeof (msg));
7652 msg.message = wParam;
7653 msg.flags = hook;
7654 add_message(&msg);
7655 }
7656 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
7657 }
7658
7659 /* Log also SetFocus(0) calls */
7660 hwnd = wParam ? (HWND)wParam : (HWND)lParam;
7661
7662 if (GetClassNameA(hwnd, buf, sizeof(buf)))
7663 {
7664 if (!lstrcmpiA(buf, "TestWindowClass") ||
7665 !lstrcmpiA(buf, "static"))
7666 {
7667 struct message msg;
7668
7669 msg.message = nCode;
7670 msg.flags = hook|wparam|lparam;
7671 msg.wParam = wParam;
7672 msg.lParam = (cbt_global_hook_thread_id == GetCurrentThreadId()) ? 1 : 2;
7673 add_message(&msg);
7674 }
7675 }
7676 return CallNextHookEx(hCBT_global_hook, nCode, wParam, lParam);
7677 }
7678
7679 static DWORD WINAPI win_event_global_thread_proc(void *param)
7680 {
7681 HWND hwnd;
7682 MSG msg;
7683 HANDLE hevent = *(HANDLE *)param;
7684
7685 assert(pNotifyWinEvent);
7686
7687 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7688 assert(hwnd);
7689 trace("created thread window %p\n", hwnd);
7690
7691 *(HWND *)param = hwnd;
7692
7693 flush_sequence();
7694 /* this event should be received only by our new hook proc,
7695 * an old one does not expect an event from another thread.
7696 */
7697 pNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_ALERT, 0);
7698 SetEvent(hevent);
7699
7700 while (GetMessage(&msg, 0, 0, 0))
7701 {
7702 TranslateMessage(&msg);
7703 DispatchMessage(&msg);
7704 }
7705 return 0;
7706 }
7707
7708 static DWORD WINAPI cbt_global_hook_thread_proc(void *param)
7709 {
7710 HWND hwnd;
7711 MSG msg;
7712 HANDLE hevent = *(HANDLE *)param;
7713
7714 flush_sequence();
7715 /* these events should be received only by our new hook proc,
7716 * an old one does not expect an event from another thread.
7717 */
7718
7719 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7720 assert(hwnd);
7721 trace("created thread window %p\n", hwnd);
7722
7723 *(HWND *)param = hwnd;
7724
7725 /* Windows doesn't like when a thread plays games with the focus,
7726 that leads to all kinds of misbehaviours and failures to activate
7727 a window. So, better keep next lines commented out.
7728 SetFocus(0);
7729 SetFocus(hwnd);*/
7730
7731 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
7732 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
7733
7734 SetEvent(hevent);
7735
7736 while (GetMessage(&msg, 0, 0, 0))
7737 {
7738 TranslateMessage(&msg);
7739 DispatchMessage(&msg);
7740 }
7741 return 0;
7742 }
7743
7744 static DWORD WINAPI mouse_ll_global_thread_proc(void *param)
7745 {
7746 HWND hwnd;
7747 MSG msg;
7748 HANDLE hevent = *(HANDLE *)param;
7749
7750 hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0,0,0,0,0,0,0, NULL);
7751 assert(hwnd);
7752 trace("created thread window %p\n", hwnd);
7753
7754 *(HWND *)param = hwnd;
7755
7756 flush_sequence();
7757
7758 /* Windows doesn't like when a thread plays games with the focus,
7759 * that leads to all kinds of misbehaviours and failures to activate
7760 * a window. So, better don't generate a mouse click message below.
7761 */
7762 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
7763 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
7764 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
7765
7766 SetEvent(hevent);
7767 while (GetMessage(&msg, 0, 0, 0))
7768 {
7769 TranslateMessage(&msg);
7770 DispatchMessage(&msg);
7771 }
7772 return 0;
7773 }
7774
7775 static void test_winevents(void)
7776 {
7777 BOOL ret;
7778 MSG msg;
7779 HWND hwnd, hwnd2;
7780 UINT i;
7781 HANDLE hthread, hevent;
7782 DWORD tid;
7783 HWINEVENTHOOK hhook;
7784 const struct message *events = WmWinEventsSeq;
7785
7786 hwnd = CreateWindowExA(0, "TestWindowClass", NULL,
7787 WS_OVERLAPPEDWINDOW,
7788 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
7789 NULL, NULL, 0);
7790 assert(hwnd);
7791
7792 /****** start of global hook test *************/
7793 hCBT_global_hook = SetWindowsHookExA(WH_CBT, cbt_global_hook_proc, GetModuleHandleA(0), 0);
7794 if (!hCBT_global_hook)
7795 {
7796 ok(DestroyWindow(hwnd), "failed to destroy window\n");
7797 skip( "cannot set global hook\n" );
7798 return;
7799 }
7800
7801 hevent = CreateEventA(NULL, 0, 0, NULL);
7802 assert(hevent);
7803 hwnd2 = (HWND)hevent;
7804
7805 hthread = CreateThread(NULL, 0, cbt_global_hook_thread_proc, &hwnd2, 0, &tid);
7806 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7807
7808 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7809
7810 ok_sequence(WmGlobalHookSeq_1, "global hook 1", FALSE);
7811
7812 flush_sequence();
7813 /* this one should be received only by old hook proc */
7814 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0);
7815 /* this one should be received only by old hook proc */
7816 DefWindowProcA(hwnd, WM_SYSCOMMAND, SC_PREVWINDOW, 0);
7817
7818 ok_sequence(WmGlobalHookSeq_2, "global hook 2", FALSE);
7819
7820 ret = UnhookWindowsHookEx(hCBT_global_hook);
7821 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
7822
7823 PostThreadMessageA(tid, WM_QUIT, 0, 0);
7824 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7825 CloseHandle(hthread);
7826 CloseHandle(hevent);
7827 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7828 /****** end of global hook test *************/
7829
7830 if (!pSetWinEventHook || !pNotifyWinEvent || !pUnhookWinEvent)
7831 {
7832 ok(DestroyWindow(hwnd), "failed to destroy window\n");
7833 return;
7834 }
7835
7836 flush_sequence();
7837
7838 if (0)
7839 {
7840 /* this test doesn't pass under Win9x */
7841 /* win2k ignores events with hwnd == 0 */
7842 SetLastError(0xdeadbeef);
7843 pNotifyWinEvent(events[0].message, 0, events[0].wParam, events[0].lParam);
7844 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || /* Win2k */
7845 GetLastError() == 0xdeadbeef, /* Win9x */
7846 "unexpected error %d\n", GetLastError());
7847 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
7848 }
7849
7850 for (i = 0; i < sizeof(WmWinEventsSeq)/sizeof(WmWinEventsSeq[0]); i++)
7851 pNotifyWinEvent(events[i].message, hwnd, events[i].wParam, events[i].lParam);
7852
7853 ok_sequence(WmWinEventsSeq, "notify winevents", FALSE);
7854
7855 /****** start of event filtering test *************/
7856 hhook = (HWINEVENTHOOK)pSetWinEventHook(
7857 EVENT_OBJECT_SHOW, /* 0x8002 */
7858 EVENT_OBJECT_LOCATIONCHANGE, /* 0x800B */
7859 GetModuleHandleA(0), win_event_global_hook_proc,
7860 GetCurrentProcessId(), 0,
7861 WINEVENT_INCONTEXT);
7862 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
7863
7864 hevent = CreateEventA(NULL, 0, 0, NULL);
7865 assert(hevent);
7866 hwnd2 = (HWND)hevent;
7867
7868 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
7869 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7870
7871 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7872
7873 ok_sequence(WmWinEventAlertSeq, "alert winevent", FALSE);
7874
7875 flush_sequence();
7876 /* this one should be received only by old hook proc */
7877 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
7878 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
7879 /* this one should be received only by old hook proc */
7880 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
7881
7882 ok_sequence(WmWinEventCaretSeq, "caret winevent", FALSE);
7883
7884 ret = pUnhookWinEvent(hhook);
7885 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7886
7887 PostThreadMessageA(tid, WM_QUIT, 0, 0);
7888 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7889 CloseHandle(hthread);
7890 CloseHandle(hevent);
7891 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7892 /****** end of event filtering test *************/
7893
7894 /****** start of out of context event test *************/
7895 hhook = (HWINEVENTHOOK)pSetWinEventHook(
7896 EVENT_MIN, EVENT_MAX,
7897 0, win_event_global_hook_proc,
7898 GetCurrentProcessId(), 0,
7899 WINEVENT_OUTOFCONTEXT);
7900 ok(hhook != 0, "SetWinEventHook error %d\n", GetLastError());
7901
7902 hevent = CreateEventA(NULL, 0, 0, NULL);
7903 assert(hevent);
7904 hwnd2 = (HWND)hevent;
7905
7906 flush_sequence();
7907
7908 hthread = CreateThread(NULL, 0, win_event_global_thread_proc, &hwnd2, 0, &tid);
7909 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7910
7911 ok(WaitForSingleObject(hevent, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7912
7913 ok_sequence(WmEmptySeq, "empty notify winevents", FALSE);
7914 /* process pending winevent messages */
7915 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
7916 ok_sequence(WmWinEventAlertSeq_2, "alert winevent for out of context proc", FALSE);
7917
7918 flush_sequence();
7919 /* this one should be received only by old hook proc */
7920 pNotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, 0); /* 0x8000 */
7921 pNotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, 0); /* 0x8002 */
7922 /* this one should be received only by old hook proc */
7923 pNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, hwnd, OBJID_CARET, 0); /* 0x800C */
7924
7925 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for incontext proc", FALSE);
7926 /* process pending winevent messages */
7927 ok(!PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE), "msg queue should be empty\n");
7928 ok_sequence(WmWinEventCaretSeq_2, "caret winevent for out of context proc", FALSE);
7929
7930 ret = pUnhookWinEvent(hhook);
7931 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
7932
7933 PostThreadMessageA(tid, WM_QUIT, 0, 0);
7934 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7935 CloseHandle(hthread);
7936 CloseHandle(hevent);
7937 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7938 /****** end of out of context event test *************/
7939
7940 /****** start of MOUSE_LL hook test *************/
7941 hCBT_global_hook = SetWindowsHookExA(WH_MOUSE_LL, cbt_global_hook_proc, GetModuleHandleA(0), 0);
7942 /* WH_MOUSE_LL is not supported on Win9x platforms */
7943 if (!hCBT_global_hook)
7944 {
7945 trace("Skipping WH_MOUSE_LL test on this platform\n");
7946 goto skip_mouse_ll_hook_test;
7947 }
7948
7949 hevent = CreateEventA(NULL, 0, 0, NULL);
7950 assert(hevent);
7951 hwnd2 = (HWND)hevent;
7952
7953 hthread = CreateThread(NULL, 0, mouse_ll_global_thread_proc, &hwnd2, 0, &tid);
7954 ok(hthread != NULL, "CreateThread failed, error %d\n", GetLastError());
7955
7956 while (WaitForSingleObject(hevent, 100) == WAIT_TIMEOUT)
7957 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
7958
7959 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook other thread", FALSE);
7960 flush_sequence();
7961
7962 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
7963 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
7964 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
7965
7966 ok_sequence(WmMouseLLHookSeq, "MOUSE_LL hook same thread", FALSE);
7967
7968 ret = UnhookWindowsHookEx(hCBT_global_hook);
7969 ok( ret, "UnhookWindowsHookEx error %d\n", GetLastError());
7970
7971 PostThreadMessageA(tid, WM_QUIT, 0, 0);
7972 ok(WaitForSingleObject(hthread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
7973 CloseHandle(hthread);
7974 CloseHandle(hevent);
7975 ok(!IsWindow(hwnd2), "window should be destroyed on thread exit\n");
7976 /****** end of MOUSE_LL hook test *************/
7977 skip_mouse_ll_hook_test:
7978
7979 ok(DestroyWindow(hwnd), "failed to destroy window\n");
7980 }
7981
7982 static void test_set_hook(void)
7983 {
7984 BOOL ret;
7985 HHOOK hhook;
7986 HWINEVENTHOOK hwinevent_hook;
7987
7988 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, GetModuleHandleA(0), GetCurrentThreadId());
7989 ok(hhook != 0, "local hook does not require hModule set to 0\n");
7990 UnhookWindowsHookEx(hhook);
7991
7992 if (0)
7993 {
7994 /* this test doesn't pass under Win9x: BUG! */
7995 SetLastError(0xdeadbeef);
7996 hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, 0);
7997 ok(!hhook, "global hook requires hModule != 0\n");
7998 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD, "unexpected error %d\n", GetLastError());
7999 }
8000
8001 SetLastError(0xdeadbeef);
8002 hhook = SetWindowsHookExA(WH_CBT, 0, GetModuleHandleA(0), GetCurrentThreadId());
8003 ok(!hhook, "SetWinEventHook with invalid proc should fail\n");
8004 ok(GetLastError() == ERROR_INVALID_FILTER_PROC || /* Win2k */
8005 GetLastError() == 0xdeadbeef, /* Win9x */
8006 "unexpected error %d\n", GetLastError());
8007
8008 SetLastError(0xdeadbeef);
8009 ok(!UnhookWindowsHookEx((HHOOK)0xdeadbeef), "UnhookWindowsHookEx succeeded\n");
8010 ok(GetLastError() == ERROR_INVALID_HOOK_HANDLE || /* Win2k */
8011 GetLastError() == 0xdeadbeef, /* Win9x */
8012 "unexpected error %d\n", GetLastError());
8013
8014 if (!pSetWinEventHook || !pUnhookWinEvent) return;
8015
8016 /* even process local incontext hooks require hmodule */
8017 SetLastError(0xdeadbeef);
8018 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
8019 0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_INCONTEXT);
8020 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
8021 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
8022 GetLastError() == 0xdeadbeef, /* Win9x */
8023 "unexpected error %d\n", GetLastError());
8024
8025 /* even thread local incontext hooks require hmodule */
8026 SetLastError(0xdeadbeef);
8027 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
8028 0, win_event_proc, GetCurrentProcessId(), GetCurrentThreadId(), WINEVENT_INCONTEXT);
8029 ok(!hwinevent_hook, "WINEVENT_INCONTEXT requires hModule != 0\n");
8030 ok(GetLastError() == ERROR_HOOK_NEEDS_HMOD || /* Win2k */
8031 GetLastError() == 0xdeadbeef, /* Win9x */
8032 "unexpected error %d\n", GetLastError());
8033
8034 if (0)
8035 {
8036 /* these 3 tests don't pass under Win9x */
8037 SetLastError(0xdeadbeef);
8038 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(1, 0,
8039 0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
8040 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
8041 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
8042
8043 SetLastError(0xdeadbeef);
8044 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(-1, 1,
8045 0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
8046 ok(!hwinevent_hook, "SetWinEventHook with invalid event range should fail\n");
8047 ok(GetLastError() == ERROR_INVALID_HOOK_FILTER, "unexpected error %d\n", GetLastError());
8048
8049 SetLastError(0xdeadbeef);
8050 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
8051 0, win_event_proc, 0, 0xdeadbeef, WINEVENT_OUTOFCONTEXT);
8052 ok(!hwinevent_hook, "SetWinEventHook with invalid tid should fail\n");
8053 ok(GetLastError() == ERROR_INVALID_THREAD_ID, "unexpected error %d\n", GetLastError());
8054 }
8055
8056 SetLastError(0xdeadbeef);
8057 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(0, 0,
8058 0, win_event_proc, GetCurrentProcessId(), 0, WINEVENT_OUTOFCONTEXT);
8059 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
8060 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
8061 ret = pUnhookWinEvent(hwinevent_hook);
8062 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
8063
8064 todo_wine {
8065 /* This call succeeds under win2k SP4, but fails under Wine.
8066 Does win2k test/use passed process id? */
8067 SetLastError(0xdeadbeef);
8068 hwinevent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
8069 0, win_event_proc, 0xdeadbeef, 0, WINEVENT_OUTOFCONTEXT);
8070 ok(hwinevent_hook != 0, "SetWinEventHook error %d\n", GetLastError());
8071 ok(GetLastError() == 0xdeadbeef, "unexpected error %d\n", GetLastError());
8072 ret = pUnhookWinEvent(hwinevent_hook);
8073 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
8074 }
8075
8076 SetLastError(0xdeadbeef);
8077 ok(!pUnhookWinEvent((HWINEVENTHOOK)0xdeadbeef), "UnhookWinEvent succeeded\n");
8078 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
8079 GetLastError() == 0xdeadbeef, /* Win9x */
8080 "unexpected error %d\n", GetLastError());
8081 }
8082
8083 static const struct message ScrollWindowPaint1[] = {
8084 { WM_PAINT, sent },
8085 { WM_ERASEBKGND, sent|beginpaint },
8086 { 0 }
8087 };
8088
8089 static const struct message ScrollWindowPaint2[] = {
8090 { WM_PAINT, sent },
8091 { 0 }
8092 };
8093
8094 static void test_scrollwindowex(void)
8095 {
8096 HWND hwnd, hchild;
8097 RECT rect={0,0,130,130};
8098
8099 hwnd = CreateWindowExA(0, "TestWindowClass", "Test Scroll",
8100 WS_VISIBLE|WS_OVERLAPPEDWINDOW,
8101 100, 100, 200, 200, 0, 0, 0, NULL);
8102 ok (hwnd != 0, "Failed to create overlapped window\n");
8103 hchild = CreateWindowExA(0, "TestWindowClass", "Test child",
8104 WS_VISIBLE|WS_CAPTION|WS_CHILD,
8105 10, 10, 150, 150, hwnd, 0, 0, NULL);
8106 ok (hchild != 0, "Failed to create child\n");
8107 UpdateWindow(hwnd);
8108 flush_events();
8109 flush_sequence();
8110
8111 /* scroll without the child window */
8112 trace("start scroll\n");
8113 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
8114 SW_ERASE|SW_INVALIDATE);
8115 ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
8116 trace("end scroll\n");
8117 flush_sequence();
8118 flush_events();
8119 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
8120 flush_events();
8121 flush_sequence();
8122
8123 /* Now without the SW_ERASE flag */
8124 trace("start scroll\n");
8125 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL, SW_INVALIDATE);
8126 ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
8127 trace("end scroll\n");
8128 flush_sequence();
8129 flush_events();
8130 ok_sequence(ScrollWindowPaint2, "ScrollWindowEx", 0);
8131 flush_events();
8132 flush_sequence();
8133
8134 /* now scroll the child window as well */
8135 trace("start scroll\n");
8136 ScrollWindowEx( hwnd, 10, 10, &rect, NULL, NULL, NULL,
8137 SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
8138 todo_wine { /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
8139 /* windows sometimes a WM_MOVE */
8140 ok_sequence(WmEmptySeq, "ScrollWindowEx", 0);
8141 }
8142 trace("end scroll\n");
8143 flush_sequence();
8144 flush_events();
8145 ok_sequence(ScrollWindowPaint1, "ScrollWindowEx", 0);
8146 flush_events();
8147 flush_sequence();
8148
8149 /* now scroll with ScrollWindow() */
8150 trace("start scroll with ScrollWindow\n");
8151 ScrollWindow( hwnd, 5, 5, NULL, NULL);
8152 trace("end scroll\n");
8153 flush_sequence();
8154 flush_events();
8155 ok_sequence(ScrollWindowPaint1, "ScrollWindow", 0);
8156
8157 ok(DestroyWindow(hchild), "failed to destroy window\n");
8158 ok(DestroyWindow(hwnd), "failed to destroy window\n");
8159 flush_sequence();
8160 }
8161
8162 static const struct message destroy_window_with_children[] = {
8163 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
8164 { HCBT_DESTROYWND, hook|lparam, 0, WND_PARENT_ID }, /* parent */
8165 { 0x0090, sent|optional },
8166 { HCBT_DESTROYWND, hook|lparam, 0, WND_POPUP_ID }, /* popup */
8167 { 0x0090, sent|optional },
8168 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* popup */
8169 { WM_DESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
8170 { WM_CAPTURECHANGED, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
8171 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_POPUP_ID }, /* popup */
8172 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, 0, 0 }, /* parent */
8173 { WM_DESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
8174 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
8175 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
8176 { WM_DESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
8177 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 2 }, /* child2 */
8178 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 3 }, /* child3 */
8179 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_CHILD_ID + 1 }, /* child1 */
8180 { WM_NCDESTROY, sent|wparam|lparam, 0, WND_PARENT_ID }, /* parent */
8181 { 0 }
8182 };
8183
8184 static void test_DestroyWindow(void)
8185 {
8186 BOOL ret;
8187 HWND parent, child1, child2, child3, child4, test;
8188 UINT child_id = WND_CHILD_ID + 1;
8189
8190 parent = CreateWindowExA(0, "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8191 100, 100, 200, 200, 0, 0, 0, NULL);
8192 assert(parent != 0);
8193 child1 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
8194 0, 0, 50, 50, parent, (HMENU)child_id++, 0, NULL);
8195 assert(child1 != 0);
8196 child2 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
8197 0, 0, 50, 50, GetDesktopWindow(), (HMENU)child_id++, 0, NULL);
8198 assert(child2 != 0);
8199 child3 = CreateWindowExA(0, "TestWindowClass", NULL, WS_CHILD,
8200 0, 0, 50, 50, child1, (HMENU)child_id++, 0, NULL);
8201 assert(child3 != 0);
8202 child4 = CreateWindowExA(0, "TestWindowClass", NULL, WS_POPUP,
8203 0, 0, 50, 50, parent, 0, 0, NULL);
8204 assert(child4 != 0);
8205
8206 /* test owner/parent of child2 */
8207 test = GetParent(child2);
8208 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8209 ok(!IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
8210 if(pGetAncestor) {
8211 test = pGetAncestor(child2, GA_PARENT);
8212 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8213 }
8214 test = GetWindow(child2, GW_OWNER);
8215 ok(!test, "wrong owner %p\n", test);
8216
8217 test = SetParent(child2, parent);
8218 ok(test == GetDesktopWindow(), "wrong old parent %p\n", test);
8219
8220 /* test owner/parent of the parent */
8221 test = GetParent(parent);
8222 ok(!test, "wrong parent %p\n", test);
8223 ok(!IsChild(GetDesktopWindow(), parent), "wrong parent/child %p/%p\n", GetDesktopWindow(), parent);
8224 if(pGetAncestor) {
8225 test = pGetAncestor(parent, GA_PARENT);
8226 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8227 }
8228 test = GetWindow(parent, GW_OWNER);
8229 ok(!test, "wrong owner %p\n", test);
8230
8231 /* test owner/parent of child1 */
8232 test = GetParent(child1);
8233 ok(test == parent, "wrong parent %p\n", test);
8234 ok(IsChild(parent, child1), "wrong parent/child %p/%p\n", parent, child1);
8235 if(pGetAncestor) {
8236 test = pGetAncestor(child1, GA_PARENT);
8237 ok(test == parent, "wrong parent %p\n", test);
8238 }
8239 test = GetWindow(child1, GW_OWNER);
8240 ok(!test, "wrong owner %p\n", test);
8241
8242 /* test owner/parent of child2 */
8243 test = GetParent(child2);
8244 ok(test == parent, "wrong parent %p\n", test);
8245 ok(IsChild(parent, child2), "wrong parent/child %p/%p\n", parent, child2);
8246 if(pGetAncestor) {
8247 test = pGetAncestor(child2, GA_PARENT);
8248 ok(test == parent, "wrong parent %p\n", test);
8249 }
8250 test = GetWindow(child2, GW_OWNER);
8251 ok(!test, "wrong owner %p\n", test);
8252
8253 /* test owner/parent of child3 */
8254 test = GetParent(child3);
8255 ok(test == child1, "wrong parent %p\n", test);
8256 ok(IsChild(parent, child3), "wrong parent/child %p/%p\n", parent, child3);
8257 if(pGetAncestor) {
8258 test = pGetAncestor(child3, GA_PARENT);
8259 ok(test == child1, "wrong parent %p\n", test);
8260 }
8261 test = GetWindow(child3, GW_OWNER);
8262 ok(!test, "wrong owner %p\n", test);
8263
8264 /* test owner/parent of child4 */
8265 test = GetParent(child4);
8266 ok(test == parent, "wrong parent %p\n", test);
8267 ok(!IsChild(parent, child4), "wrong parent/child %p/%p\n", parent, child4);
8268 if(pGetAncestor) {
8269 test = pGetAncestor(child4, GA_PARENT);
8270 ok(test == GetDesktopWindow(), "wrong parent %p\n", test);
8271 }
8272 test = GetWindow(child4, GW_OWNER);
8273 ok(test == parent, "wrong owner %p\n", test);
8274
8275 flush_sequence();
8276
8277 trace("parent %p, child1 %p, child2 %p, child3 %p, child4 %p\n",
8278 parent, child1, child2, child3, child4);
8279
8280 SetCapture(child4);
8281 test = GetCapture();
8282 ok(test == child4, "wrong capture window %p\n", test);
8283
8284 test_DestroyWindow_flag = TRUE;
8285 ret = DestroyWindow(parent);
8286 ok( ret, "DestroyWindow() error %d\n", GetLastError());
8287 test_DestroyWindow_flag = FALSE;
8288 ok_sequence(destroy_window_with_children, "destroy window with children", 0);
8289
8290 ok(!IsWindow(parent), "parent still exists\n");
8291 ok(!IsWindow(child1), "child1 still exists\n");
8292 ok(!IsWindow(child2), "child2 still exists\n");
8293 ok(!IsWindow(child3), "child3 still exists\n");
8294 ok(!IsWindow(child4), "child4 still exists\n");
8295
8296 test = GetCapture();
8297 ok(!test, "wrong capture window %p\n", test);
8298 }
8299
8300
8301 static const struct message WmDispatchPaint[] = {
8302 { WM_NCPAINT, sent },
8303 { WM_GETTEXT, sent|defwinproc|optional },
8304 { WM_GETTEXT, sent|defwinproc|optional },
8305 { WM_ERASEBKGND, sent },
8306 { 0 }
8307 };
8308
8309 static LRESULT WINAPI DispatchMessageCheckProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8310 {
8311 if (message == WM_PAINT) return 0;
8312 return MsgCheckProcA( hwnd, message, wParam, lParam );
8313 }
8314
8315 static void test_DispatchMessage(void)
8316 {
8317 RECT rect;
8318 MSG msg;
8319 int count;
8320 HWND hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8321 100, 100, 200, 200, 0, 0, 0, NULL);
8322 ShowWindow( hwnd, SW_SHOW );
8323 UpdateWindow( hwnd );
8324 flush_events();
8325 flush_sequence();
8326 SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)DispatchMessageCheckProc );
8327
8328 SetRect( &rect, -5, -5, 5, 5 );
8329 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
8330 count = 0;
8331 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
8332 {
8333 if (msg.message != WM_PAINT) DispatchMessage( &msg );
8334 else
8335 {
8336 flush_sequence();
8337 DispatchMessage( &msg );
8338 /* DispatchMessage will send WM_NCPAINT if non client area is still invalid after WM_PAINT */
8339 if (!count) ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
8340 else ok_sequence( WmEmptySeq, "WmEmpty", FALSE );
8341 if (++count > 10) break;
8342 }
8343 }
8344 ok( msg.message == WM_PAINT && count > 10, "WM_PAINT messages stopped\n" );
8345
8346 trace("now without DispatchMessage\n");
8347 flush_sequence();
8348 RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME );
8349 count = 0;
8350 while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
8351 {
8352 if (msg.message != WM_PAINT) DispatchMessage( &msg );
8353 else
8354 {
8355 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
8356 flush_sequence();
8357 /* this will send WM_NCCPAINT just like DispatchMessage does */
8358 GetUpdateRgn( hwnd, hrgn, TRUE );
8359 ok_sequence( WmDispatchPaint, "WmDispatchPaint", FALSE );
8360 DeleteObject( hrgn );
8361 GetClientRect( hwnd, &rect );
8362 ValidateRect( hwnd, &rect ); /* this will stop WM_PAINTs */
8363 ok( !count, "Got multiple WM_PAINTs\n" );
8364 if (++count > 10) break;
8365 }
8366 }
8367 DestroyWindow(hwnd);
8368 }
8369
8370
8371 static const struct message WmUser[] = {
8372 { WM_USER, sent },
8373 { 0 }
8374 };
8375
8376 struct sendmsg_info
8377 {
8378 HWND hwnd;
8379 DWORD timeout;
8380 DWORD ret;
8381 };
8382
8383 static DWORD CALLBACK send_msg_thread( LPVOID arg )
8384 {
8385 struct sendmsg_info *info = arg;
8386 info->ret = SendMessageTimeoutA( info->hwnd, WM_USER, 0, 0, 0, info->timeout, NULL );
8387 if (!info->ret) ok( GetLastError() == ERROR_TIMEOUT, "unexpected error %d\n", GetLastError());
8388 return 0;
8389 }
8390
8391 static void wait_for_thread( HANDLE thread )
8392 {
8393 while (MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, QS_SENDMESSAGE) != WAIT_OBJECT_0)
8394 {
8395 MSG msg;
8396 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage(&msg);
8397 }
8398 }
8399
8400 static LRESULT WINAPI send_msg_delay_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8401 {
8402 if (message == WM_USER) Sleep(200);
8403 return MsgCheckProcA( hwnd, message, wParam, lParam );
8404 }
8405
8406 static void test_SendMessageTimeout(void)
8407 {
8408 HANDLE thread;
8409 struct sendmsg_info info;
8410 DWORD tid;
8411
8412 info.hwnd = CreateWindowA( "TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8413 100, 100, 200, 200, 0, 0, 0, NULL);
8414 flush_events();
8415 flush_sequence();
8416
8417 info.timeout = 1000;
8418 info.ret = 0xdeadbeef;
8419 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8420 wait_for_thread( thread );
8421 CloseHandle( thread );
8422 ok( info.ret == 1, "SendMessageTimeout failed\n" );
8423 ok_sequence( WmUser, "WmUser", FALSE );
8424
8425 info.timeout = 1;
8426 info.ret = 0xdeadbeef;
8427 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8428 Sleep(100); /* SendMessageTimeout should time out here */
8429 wait_for_thread( thread );
8430 CloseHandle( thread );
8431 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
8432 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8433
8434 /* 0 means infinite timeout */
8435 info.timeout = 0;
8436 info.ret = 0xdeadbeef;
8437 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8438 Sleep(100);
8439 wait_for_thread( thread );
8440 CloseHandle( thread );
8441 ok( info.ret == 1, "SendMessageTimeout failed\n" );
8442 ok_sequence( WmUser, "WmUser", FALSE );
8443
8444 /* timeout is treated as signed despite the prototype */
8445 info.timeout = 0x7fffffff;
8446 info.ret = 0xdeadbeef;
8447 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8448 Sleep(100);
8449 wait_for_thread( thread );
8450 CloseHandle( thread );
8451 ok( info.ret == 1, "SendMessageTimeout failed\n" );
8452 ok_sequence( WmUser, "WmUser", FALSE );
8453
8454 info.timeout = 0x80000000;
8455 info.ret = 0xdeadbeef;
8456 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8457 Sleep(100);
8458 wait_for_thread( thread );
8459 CloseHandle( thread );
8460 ok( info.ret == 0, "SendMessageTimeout succeeded\n" );
8461 ok_sequence( WmEmptySeq, "WmEmptySeq", FALSE );
8462
8463 /* now check for timeout during message processing */
8464 SetWindowLongPtrA( info.hwnd, GWLP_WNDPROC, (LONG_PTR)send_msg_delay_proc );
8465 info.timeout = 100;
8466 info.ret = 0xdeadbeef;
8467 thread = CreateThread( NULL, 0, send_msg_thread, &info, 0, &tid );
8468 wait_for_thread( thread );
8469 CloseHandle( thread );
8470 /* we should time out but still get the message */
8471 ok( info.ret == 0, "SendMessageTimeout failed\n" );
8472 ok_sequence( WmUser, "WmUser", FALSE );
8473
8474 DestroyWindow( info.hwnd );
8475 }
8476
8477
8478 /****************** edit message test *************************/
8479 #define ID_EDIT 0x1234
8480 static const struct message sl_edit_setfocus[] =
8481 {
8482 { HCBT_SETFOCUS, hook },
8483 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
8484 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8485 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8486 { WM_SETFOCUS, sent|wparam, 0 },
8487 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8488 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 15 },
8489 { WM_CTLCOLOREDIT, sent|parent },
8490 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8491 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8492 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8493 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8494 { 0 }
8495 };
8496 static const struct message ml_edit_setfocus[] =
8497 {
8498 { HCBT_SETFOCUS, hook },
8499 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
8500 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8501 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8502 { WM_SETFOCUS, sent|wparam, 0 },
8503 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8504 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8505 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8506 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8507 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8508 { 0 }
8509 };
8510 static const struct message sl_edit_killfocus[] =
8511 {
8512 { HCBT_SETFOCUS, hook },
8513 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8514 { WM_KILLFOCUS, sent|wparam, 0 },
8515 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8516 { EVENT_OBJECT_DESTROY, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8517 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_KILLFOCUS) },
8518 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
8519 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
8520 { 0 }
8521 };
8522 static const struct message sl_edit_lbutton_dblclk[] =
8523 {
8524 { WM_LBUTTONDBLCLK, sent },
8525 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
8526 { 0 }
8527 };
8528 static const struct message sl_edit_lbutton_down[] =
8529 {
8530 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
8531 { HCBT_SETFOCUS, hook },
8532 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
8533 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8534 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8535 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
8536 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8537 { WM_CTLCOLOREDIT, sent|parent },
8538 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8539 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8540 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8541 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8542 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8543 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
8544 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8545 { WM_CTLCOLOREDIT, sent|parent|optional },
8546 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8547 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8548 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8549 { 0 }
8550 };
8551 static const struct message ml_edit_lbutton_down[] =
8552 {
8553 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
8554 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
8555 { HCBT_SETFOCUS, hook },
8556 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
8557 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
8558 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
8559 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
8560 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
8561 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
8562 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8563 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8564 { WM_COMMAND, sent|parent|wparam, MAKEWPARAM(ID_EDIT, EN_SETFOCUS) },
8565 { 0 }
8566 };
8567 static const struct message sl_edit_lbutton_up[] =
8568 {
8569 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
8570 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8571 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
8572 { WM_CAPTURECHANGED, sent|defwinproc },
8573 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
8574 { 0 }
8575 };
8576 static const struct message ml_edit_lbutton_up[] =
8577 {
8578 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
8579 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
8580 { WM_CAPTURECHANGED, sent|defwinproc },
8581 { 0 }
8582 };
8583
8584 static WNDPROC old_edit_proc;
8585
8586 static LRESULT CALLBACK edit_hook_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
8587 {
8588 static long defwndproc_counter = 0;
8589 LRESULT ret;
8590 struct message msg;
8591
8592 trace("edit: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
8593
8594 /* explicitly ignore WM_GETICON message */
8595 if (message == WM_GETICON) return 0;
8596
8597 msg.message = message;
8598 msg.flags = sent|wparam|lparam;
8599 if (defwndproc_counter) msg.flags |= defwinproc;
8600 msg.wParam = wParam;
8601 msg.lParam = lParam;
8602 add_message(&msg);
8603
8604 defwndproc_counter++;
8605 ret = CallWindowProcA(old_edit_proc, hwnd, message, wParam, lParam);
8606 defwndproc_counter--;
8607
8608 return ret;
8609 }
8610
8611 static void subclass_edit(void)
8612 {
8613 WNDCLASSA cls;
8614
8615 if (!GetClassInfoA(0, "edit", &cls)) assert(0);
8616
8617 old_edit_proc = cls.lpfnWndProc;
8618
8619 cls.hInstance = GetModuleHandle(0);
8620 cls.lpfnWndProc = edit_hook_proc;
8621 cls.lpszClassName = "my_edit_class";
8622 UnregisterClass(cls.lpszClassName, cls.hInstance);
8623 if (!RegisterClassA(&cls)) assert(0);
8624 }
8625
8626 static void test_edit_messages(void)
8627 {
8628 HWND hwnd, parent;
8629 DWORD dlg_code;
8630
8631 subclass_edit();
8632 log_all_parent_messages++;
8633
8634 parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
8635 100, 100, 200, 200, 0, 0, 0, NULL);
8636 ok (parent != 0, "Failed to create parent window\n");
8637
8638 /* test single line edit */
8639 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD,
8640 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
8641 ok(hwnd != 0, "Failed to create edit window\n");
8642
8643 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
8644 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS), "wrong dlg_code %08x\n", dlg_code);
8645
8646 ShowWindow(hwnd, SW_SHOW);
8647 UpdateWindow(hwnd);
8648 SetFocus(0);
8649 flush_sequence();
8650
8651 SetFocus(hwnd);
8652 ok_sequence(sl_edit_setfocus, "SetFocus(hwnd) on an edit", FALSE);
8653
8654 SetFocus(0);
8655 ok_sequence(sl_edit_killfocus, "SetFocus(0) on an edit", FALSE);
8656
8657 SetFocus(0);
8658 ReleaseCapture();
8659 flush_sequence();
8660
8661 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
8662 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on an edit", FALSE);
8663
8664 SetFocus(0);
8665 ReleaseCapture();
8666 flush_sequence();
8667
8668 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
8669 ok_sequence(sl_edit_lbutton_down, "WM_LBUTTONDOWN on an edit", FALSE);
8670
8671 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
8672 ok_sequence(sl_edit_lbutton_up, "WM_LBUTTONUP on an edit", FALSE);
8673
8674 DestroyWindow(hwnd);
8675
8676 /* test multiline edit */
8677 hwnd = CreateWindowExA(0, "my_edit_class", "test", WS_CHILD | ES_MULTILINE,
8678 0, 0, 80, 20, parent, (HMENU)ID_EDIT, 0, NULL);
8679 ok(hwnd != 0, "Failed to create edit window\n");
8680
8681 dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
8682 ok(dlg_code == (DLGC_WANTCHARS|DLGC_HASSETSEL|DLGC_WANTARROWS|DLGC_WANTALLKEYS),
8683 "wrong dlg_code %08x\n", dlg_code);
8684
8685 ShowWindow(hwnd, SW_SHOW);
8686 UpdateWindow(hwnd);
8687 SetFocus(0);
8688 flush_sequence();
8689
8690 SetFocus(hwnd);
8691 ok_sequence(ml_edit_setfocus, "SetFocus(hwnd) on multiline edit", FALSE);
8692
8693 SetFocus(0);
8694 ok_sequence(sl_edit_killfocus, "SetFocus(0) on multiline edit", FALSE);
8695
8696 SetFocus(0);
8697 ReleaseCapture();
8698 flush_sequence();
8699
8700 SendMessageA(hwnd, WM_LBUTTONDBLCLK, 0, 0);
8701 ok_sequence(sl_edit_lbutton_dblclk, "WM_LBUTTONDBLCLK on multiline edit", FALSE);
8702
8703 SetFocus(0);
8704 ReleaseCapture();
8705 flush_sequence();
8706
8707 SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
8708 ok_sequence(ml_edit_lbutton_down, "WM_LBUTTONDOWN on multiline edit", FALSE);
8709
8710 SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
8711 ok_sequence(ml_edit_lbutton_up, "WM_LBUTTONUP on multiline edit", FALSE);
8712
8713 DestroyWindow(hwnd);
8714 DestroyWindow(parent);
8715
8716 log_all_parent_messages--;
8717 }
8718
8719 /**************************** End of Edit test ******************************/
8720
8721 static const struct message WmKeyDownSkippedSeq[] =
8722 {
8723 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 1 }, /* XP */
8724 { 0 }
8725 };
8726 static const struct message WmKeyUpSkippedSeq[] =
8727 {
8728 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'N', 0xc0000001 }, /* XP */
8729 { 0 }
8730 };
8731
8732 #define EV_STOP 0
8733 #define EV_SENDMSG 1
8734 #define EV_ACK 2
8735
8736 struct peekmsg_info
8737 {
8738 HWND hwnd;
8739 HANDLE hevent[3]; /* 0 - start/stop, 1 - SendMessage, 2 - ack */
8740 };
8741
8742 static DWORD CALLBACK send_msg_thread_2(void *param)
8743 {
8744 DWORD ret;
8745 struct peekmsg_info *info = param;
8746
8747 trace("thread: looping\n");
8748 SetEvent(info->hevent[EV_ACK]);
8749
8750 while (1)
8751 {
8752 ret = WaitForMultipleObjects(2, info->hevent, FALSE, INFINITE);
8753
8754 switch (ret)
8755 {
8756 case WAIT_OBJECT_0 + EV_STOP:
8757 trace("thread: exiting\n");
8758 return 0;
8759
8760 case WAIT_OBJECT_0 + EV_SENDMSG:
8761 trace("thread: sending message\n");
8762 ok( SendNotifyMessageA(info->hwnd, WM_USER, 0, 0),
8763 "SendNotifyMessageA failed error %u\n", GetLastError());
8764 SetEvent(info->hevent[EV_ACK]);
8765 break;
8766
8767 default:
8768 trace("unexpected return: %04x\n", ret);
8769 assert(0);
8770 break;
8771 }
8772 }
8773 return 0;
8774 }
8775
8776 static void test_PeekMessage(void)
8777 {
8778 MSG msg;
8779 HANDLE hthread;
8780 DWORD tid, qstatus;
8781 UINT qs_all_input = QS_ALLINPUT;
8782 UINT qs_input = QS_INPUT;
8783 BOOL ret;
8784 struct peekmsg_info info;
8785
8786 info.hwnd = CreateWindowA("TestWindowClass", NULL, WS_OVERLAPPEDWINDOW,
8787 100, 100, 200, 200, 0, 0, 0, NULL);
8788 assert(info.hwnd);
8789 ShowWindow(info.hwnd, SW_SHOW);
8790 UpdateWindow(info.hwnd);
8791 SetFocus(info.hwnd);
8792
8793 info.hevent[EV_STOP] = CreateEventA(NULL, 0, 0, NULL);
8794 info.hevent[EV_SENDMSG] = CreateEventA(NULL, 0, 0, NULL);
8795 info.hevent[EV_ACK] = CreateEventA(NULL, 0, 0, NULL);
8796
8797 hthread = CreateThread(NULL, 0, send_msg_thread_2, &info, 0, &tid);
8798 WaitForSingleObject(info.hevent[EV_ACK], 10000);
8799
8800 flush_events();
8801 flush_sequence();
8802
8803 SetLastError(0xdeadbeef);
8804 qstatus = GetQueueStatus(qs_all_input);
8805 if (GetLastError() == ERROR_INVALID_FLAGS)
8806 {
8807 trace("QS_RAWINPUT not supported on this platform\n");
8808 qs_all_input &= ~QS_RAWINPUT;
8809 qs_input &= ~QS_RAWINPUT;
8810 }
8811 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
8812
8813 trace("signalling to send message\n");
8814 SetEvent(info.hevent[EV_SENDMSG]);
8815 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8816
8817 /* pass invalid QS_xxxx flags */
8818 SetLastError(0xdeadbeef);
8819 qstatus = GetQueueStatus(0xffffffff);
8820 ok(qstatus == 0, "GetQueueStatus should fail: %08x\n", qstatus);
8821 ok(GetLastError() == ERROR_INVALID_FLAGS, "wrong error %d\n", GetLastError());
8822
8823 qstatus = GetQueueStatus(qs_all_input);
8824 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE),
8825 "wrong qstatus %08x\n", qstatus);
8826
8827 msg.message = 0;
8828 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
8829 ok(!ret,
8830 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8831 msg.message);
8832 ok_sequence(WmUser, "WmUser", FALSE);
8833
8834 qstatus = GetQueueStatus(qs_all_input);
8835 ok(qstatus == 0, "wrong qstatus %08x\n", qstatus);
8836
8837 keybd_event('N', 0, 0, 0);
8838 keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
8839 qstatus = GetQueueStatus(qs_all_input);
8840 ok(qstatus == MAKELONG(QS_KEY, QS_KEY),
8841 "wrong qstatus %08x\n", qstatus);
8842
8843 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8844 qstatus = GetQueueStatus(qs_all_input);
8845 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
8846 "wrong qstatus %08x\n", qstatus);
8847
8848 InvalidateRect(info.hwnd, NULL, FALSE);
8849 qstatus = GetQueueStatus(qs_all_input);
8850 ok(qstatus == MAKELONG(QS_PAINT, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8851 "wrong qstatus %08x\n", qstatus);
8852
8853 trace("signalling to send message\n");
8854 SetEvent(info.hevent[EV_SENDMSG]);
8855 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8856
8857 qstatus = GetQueueStatus(qs_all_input);
8858 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8859 "wrong qstatus %08x\n", qstatus);
8860
8861 msg.message = 0;
8862 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (qs_input << 16));
8863 ok(!ret,
8864 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8865 msg.message);
8866 ok_sequence(WmUser, "WmUser", FALSE);
8867
8868 qstatus = GetQueueStatus(qs_all_input);
8869 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8870 "wrong qstatus %08x\n", qstatus);
8871
8872 trace("signalling to send message\n");
8873 SetEvent(info.hevent[EV_SENDMSG]);
8874 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8875
8876 qstatus = GetQueueStatus(qs_all_input);
8877 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8878 "wrong qstatus %08x\n", qstatus);
8879
8880 msg.message = 0;
8881 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
8882 ok(!ret,
8883 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8884 msg.message);
8885 ok_sequence(WmUser, "WmUser", FALSE);
8886
8887 qstatus = GetQueueStatus(qs_all_input);
8888 ok(qstatus == MAKELONG(0, QS_PAINT|QS_POSTMESSAGE|QS_KEY),
8889 "wrong qstatus %08x\n", qstatus);
8890
8891 msg.message = 0;
8892 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
8893 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
8894 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
8895 ret, msg.message, msg.wParam);
8896 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8897
8898 qstatus = GetQueueStatus(qs_all_input);
8899 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
8900 "wrong qstatus %08x\n", qstatus);
8901
8902 msg.message = 0;
8903 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_POSTMESSAGE);
8904 ok(!ret,
8905 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8906 msg.message);
8907 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8908
8909 qstatus = GetQueueStatus(qs_all_input);
8910 ok(qstatus == MAKELONG(0, QS_PAINT|QS_KEY),
8911 "wrong qstatus %08x\n", qstatus);
8912
8913 msg.message = 0;
8914 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
8915 ok(ret && msg.message == WM_PAINT,
8916 "got %d and %04x instead of TRUE and WM_PAINT\n", ret, msg.message);
8917 DispatchMessageA(&msg);
8918 ok_sequence(WmPaint, "WmPaint", FALSE);
8919
8920 qstatus = GetQueueStatus(qs_all_input);
8921 ok(qstatus == MAKELONG(0, QS_KEY),
8922 "wrong qstatus %08x\n", qstatus);
8923
8924 msg.message = 0;
8925 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_PAINT);
8926 ok(!ret,
8927 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8928 msg.message);
8929 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8930
8931 qstatus = GetQueueStatus(qs_all_input);
8932 ok(qstatus == MAKELONG(0, QS_KEY),
8933 "wrong qstatus %08x\n", qstatus);
8934
8935 trace("signalling to send message\n");
8936 SetEvent(info.hevent[EV_SENDMSG]);
8937 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8938
8939 qstatus = GetQueueStatus(qs_all_input);
8940 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_KEY),
8941 "wrong qstatus %08x\n", qstatus);
8942
8943 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8944
8945 qstatus = GetQueueStatus(qs_all_input);
8946 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
8947 "wrong qstatus %08x\n", qstatus);
8948
8949 msg.message = 0;
8950 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
8951 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
8952 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
8953 ret, msg.message, msg.wParam);
8954 ok_sequence(WmUser, "WmUser", FALSE);
8955
8956 qstatus = GetQueueStatus(qs_all_input);
8957 ok(qstatus == MAKELONG(0, QS_KEY),
8958 "wrong qstatus %08x\n", qstatus);
8959
8960 msg.message = 0;
8961 ret = PeekMessageA(&msg, 0, WM_CHAR, WM_CHAR, PM_REMOVE);
8962 ok(!ret,
8963 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8964 msg.message);
8965 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
8966
8967 qstatus = GetQueueStatus(qs_all_input);
8968 ok(qstatus == MAKELONG(0, QS_KEY),
8969 "wrong qstatus %08x\n", qstatus);
8970
8971 PostMessageA(info.hwnd, WM_CHAR, 'z', 0);
8972
8973 qstatus = GetQueueStatus(qs_all_input);
8974 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE|QS_KEY),
8975 "wrong qstatus %08x\n", qstatus);
8976
8977 trace("signalling to send message\n");
8978 SetEvent(info.hevent[EV_SENDMSG]);
8979 WaitForSingleObject(info.hevent[EV_ACK], INFINITE);
8980
8981 qstatus = GetQueueStatus(qs_all_input);
8982 ok(qstatus == MAKELONG(QS_SENDMESSAGE, QS_SENDMESSAGE|QS_POSTMESSAGE|QS_KEY),
8983 "wrong qstatus %08x\n", qstatus);
8984
8985 msg.message = 0;
8986 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_KEY << 16));
8987 ok(!ret,
8988 "PeekMessageA should have returned FALSE instead of msg %04x\n",
8989 msg.message);
8990 ok_sequence(WmUser, "WmUser", FALSE);
8991
8992 qstatus = GetQueueStatus(qs_all_input);
8993 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
8994 "wrong qstatus %08x\n", qstatus);
8995
8996 msg.message = 0;
8997 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
8998 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
8999 else /* workaround for a missing QS_RAWINPUT support */
9000 ret = PeekMessageA(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE);
9001 ok(ret && msg.message == WM_KEYDOWN && msg.wParam == 'N',
9002 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYDOWN wParam 'N'\n",
9003 ret, msg.message, msg.wParam);
9004 ok_sequence(WmKeyDownSkippedSeq, "WmKeyDownSkippedSeq", FALSE);
9005
9006 qstatus = GetQueueStatus(qs_all_input);
9007 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE|QS_KEY),
9008 "wrong qstatus %08x\n", qstatus);
9009
9010 msg.message = 0;
9011 if (qs_all_input & QS_RAWINPUT) /* use QS_RAWINPUT only if supported */
9012 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | (QS_RAWINPUT << 16));
9013 else /* workaround for a missing QS_RAWINPUT support */
9014 ret = PeekMessageA(&msg, 0, WM_KEYUP, WM_KEYUP, PM_REMOVE);
9015 ok(ret && msg.message == WM_KEYUP && msg.wParam == 'N',
9016 "got %d and %04x wParam %08lx instead of TRUE and WM_KEYUP wParam 'N'\n",
9017 ret, msg.message, msg.wParam);
9018 ok_sequence(WmKeyUpSkippedSeq, "WmKeyUpSkippedSeq", FALSE);
9019
9020 qstatus = GetQueueStatus(qs_all_input);
9021 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9022 "wrong qstatus %08x\n", qstatus);
9023
9024 msg.message = 0;
9025 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE);
9026 ok(!ret,
9027 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9028 msg.message);
9029 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9030
9031 qstatus = GetQueueStatus(qs_all_input);
9032 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9033 "wrong qstatus %08x\n", qstatus);
9034
9035 msg.message = 0;
9036 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9037 ok(ret && msg.message == WM_CHAR && msg.wParam == 'z',
9038 "got %d and %04x wParam %08lx instead of TRUE and WM_CHAR wParam 'z'\n",
9039 ret, msg.message, msg.wParam);
9040 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9041
9042 qstatus = GetQueueStatus(qs_all_input);
9043 ok(qstatus == 0,
9044 "wrong qstatus %08x\n", qstatus);
9045
9046 msg.message = 0;
9047 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9048 ok(!ret,
9049 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9050 msg.message);
9051 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9052
9053 qstatus = GetQueueStatus(qs_all_input);
9054 ok(qstatus == 0,
9055 "wrong qstatus %08x\n", qstatus);
9056
9057 /* test whether presence of the quit flag in the queue affects
9058 * the queue state
9059 */
9060 PostQuitMessage(0x1234abcd);
9061
9062 qstatus = GetQueueStatus(qs_all_input);
9063 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
9064 "wrong qstatus %08x\n", qstatus);
9065
9066 PostMessageA(info.hwnd, WM_USER, 0, 0);
9067
9068 qstatus = GetQueueStatus(qs_all_input);
9069 ok(qstatus == MAKELONG(QS_POSTMESSAGE, QS_POSTMESSAGE),
9070 "wrong qstatus %08x\n", qstatus);
9071
9072 msg.message = 0;
9073 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9074 ok(ret && msg.message == WM_USER,
9075 "got %d and %04x instead of TRUE and WM_USER\n", ret, msg.message);
9076 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9077
9078 qstatus = GetQueueStatus(qs_all_input);
9079 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9080 "wrong qstatus %08x\n", qstatus);
9081
9082 msg.message = 0;
9083 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9084 ok(ret && msg.message == WM_QUIT,
9085 "got %d and %04x instead of TRUE and WM_QUIT\n", ret, msg.message);
9086 ok(msg.wParam == 0x1234abcd, "got wParam %08lx instead of 0x1234abcd\n", msg.wParam);
9087 ok(msg.lParam == 0, "got lParam %08lx instead of 0\n", msg.lParam);
9088 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9089
9090 qstatus = GetQueueStatus(qs_all_input);
9091 todo_wine {
9092 ok(qstatus == MAKELONG(0, QS_POSTMESSAGE),
9093 "wrong qstatus %08x\n", qstatus);
9094 }
9095
9096 msg.message = 0;
9097 ret = PeekMessageA(&msg, 0, 0, 0, PM_REMOVE);
9098 ok(!ret,
9099 "PeekMessageA should have returned FALSE instead of msg %04x\n",
9100 msg.message);
9101 ok_sequence(WmEmptySeq, "WmEmptySeq", FALSE);
9102
9103 qstatus = GetQueueStatus(qs_all_input);
9104 ok(qstatus == 0,
9105 "wrong qstatus %08x\n", qstatus);
9106
9107 trace("signalling to exit\n");
9108 SetEvent(info.hevent[EV_STOP]);
9109
9110 WaitForSingleObject(hthread, INFINITE);
9111
9112 CloseHandle(hthread);
9113 CloseHandle(info.hevent[0]);
9114 CloseHandle(info.hevent[1]);
9115 CloseHandle(info.hevent[2]);
9116
9117 DestroyWindow(info.hwnd);
9118 }
9119
9120 static void wait_move_event(HWND hwnd, int x, int y)
9121 {
9122 MSG msg;
9123 DWORD time;
9124 BOOL ret;
9125 int go = 0;
9126
9127 time = GetTickCount();
9128 while (GetTickCount() - time < 200 && !go) {
9129 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9130 go = ret && msg.pt.x > x && msg.pt.y > y;
9131 }
9132 }
9133
9134 #define STEP 20
9135 static void test_PeekMessage2(void)
9136 {
9137 HWND hwnd;
9138 BOOL ret;
9139 MSG msg;
9140 UINT message;
9141 DWORD time1, time2, time3;
9142 int x1, y1, x2, y2, x3, y3;
9143 POINT pos;
9144
9145 time1 = time2 = time3 = 0;
9146 x1 = y1 = x2 = y2 = x3 = y3 = 0;
9147
9148 /* Initialise window and make sure it is ready for events */
9149 hwnd = CreateWindow("TestWindowClass", "PeekMessage2", WS_OVERLAPPEDWINDOW,
9150 10, 10, 800, 800, NULL, NULL, NULL, NULL);
9151 assert(hwnd);
9152 trace("Window for test_PeekMessage2 %p\n", hwnd);
9153 ShowWindow(hwnd, SW_SHOW);
9154 UpdateWindow(hwnd);
9155 SetFocus(hwnd);
9156 GetCursorPos(&pos);
9157 SetCursorPos(100, 100);
9158 mouse_event(MOUSEEVENTF_MOVE, -STEP, -STEP, 0, 0);
9159 flush_events();
9160
9161 /* Do initial mousemove, wait until we can see it
9162 and then do our test peek with PM_NOREMOVE. */
9163 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
9164 wait_move_event(hwnd, 80, 80);
9165
9166 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9167 ok(ret, "no message available\n");
9168 if (ret) {
9169 trace("1st move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
9170 message = msg.message;
9171 time1 = msg.time;
9172 x1 = msg.pt.x;
9173 y1 = msg.pt.y;
9174 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
9175 }
9176
9177 /* Allow time to advance a bit, and then simulate the user moving their
9178 * mouse around. After that we peek again with PM_NOREMOVE.
9179 * Although the previous mousemove message was never removed, the
9180 * mousemove we now peek should reflect the recent mouse movements
9181 * because the input queue will merge the move events. */
9182 Sleep(2);
9183 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
9184 wait_move_event(hwnd, x1, y1);
9185
9186 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9187 ok(ret, "no message available\n");
9188 if (ret) {
9189 trace("2nd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
9190 message = msg.message;
9191 time2 = msg.time;
9192 x2 = msg.pt.x;
9193 y2 = msg.pt.y;
9194 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
9195 ok(time2 > time1, "message time not advanced: %x %x\n", time1, time2);
9196 ok(x2 != x1 && y2 != y1, "coords not changed: (%d %d) (%d %d)\n", x1, y1, x2, y2);
9197 }
9198
9199 /* Have another go, to drive the point home */
9200 Sleep(2);
9201 mouse_event(MOUSEEVENTF_MOVE, STEP, STEP, 0, 0);
9202 wait_move_event(hwnd, x2, y2);
9203
9204 ret = PeekMessageA(&msg, hwnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_NOREMOVE);
9205 ok(ret, "no message available\n");
9206 if (ret) {
9207 trace("3rd move event: %04x %x %d %d\n", msg.message, msg.time, msg.pt.x, msg.pt.y);
9208 message = msg.message;
9209 time3 = msg.time;
9210 x3 = msg.pt.x;
9211 y3 = msg.pt.y;
9212 ok(message == WM_MOUSEMOVE, "message not WM_MOUSEMOVE, %04x instead\n", message);
9213 ok(time3 > time2, "message time not advanced: %x %x\n", time2, time3);
9214 ok(x3 != x2 && y3 != y2, "coords not changed: (%d %d) (%d %d)\n", x2, y2, x3, y3);
9215 }
9216
9217 DestroyWindow(hwnd);
9218 SetCursorPos(pos.x, pos.y);
9219 flush_events();
9220 }
9221
9222 static void test_quit_message(void)
9223 {
9224 MSG msg;
9225 BOOL ret;
9226
9227 /* test using PostQuitMessage */
9228 flush_events();
9229 PostQuitMessage(0xbeef);
9230
9231 ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
9232 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
9233 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9234 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
9235
9236 ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
9237 ok(ret, "PostMessage failed with error %d\n", GetLastError());
9238
9239 ret = GetMessage(&msg, NULL, 0, 0);
9240 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
9241 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
9242
9243 /* note: WM_QUIT message received after WM_USER message */
9244 ret = GetMessage(&msg, NULL, 0, 0);
9245 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
9246 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9247 ok(msg.wParam == 0xbeef, "wParam was 0x%lx instead of 0xbeef\n", msg.wParam);
9248
9249 ret = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
9250 ok( !ret || msg.message != WM_QUIT, "Received WM_QUIT again\n" );
9251
9252 /* now test with PostThreadMessage - different behaviour! */
9253 PostThreadMessage(GetCurrentThreadId(), WM_QUIT, 0xdead, 0);
9254
9255 ret = PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
9256 ok(ret, "PeekMessage failed with error %d\n", GetLastError());
9257 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9258 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
9259
9260 ret = PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0);
9261 ok(ret, "PostMessage failed with error %d\n", GetLastError());
9262
9263 /* note: we receive the WM_QUIT message first this time */
9264 ret = GetMessage(&msg, NULL, 0, 0);
9265 ok(!ret, "GetMessage return %d with error %d instead of FALSE\n", ret, GetLastError());
9266 ok(msg.message == WM_QUIT, "Received message 0x%04x instead of WM_QUIT\n", msg.message);
9267 ok(msg.wParam == 0xdead, "wParam was 0x%lx instead of 0xdead\n", msg.wParam);
9268
9269 ret = GetMessage(&msg, NULL, 0, 0);
9270 ok(ret > 0, "GetMessage failed with error %d\n", GetLastError());
9271 ok(msg.message == WM_USER, "Received message 0x%04x instead of WM_USER\n", msg.message);
9272 }
9273
9274 static const struct message WmMouseHoverSeq[] = {
9275 { WM_MOUSEACTIVATE, sent|optional }, /* we can get those when moving the mouse in focus-follow-mouse mode under X11 */
9276 { WM_MOUSEACTIVATE, sent|optional },
9277 { WM_TIMER, sent|optional }, /* XP sends it */
9278 { WM_SYSTIMER, sent },
9279 { WM_MOUSEHOVER, sent|wparam, 0 },
9280 { 0 }
9281 };
9282
9283 static void pump_msg_loop_timeout(DWORD timeout, BOOL inject_mouse_move)
9284 {
9285 MSG msg;
9286 DWORD start_ticks, end_ticks;
9287
9288 start_ticks = GetTickCount();
9289 /* add some deviation (5%) to cover not expected delays */
9290 start_ticks += timeout / 20;
9291
9292 do
9293 {
9294 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
9295 {
9296 /* Timer proc messages are not dispatched to the window proc,
9297 * and therefore not logged.
9298 */
9299 if (msg.message == WM_TIMER || msg.message == WM_SYSTIMER)
9300 {
9301 struct message s_msg;
9302
9303 s_msg.message = msg.message;
9304 s_msg.flags = sent|wparam|lparam;
9305 s_msg.wParam = msg.wParam;
9306 s_msg.lParam = msg.lParam;
9307 add_message(&s_msg);
9308 }
9309 DispatchMessage(&msg);
9310 }
9311
9312 end_ticks = GetTickCount();
9313
9314 /* inject WM_MOUSEMOVE to see how it changes tracking */
9315 if (inject_mouse_move && start_ticks + timeout / 2 >= end_ticks)
9316 {
9317 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9318 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9319
9320 inject_mouse_move = FALSE;
9321 }
9322 } while (start_ticks + timeout >= end_ticks);
9323 }
9324
9325 static void test_TrackMouseEvent(void)
9326 {
9327 TRACKMOUSEEVENT tme;
9328 BOOL ret;
9329 HWND hwnd, hchild;
9330 RECT rc_parent, rc_child;
9331 UINT default_hover_time, hover_width = 0, hover_height = 0;
9332
9333 #define track_hover(track_hwnd, track_hover_time) \
9334 tme.cbSize = sizeof(tme); \
9335 tme.dwFlags = TME_HOVER; \
9336 tme.hwndTrack = track_hwnd; \
9337 tme.dwHoverTime = track_hover_time; \
9338 SetLastError(0xdeadbeef); \
9339 ret = pTrackMouseEvent(&tme); \
9340 ok(ret, "TrackMouseEvent(TME_HOVER) error %d\n", GetLastError())
9341
9342 #define track_query(expected_track_flags, expected_track_hwnd, expected_hover_time) \
9343 tme.cbSize = sizeof(tme); \
9344 tme.dwFlags = TME_QUERY; \
9345 tme.hwndTrack = (HWND)0xdeadbeef; \
9346 tme.dwHoverTime = 0xdeadbeef; \
9347 SetLastError(0xdeadbeef); \
9348 ret = pTrackMouseEvent(&tme); \
9349 ok(ret, "TrackMouseEvent(TME_QUERY) error %d\n", GetLastError());\
9350 ok(tme.cbSize == sizeof(tme), "wrong tme.cbSize %u\n", tme.cbSize); \
9351 ok(tme.dwFlags == (expected_track_flags), \
9352 "wrong tme.dwFlags %08x, expected %08x\n", tme.dwFlags, (expected_track_flags)); \
9353 ok(tme.hwndTrack == (expected_track_hwnd), \
9354 "wrong tme.hwndTrack %p, expected %p\n", tme.hwndTrack, (expected_track_hwnd)); \
9355 ok(tme.dwHoverTime == (expected_hover_time), \
9356 "wrong tme.dwHoverTime %u, expected %u\n", tme.dwHoverTime, (expected_hover_time))
9357
9358 #define track_hover_cancel(track_hwnd) \
9359 tme.cbSize = sizeof(tme); \
9360 tme.dwFlags = TME_HOVER | TME_CANCEL; \
9361 tme.hwndTrack = track_hwnd; \
9362 tme.dwHoverTime = 0xdeadbeef; \
9363 SetLastError(0xdeadbeef); \
9364 ret = pTrackMouseEvent(&tme); \
9365 ok(ret, "TrackMouseEvent(TME_HOVER | TME_CANCEL) error %d\n", GetLastError())
9366
9367 default_hover_time = 0xdeadbeef;
9368 SetLastError(0xdeadbeef);
9369 ret = SystemParametersInfo(SPI_GETMOUSEHOVERTIME, 0, &default_hover_time, 0);
9370 ok(ret, "SystemParametersInfo(SPI_GETMOUSEHOVERTIME) error %u\n", GetLastError());
9371 if (!ret) default_hover_time = 400;
9372 trace("SPI_GETMOUSEHOVERTIME returned %u ms\n", default_hover_time);
9373
9374 SetLastError(0xdeadbeef);
9375 ret = SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH, 0, &hover_width, 0);
9376 ok(ret, "SystemParametersInfo(SPI_GETMOUSEHOVERWIDTH) error %u\n", GetLastError());
9377 if (!ret) hover_width = 4;
9378 SetLastError(0xdeadbeef);
9379 ret = SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT, 0, &hover_height, 0);
9380 ok(ret, "SystemParametersInfo(SPI_GETMOUSEHOVERHEIGHT) error %u\n", GetLastError());
9381 if (!ret) hover_height = 4;
9382 trace("hover rect is %u x %d\n", hover_width, hover_height);
9383
9384 hwnd = CreateWindowEx(0, "TestWindowClass", NULL,
9385 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
9386 CW_USEDEFAULT, CW_USEDEFAULT, 300, 300, 0,
9387 NULL, NULL, 0);
9388 assert(hwnd);
9389
9390 hchild = CreateWindowEx(0, "TestWindowClass", NULL,
9391 WS_CHILD | WS_BORDER | WS_VISIBLE,
9392 50, 50, 200, 200, hwnd,
9393 NULL, NULL, 0);
9394 assert(hchild);
9395
9396 flush_events();
9397 flush_sequence();
9398
9399 tme.cbSize = 0;
9400 tme.dwFlags = TME_QUERY;
9401 tme.hwndTrack = (HWND)0xdeadbeef;
9402 tme.dwHoverTime = 0xdeadbeef;
9403 SetLastError(0xdeadbeef);
9404 ret = pTrackMouseEvent(&tme);
9405 ok(!ret, "TrackMouseEvent should fail\n");
9406 ok(GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef),
9407 "not expected error %u\n", GetLastError());
9408
9409 tme.cbSize = sizeof(tme);
9410 tme.dwFlags = TME_HOVER;
9411 tme.hwndTrack = (HWND)0xdeadbeef;
9412 tme.dwHoverTime = 0xdeadbeef;
9413 SetLastError(0xdeadbeef);
9414 ret = pTrackMouseEvent(&tme);
9415 ok(!ret, "TrackMouseEvent should fail\n");
9416 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
9417 "not expected error %u\n", GetLastError());
9418
9419 tme.cbSize = sizeof(tme);
9420 tme.dwFlags = TME_HOVER | TME_CANCEL;
9421 tme.hwndTrack = (HWND)0xdeadbeef;
9422 tme.dwHoverTime = 0xdeadbeef;
9423 SetLastError(0xdeadbeef);
9424 ret = pTrackMouseEvent(&tme);
9425 ok(!ret, "TrackMouseEvent should fail\n");
9426 ok(GetLastError() == ERROR_INVALID_WINDOW_HANDLE || broken(GetLastError() == 0xdeadbeef),
9427 "not expected error %u\n", GetLastError());
9428
9429 GetWindowRect(hwnd, &rc_parent);
9430 GetWindowRect(hchild, &rc_child);
9431 SetCursorPos(rc_child.left - 10, rc_child.top - 10);
9432
9433 /* Process messages so that the system updates its internal current
9434 * window and hittest, otherwise TrackMouseEvent calls don't have any
9435 * effect.
9436 */
9437 flush_events();
9438 flush_sequence();
9439
9440 track_query(0, NULL, 0);
9441 track_hover(hchild, 0);
9442 track_query(0, NULL, 0);
9443
9444 flush_events();
9445 flush_sequence();
9446
9447 track_hover(hwnd, 0);
9448 track_query(TME_HOVER, hwnd, default_hover_time);
9449
9450 pump_msg_loop_timeout(default_hover_time, FALSE);
9451 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
9452
9453 track_query(0, NULL, 0);
9454
9455 track_hover(hwnd, HOVER_DEFAULT);
9456 track_query(TME_HOVER, hwnd, default_hover_time);
9457
9458 Sleep(default_hover_time / 2);
9459 mouse_event(MOUSEEVENTF_MOVE, -1, 0, 0, 0);
9460 mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0);
9461
9462 track_query(TME_HOVER, hwnd, default_hover_time);
9463
9464 pump_msg_loop_timeout(default_hover_time / 2, FALSE);
9465 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
9466
9467 track_query(0, NULL, 0);
9468
9469 track_hover(hwnd, HOVER_DEFAULT);
9470 track_query(TME_HOVER, hwnd, default_hover_time);
9471
9472 pump_msg_loop_timeout(default_hover_time, TRUE);
9473 ok_sequence(WmMouseHoverSeq, "WmMouseHoverSeq", FALSE);
9474
9475 track_query(0, NULL, 0);
9476
9477 track_hover(hwnd, HOVER_DEFAULT);
9478 track_query(TME_HOVER, hwnd, default_hover_time);
9479 track_hover_cancel(hwnd);
9480
9481 DestroyWindow(hwnd);
9482
9483 #undef track_hover
9484 #undef track_query
9485 #undef track_hover_cancel
9486 }
9487
9488
9489 static const struct message WmSetWindowRgn[] = {
9490 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9491 { WM_NCCALCSIZE, sent|wparam, 1 },
9492 { WM_NCPAINT, sent|optional }, /* wparam != 1 */
9493 { WM_GETTEXT, sent|defwinproc|optional },
9494 { WM_ERASEBKGND, sent|optional },
9495 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9496 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9497 { 0 }
9498 };
9499
9500 static const struct message WmSetWindowRgn_no_redraw[] = {
9501 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
9502 { WM_NCCALCSIZE, sent|wparam, 1 },
9503 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW },
9504 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9505 { 0 }
9506 };
9507
9508 static const struct message WmSetWindowRgn_clear[] = {
9509 { WM_WINDOWPOSCHANGING, sent/*|wparam*/, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE/*|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE only on some Windows versions */ },
9510 { WM_NCCALCSIZE, sent|wparam, 1 },
9511 { WM_NCPAINT, sent|optional },
9512 { WM_GETTEXT, sent|defwinproc|optional },
9513 { WM_ERASEBKGND, sent|optional }, /* FIXME: remove optional once Wine is fixed */
9514 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9515 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
9516 { WM_NCPAINT, sent|optional },
9517 { WM_GETTEXT, sent|defwinproc|optional },
9518 { WM_ERASEBKGND, sent|optional },
9519 { WM_WINDOWPOSCHANGING, sent|optional },
9520 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
9521 { WM_NCPAINT, sent|optional },
9522 { WM_GETTEXT, sent|defwinproc|optional },
9523 { WM_ERASEBKGND, sent|optional },
9524 { WM_WINDOWPOSCHANGED, sent|optional|wparam, SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE },
9525 { WM_NCCALCSIZE, sent|optional|wparam, 1 },
9526 { WM_NCPAINT, sent|optional },
9527 { WM_GETTEXT, sent|defwinproc|optional },
9528 { WM_ERASEBKGND, sent|optional },
9529 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9530 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, 0, 0 },
9531 { 0 }
9532 };
9533
9534 static void test_SetWindowRgn(void)
9535 {
9536 HRGN hrgn;
9537 HWND hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
9538 100, 100, 200, 200, 0, 0, 0, NULL);
9539 ok( hwnd != 0, "Failed to create overlapped window\n" );
9540
9541 ShowWindow( hwnd, SW_SHOW );
9542 UpdateWindow( hwnd );
9543 flush_events();
9544 flush_sequence();
9545
9546 trace("testing SetWindowRgn\n");
9547 hrgn = CreateRectRgn( 0, 0, 150, 150 );
9548 SetWindowRgn( hwnd, hrgn, TRUE );
9549 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn", FALSE );
9550
9551 hrgn = CreateRectRgn( 30, 30, 160, 160 );
9552 SetWindowRgn( hwnd, hrgn, FALSE );
9553 ok_sequence( WmSetWindowRgn_no_redraw, "WmSetWindowRgn_no_redraw", FALSE );
9554
9555 hrgn = CreateRectRgn( 0, 0, 180, 180 );
9556 SetWindowRgn( hwnd, hrgn, TRUE );
9557 ok_sequence( WmSetWindowRgn, "WmSetWindowRgn2", FALSE );
9558
9559 SetWindowRgn( hwnd, 0, TRUE );
9560 ok_sequence( WmSetWindowRgn_clear, "WmSetWindowRgn_clear", FALSE );
9561
9562 DestroyWindow( hwnd );
9563 }
9564
9565 /*************************** ShowWindow() test ******************************/
9566 static const struct message WmShowNormal[] = {
9567 { WM_SHOWWINDOW, sent|wparam, 1 },
9568 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9569 { HCBT_ACTIVATE, hook },
9570 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
9571 { HCBT_SETFOCUS, hook },
9572 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9573 { 0 }
9574 };
9575 static const struct message WmShow[] = {
9576 { WM_SHOWWINDOW, sent|wparam, 1 },
9577 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9578 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9579 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9580 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9581 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9582 { 0 }
9583 };
9584 static const struct message WmShowNoActivate_1[] = {
9585 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
9586 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
9587 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_STATECHANGED },
9588 { WM_MOVE, sent|defwinproc },
9589 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9590 { 0 }
9591 };
9592 static const struct message WmShowNoActivate_2[] = {
9593 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNOACTIVATE },
9594 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9595 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9596 { WM_MOVE, sent|defwinproc },
9597 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9598 { HCBT_SETFOCUS, hook|optional },
9599 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
9600 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
9601 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
9602 { 0 }
9603 };
9604 static const struct message WmShowNA_1[] = {
9605 { WM_SHOWWINDOW, sent|wparam, 1 },
9606 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
9607 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9608 { 0 }
9609 };
9610 static const struct message WmShowNA_2[] = {
9611 { WM_SHOWWINDOW, sent|wparam, 1 },
9612 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
9613 { 0 }
9614 };
9615 static const struct message WmRestore_1[] = {
9616 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
9617 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9618 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9619 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9620 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9621 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9622 { WM_MOVE, sent|defwinproc },
9623 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9624 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
9625 { 0 }
9626 };
9627 static const struct message WmRestore_2[] = {
9628 { WM_SHOWWINDOW, sent|wparam, 1 },
9629 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9630 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9631 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9632 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9633 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9634 { 0 }
9635 };
9636 static const struct message WmRestore_3[] = {
9637 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
9638 { WM_GETMINMAXINFO, sent },
9639 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9640 { HCBT_ACTIVATE, hook|optional }, /* win2003 doesn't send it */
9641 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2003 doesn't send it */
9642 { HCBT_SETFOCUS, hook|optional }, /* win2003 doesn't send it */
9643 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9644 { WM_MOVE, sent|defwinproc },
9645 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
9646 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
9647 { 0 }
9648 };
9649 static const struct message WmRestore_4[] = {
9650 { HCBT_MINMAX, hook|lparam, 0, SW_RESTORE },
9651 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
9652 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
9653 { WM_MOVE, sent|defwinproc },
9654 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9655 { 0 }
9656 };
9657 static const struct message WmRestore_5[] = {
9658 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWNORMAL },
9659 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
9660 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
9661 { WM_MOVE, sent|defwinproc },
9662 { WM_SIZE, sent|wparam|defwinproc, SIZE_RESTORED },
9663 { 0 }
9664 };
9665 static const struct message WmHide_1[] = {
9666 { WM_SHOWWINDOW, sent|wparam, 0 },
9667 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9668 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9669 { HCBT_SETFOCUS, hook|optional }, /* win2000 sends it */
9670 { 0 }
9671 };
9672 static const struct message WmHide_2[] = {
9673 { WM_SHOWWINDOW, sent|wparam, 0 },
9674 { WM_WINDOWPOSCHANGING, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
9675 { WM_WINDOWPOSCHANGED, sent /*|wparam, SWP_HIDEWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ }, /* win2000 doesn't add SWP_NOACTIVATE */
9676 { 0 }
9677 };
9678 static const struct message WmHide_3[] = {
9679 { WM_SHOWWINDOW, sent|wparam, 0 },
9680 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE },
9681 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_HIDEWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9682 { HCBT_SETFOCUS, hook|optional },
9683 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
9684 { 0 }
9685 };
9686 static const struct message WmShowMinimized_1[] = {
9687 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
9688 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9689 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9690 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9691 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9692 { WM_MOVE, sent|defwinproc },
9693 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9694 { 0 }
9695 };
9696 static const struct message WmMinimize_1[] = {
9697 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9698 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9699 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
9700 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9701 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9702 { WM_MOVE, sent|defwinproc },
9703 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9704 { 0 }
9705 };
9706 static const struct message WmMinimize_2[] = {
9707 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9708 { HCBT_SETFOCUS, hook|optional },
9709 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9710 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9711 { WM_MOVE, sent|defwinproc },
9712 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9713 { 0 }
9714 };
9715 static const struct message WmMinimize_3[] = {
9716 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9717 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9718 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9719 { WM_MOVE, sent|defwinproc },
9720 { WM_SIZE, sent|wparam|defwinproc, SIZE_MINIMIZED },
9721 { 0 }
9722 };
9723 static const struct message WmShowMinNoActivate[] = {
9724 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
9725 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE },
9726 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
9727 { 0 }
9728 };
9729 static const struct message WmMinMax_1[] = {
9730 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINIMIZED },
9731 { 0 }
9732 };
9733 static const struct message WmMinMax_2[] = {
9734 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
9735 { 0 }
9736 };
9737 static const struct message WmMinMax_3[] = {
9738 { HCBT_MINMAX, hook|lparam, 0, SW_MINIMIZE },
9739 { 0 }
9740 };
9741 static const struct message WmMinMax_4[] = {
9742 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMINNOACTIVE },
9743 { 0 }
9744 };
9745 static const struct message WmShowMaximized_1[] = {
9746 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
9747 { WM_GETMINMAXINFO, sent },
9748 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9749 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9750 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9751 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9752 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_SHOWWINDOW|SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9753 { WM_MOVE, sent|defwinproc },
9754 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
9755 { HCBT_SETFOCUS, hook|optional }, /* win2003 sends it */
9756 { 0 }
9757 };
9758 static const struct message WmShowMaximized_2[] = {
9759 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
9760 { WM_GETMINMAXINFO, sent },
9761 { WM_WINDOWPOSCHANGING, sent|optional },
9762 { HCBT_ACTIVATE, hook|optional },
9763 { WM_WINDOWPOSCHANGED, sent|optional },
9764 { WM_MOVE, sent|optional }, /* Win9x doesn't send it */
9765 { WM_SIZE, sent|wparam|optional, SIZE_MAXIMIZED }, /* Win9x doesn't send it */
9766 { WM_WINDOWPOSCHANGING, sent },
9767 { HCBT_SETFOCUS, hook|optional },
9768 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_NOCOPYBITS|SWP_STATECHANGED },
9769 { WM_MOVE, sent|defwinproc },
9770 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
9771 { HCBT_SETFOCUS, hook|optional },
9772 { 0 }
9773 };
9774 static const struct message WmShowMaximized_3[] = {
9775 { HCBT_MINMAX, hook|lparam, 0, SW_SHOWMAXIMIZED },
9776 { WM_GETMINMAXINFO, sent },
9777 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
9778 { HCBT_ACTIVATE, hook|optional }, /* win2000 doesn't send it */
9779 { WM_WINDOWPOSCHANGING, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE }, /* win2000 doesn't send it */
9780 { HCBT_SETFOCUS, hook|optional }, /* win2000 doesn't send it */
9781 { WM_WINDOWPOSCHANGED, sent|wparam, SWP_FRAMECHANGED|SWP_STATECHANGED },
9782 { WM_MOVE, sent|defwinproc },
9783 { WM_SIZE, sent|wparam|defwinproc, SIZE_MAXIMIZED },
9784 { 0 }
9785 };
9786
9787 static void test_ShowWindow(void)
9788 {
9789 /* ShowWindow commands in random order */
9790 static const struct
9791 {
9792 INT cmd; /* ShowWindow command */
9793 LPARAM ret; /* ShowWindow return value */
9794 DWORD style; /* window style after the command */
9795 const struct message *msg; /* message sequence the command produces */
9796 BOOL todo_msg; /* message sequence doesn't match what Wine does */
9797 } sw[] =
9798 {
9799 /* 1 */ { SW_SHOWNORMAL, FALSE, WS_VISIBLE, WmShowNormal, FALSE },
9800 /* 2 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9801 /* 3 */ { SW_HIDE, TRUE, 0, WmHide_1, FALSE },
9802 /* 4 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
9803 /* 5 */ { SW_SHOWMINIMIZED, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinimized_1, FALSE },
9804 /* 6 */ { SW_SHOWMINIMIZED, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_1, FALSE },
9805 /* 7 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_1, FALSE },
9806 /* 8 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
9807 /* 9 */ { SW_SHOWMAXIMIZED, FALSE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_1, FALSE },
9808 /* 10 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2, FALSE },
9809 /* 11 */ { SW_HIDE, TRUE, WS_MAXIMIZE, WmHide_1, FALSE },
9810 /* 12 */ { SW_HIDE, FALSE, WS_MAXIMIZE, WmEmptySeq, FALSE },
9811 /* 13 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_1, FALSE },
9812 /* 14 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9813 /* 15 */ { SW_HIDE, TRUE, 0, WmHide_2, FALSE },
9814 /* 16 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
9815 /* 17 */ { SW_SHOW, FALSE, WS_VISIBLE, WmShow, FALSE },
9816 /* 18 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9817 /* 19 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1, FALSE },
9818 /* 20 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
9819 /* 21 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
9820 /* 22 */ { SW_SHOWMINNOACTIVE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowMinNoActivate, TRUE },
9821 /* 23 */ { SW_SHOWMINNOACTIVE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_4, FALSE },
9822 /* 24 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
9823 /* 25 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
9824 /* 26 */ { SW_SHOWNA, FALSE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_1, FALSE },
9825 /* 27 */ { SW_SHOWNA, TRUE, WS_VISIBLE|WS_MINIMIZE, WmShowNA_2, FALSE },
9826 /* 28 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
9827 /* 29 */ { SW_HIDE, FALSE, WS_MINIMIZE, WmEmptySeq, FALSE },
9828 /* 30 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_1, FALSE },
9829 /* 31 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9830 /* 32 */ { SW_HIDE, TRUE, 0, WmHide_3, FALSE },
9831 /* 33 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
9832 /* 34 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, FALSE }, /* what does this mean?! */
9833 /* 35 */ { SW_NORMALNA, FALSE, 0, WmEmptySeq, FALSE },
9834 /* 36 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
9835 /* 37 */ { SW_RESTORE, FALSE, WS_VISIBLE, WmRestore_2, FALSE },
9836 /* 38 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9837 /* 39 */ { SW_SHOWNOACTIVATE, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9838 /* 40 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_2, FALSE },
9839 /* 41 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
9840 /* 42 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_2, TRUE },
9841 /* 43 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmMinMax_2, FALSE },
9842 /* 44 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_1, FALSE },
9843 /* 45 */ { SW_MINIMIZE, TRUE, WS_VISIBLE|WS_MINIMIZE, WmMinMax_3, FALSE },
9844 /* 46 */ { SW_RESTORE, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmRestore_3, FALSE },
9845 /* 47 */ { SW_RESTORE, TRUE, WS_VISIBLE, WmRestore_4, FALSE },
9846 /* 48 */ { SW_SHOWMAXIMIZED, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmShowMaximized_3, FALSE },
9847 /* 49 */ { SW_SHOW, TRUE, WS_VISIBLE|WS_MAXIMIZE, WmEmptySeq, FALSE },
9848 /* 50 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmRestore_5, FALSE },
9849 /* 51 */ { SW_SHOWNORMAL, TRUE, WS_VISIBLE, WmEmptySeq, FALSE },
9850 /* 52 */ { SW_HIDE, TRUE, 0, WmHide_1, FALSE },
9851 /* 53 */ { SW_HIDE, FALSE, 0, WmEmptySeq, FALSE },
9852 /* 54 */ { SW_MINIMIZE, FALSE, WS_VISIBLE|WS_MINIMIZE, WmMinimize_3, FALSE },
9853 /* 55 */ { SW_HIDE, TRUE, WS_MINIMIZE, WmHide_2, FALSE },
9854 /* 56 */ { SW_SHOWNOACTIVATE, FALSE, WS_VISIBLE, WmShowNoActivate_2, FALSE },
9855 /* 57 */ { SW_SHOW, TRUE, WS_VISIBLE, WmEmptySeq, FALSE }
9856 };
9857 HWND hwnd;
9858 DWORD style;
9859 LPARAM ret;
9860 INT i;
9861
9862 #define WS_BASE (WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|WS_CLIPSIBLINGS)
9863 hwnd = CreateWindowEx(0, "ShowWindowClass", NULL, WS_BASE,
9864 120, 120, 90, 90,
9865 0, 0, 0, NULL);
9866 assert(hwnd);
9867
9868 style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_BASE;
9869 ok(style == 0, "expected style 0, got %08x\n", style);
9870
9871 flush_events();
9872 flush_sequence();
9873
9874 for (i = 0; i < sizeof(sw)/sizeof(sw[0]); i++)
9875 {
9876 static const char * const sw_cmd_name[13] =
9877 {
9878 "SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_SHOWMAXIMIZED",
9879 "SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
9880 "SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
9881 "SW_NORMALNA" /* 0xCC */
9882 };
9883 char comment[64];
9884 INT idx; /* index into the above array of names */
9885
9886 idx = (sw[i].cmd == SW_NORMALNA) ? 12 : sw[i].cmd;
9887
9888 style = GetWindowLong(hwnd, GWL_STYLE);
9889 trace("%d: sending %s, current window style %08x\n", i+1, sw_cmd_name[idx], style);
9890 ret = ShowWindow(hwnd, sw[i].cmd);
9891 ok(!ret == !sw[i].ret, "%d: cmd %s: expected ret %lu, got %lu\n", i+1, sw_cmd_name[idx], sw[i].ret, ret);
9892 style = GetWindowLong(hwnd, GWL_STYLE) & ~WS_BASE;
9893 ok(style == sw[i].style, "%d: expected style %08x, got %08x\n", i+1, sw[i].style, style);
9894
9895 sprintf(comment, "%d: ShowWindow(%s)", i+1, sw_cmd_name[idx]);
9896 ok_sequence(sw[i].msg, comment, sw[i].todo_msg);
9897
9898 flush_events();
9899 flush_sequence();
9900 }
9901
9902 DestroyWindow(hwnd);
9903 }
9904
9905 static INT_PTR WINAPI test_dlg_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
9906 {
9907 struct message msg;
9908
9909 trace("dialog: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
9910
9911 switch (message)
9912 {
9913 case WM_WINDOWPOSCHANGING:
9914 case WM_WINDOWPOSCHANGED:
9915 {
9916 WINDOWPOS *winpos = (WINDOWPOS *)lParam;
9917
9918 trace("%s\n", (message == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
9919 trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x ",
9920 winpos->hwnd, winpos->hwndInsertAfter,
9921 winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
9922 dump_winpos_flags(winpos->flags);
9923
9924 /* Log only documented flags, win2k uses 0x1000 and 0x2000
9925 * in the high word for internal purposes
9926 */
9927 wParam = winpos->flags & 0xffff;
9928 /* We are not interested in the flags that don't match under XP and Win9x */
9929 wParam &= ~(SWP_NOZORDER);
9930 break;
9931 }
9932
9933 /* explicitly ignore WM_GETICON message */
9934 case WM_GETICON:
9935 return 0;
9936 }
9937
9938 msg.message = message;
9939 msg.flags = sent|wparam|lparam;
9940 msg.wParam = wParam;
9941 msg.lParam = lParam;
9942 add_message(&msg);
9943
9944 /* calling DefDlgProc leads to a recursion under XP */
9945
9946 switch (message)
9947 {
9948 case WM_INITDIALOG:
9949 case WM_GETDLGCODE:
9950 return 0;
9951 }
9952 return 1;
9953 }
9954
9955 static const struct message WmDefDlgSetFocus_1[] = {
9956 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
9957 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
9958 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
9959 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
9960 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
9961 { HCBT_SETFOCUS, hook },
9962 { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
9963 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
9964 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
9965 { WM_SETFOCUS, sent|wparam, 0 },
9966 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 10 },
9967 { WM_CTLCOLOREDIT, sent },
9968 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 11 },
9969 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9970 { EVENT_OBJECT_LOCATIONCHANGE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9971 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9972 { WM_COMMAND, sent|wparam, MAKEWPARAM(1, EN_SETFOCUS) },
9973 { 0 }
9974 };
9975 static const struct message WmDefDlgSetFocus_2[] = {
9976 { WM_GETDLGCODE, sent|wparam|lparam, 0, 0 },
9977 { WM_GETTEXTLENGTH, sent|wparam|lparam|optional, 0, 0 }, /* XP */
9978 { WM_GETTEXT, sent|wparam|optional, 6 }, /* XP */
9979 { WM_GETTEXT, sent|wparam|optional, 12 }, /* XP */
9980 { EM_SETSEL, sent|wparam, 0 }, /* XP sets lparam to text length, Win9x to -2 */
9981 { EVENT_OBJECT_HIDE, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9982 { WM_CTLCOLOREDIT, sent|optional }, /* XP */
9983 { EVENT_OBJECT_SHOW, winevent_hook|wparam|lparam, OBJID_CARET, 0 },
9984 { 0 }
9985 };
9986 /* Creation of a dialog */
9987 static const struct message WmCreateDialogParamSeq_1[] = {
9988 { HCBT_CREATEWND, hook },
9989 { WM_NCCREATE, sent },
9990 { WM_NCCALCSIZE, sent|wparam, 0 },
9991 { WM_CREATE, sent },
9992 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
9993 { WM_SIZE, sent|wparam, SIZE_RESTORED },
9994 { WM_MOVE, sent },
9995 { WM_SETFONT, sent },
9996 { WM_INITDIALOG, sent },
9997 { WM_CHANGEUISTATE, sent|optional },
9998 { 0 }
9999 };
10000 /* Creation of a dialog */
10001 static const struct message WmCreateDialogParamSeq_2[] = {
10002 { HCBT_CREATEWND, hook },
10003 { WM_NCCREATE, sent },
10004 { WM_NCCALCSIZE, sent|wparam, 0 },
10005 { WM_CREATE, sent },
10006 { EVENT_OBJECT_CREATE, winevent_hook|wparam|lparam, 0, 0 },
10007 { WM_SIZE, sent|wparam, SIZE_RESTORED },
10008 { WM_MOVE, sent },
10009 { WM_CHANGEUISTATE, sent|optional },
10010 { 0 }
10011 };
10012
10013 static void test_dialog_messages(void)
10014 {
10015 WNDCLASS cls;
10016 HWND hdlg, hedit1, hedit2, hfocus;
10017 LRESULT ret;
10018
10019 #define set_selection(hctl, start, end) \
10020 ret = SendMessage(hctl, EM_SETSEL, start, end); \
10021 ok(ret == 1, "EM_SETSEL returned %ld\n", ret);
10022
10023 #define check_selection(hctl, start, end) \
10024 ret = SendMessage(hctl, EM_GETSEL, 0, 0); \
10025 ok(ret == MAKELRESULT(start, end), "wrong selection (%d - %d)\n", LOWORD(ret), HIWORD(ret));
10026
10027 subclass_edit();
10028
10029 hdlg = CreateWindowEx(WS_EX_DLGMODALFRAME, "TestDialogClass", NULL,
10030 WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_DLGFRAME,
10031 0, 0, 100, 100, 0, 0, 0, NULL);
10032 ok(hdlg != 0, "Failed to create custom dialog window\n");
10033
10034 hedit1 = CreateWindowEx(0, "my_edit_class", NULL,
10035 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
10036 0, 0, 80, 20, hdlg, (HMENU)1, 0, NULL);
10037 ok(hedit1 != 0, "Failed to create edit control\n");
10038 hedit2 = CreateWindowEx(0, "my_edit_class", NULL,
10039 WS_CHILD|WS_BORDER|WS_VISIBLE|WS_TABSTOP,
10040 0, 40, 80, 20, hdlg, (HMENU)2, 0, NULL);
10041 ok(hedit2 != 0, "Failed to create edit control\n");
10042
10043 SendMessage(hedit1, WM_SETTEXT, 0, (LPARAM)"hello");
10044 SendMessage(hedit2, WM_SETTEXT, 0, (LPARAM)"bye");
10045
10046 hfocus = GetFocus();
10047 ok(hfocus == hdlg, "wrong focus %p\n", hfocus);
10048
10049 SetFocus(hedit2);
10050 hfocus = GetFocus();
10051 ok(hfocus == hedit2, "wrong focus %p\n", hfocus);
10052
10053 check_selection(hedit1, 0, 0);
10054 check_selection(hedit2, 0, 0);
10055
10056 set_selection(hedit2, 0, -1);
10057 check_selection(hedit2, 0, 3);
10058
10059 SetFocus(0);
10060 hfocus = GetFocus();
10061 ok(hfocus == 0, "wrong focus %p\n", hfocus);
10062
10063 flush_sequence();
10064 ret = DefDlgProc(hdlg, WM_SETFOCUS, 0, 0);
10065 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
10066 ok_sequence(WmDefDlgSetFocus_1, "DefDlgProc(WM_SETFOCUS) 1", FALSE);
10067
10068 hfocus = GetFocus();
10069 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
10070
10071 check_selection(hedit1, 0, 5);
10072 check_selection(hedit2, 0, 3);
10073
10074 flush_sequence();
10075 ret = DefDlgProc(hdlg, WM_SETFOCUS, 0, 0);
10076 ok(ret == 0, "WM_SETFOCUS returned %ld\n", ret);
10077 ok_sequence(WmDefDlgSetFocus_2, "DefDlgProc(WM_SETFOCUS) 2", FALSE);
10078
10079 hfocus = GetFocus();
10080 ok(hfocus == hedit1, "wrong focus %p\n", hfocus);
10081
10082 check_selection(hedit1, 0, 5);
10083 check_selection(hedit2, 0, 3);
10084
10085 EndDialog(hdlg, 0);
10086 DestroyWindow(hedit1);
10087 DestroyWindow(hedit2);
10088 DestroyWindow(hdlg);
10089 flush_sequence();
10090
10091 #undef set_selection
10092 #undef check_selection
10093
10094 ok(GetClassInfo(0, "#32770", &cls), "GetClassInfo failed\n");
10095 cls.lpszClassName = "MyDialogClass";
10096 cls.hInstance = GetModuleHandle(0);
10097 /* need a cast since a dlgproc is used as a wndproc */
10098 cls.lpfnWndProc = (WNDPROC)test_dlg_proc;
10099 if (!RegisterClass(&cls)) assert(0);
10100
10101 hdlg = CreateDialogParam(0, "CLASS_TEST_DIALOG_2", 0, test_dlg_proc, 0);
10102 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
10103 ok_sequence(WmCreateDialogParamSeq_1, "CreateDialogParam_1", FALSE);
10104 EndDialog(hdlg, 0);
10105 DestroyWindow(hdlg);
10106 flush_sequence();
10107
10108 hdlg = CreateDialogParam(0, "CLASS_TEST_DIALOG_2", 0, NULL, 0);
10109 ok(IsWindow(hdlg), "CreateDialogParam failed\n");
10110 ok_sequence(WmCreateDialogParamSeq_2, "CreateDialogParam_2", FALSE);
10111 EndDialog(hdlg, 0);
10112 DestroyWindow(hdlg);
10113 flush_sequence();
10114
10115 UnregisterClass(cls.lpszClassName, cls.hInstance);
10116 }
10117
10118 static void test_nullCallback(void)
10119 {
10120 HWND hwnd;
10121
10122 hwnd = CreateWindowExA(0, "TestWindowClass", "Test overlapped", WS_OVERLAPPEDWINDOW,
10123 100, 100, 200, 200, 0, 0, 0, NULL);
10124 ok (hwnd != 0, "Failed to create overlapped window\n");
10125
10126 SendMessageCallbackA(hwnd,WM_NULL,0,0,NULL,0);
10127 flush_events();
10128 DestroyWindow(hwnd);
10129 }
10130
10131 /* SetActiveWindow( 0 ) hwnd visible */
10132 static const struct message SetActiveWindowSeq0[] =
10133 {
10134 { HCBT_ACTIVATE, hook },
10135 { WM_NCACTIVATE, sent|wparam, 0 },
10136 { WM_GETTEXT, sent|defwinproc|optional },
10137 { WM_ACTIVATE, sent|wparam, 0 },
10138 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10139 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10140 { WM_NCACTIVATE, sent|wparam, 1 },
10141 { WM_GETTEXT, sent|defwinproc|optional },
10142 { WM_ACTIVATE, sent|wparam, 1 },
10143 { HCBT_SETFOCUS, hook },
10144 { WM_KILLFOCUS, sent|defwinproc },
10145 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
10146 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10147 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10148 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10149 { WM_SETFOCUS, sent|defwinproc },
10150 { 0 }
10151 };
10152 /* SetActiveWindow( hwnd ) hwnd visible */
10153 static const struct message SetActiveWindowSeq1[] =
10154 {
10155 { 0 }
10156 };
10157 /* SetActiveWindow( popup ) hwnd visible, popup visible */
10158 static const struct message SetActiveWindowSeq2[] =
10159 {
10160 { HCBT_ACTIVATE, hook },
10161 { WM_NCACTIVATE, sent|wparam, 0 },
10162 { WM_GETTEXT, sent|defwinproc|optional },
10163 { WM_ACTIVATE, sent|wparam, 0 },
10164 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10165 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10166 { WM_NCPAINT, sent|optional },
10167 { WM_GETTEXT, sent|defwinproc|optional },
10168 { WM_ERASEBKGND, sent|optional },
10169 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10170 { WM_NCACTIVATE, sent|wparam, 1 },
10171 { WM_GETTEXT, sent|defwinproc|optional },
10172 { WM_ACTIVATE, sent|wparam, 1 },
10173 { HCBT_SETFOCUS, hook },
10174 { WM_KILLFOCUS, sent|defwinproc },
10175 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
10176 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10177 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10178 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10179 { WM_SETFOCUS, sent|defwinproc },
10180 { 0 }
10181 };
10182
10183 /* SetActiveWindow( hwnd ) hwnd not visible */
10184 static const struct message SetActiveWindowSeq3[] =
10185 {
10186 { HCBT_ACTIVATE, hook },
10187 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10188 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10189 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOACTIVATE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10190 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10191 { WM_ACTIVATEAPP, sent|wparam, 1 },
10192 { WM_ACTIVATEAPP, sent|wparam, 1 },
10193 { WM_NCACTIVATE, sent|wparam, 1 },
10194 { WM_ACTIVATE, sent|wparam, 1 },
10195 { HCBT_SETFOCUS, hook },
10196 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10197 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10198 { WM_SETFOCUS, sent|defwinproc },
10199 { 0 }
10200 };
10201 /* SetActiveWindow( popup ) hwnd not visible, popup not visible */
10202 static const struct message SetActiveWindowSeq4[] =
10203 {
10204 { HCBT_ACTIVATE, hook },
10205 { WM_NCACTIVATE, sent|wparam, 0 },
10206 { WM_GETTEXT, sent|defwinproc|optional },
10207 { WM_ACTIVATE, sent|wparam, 0 },
10208 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE },
10209 { WM_WINDOWPOSCHANGING, sent|wparam, SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE },
10210 { WM_WINDOWPOSCHANGED, sent|wparam|optional, SWP_NOSIZE|SWP_NOMOVE|SWP_NOREDRAW|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE },
10211 { WM_NCACTIVATE, sent|wparam, 1 },
10212 { WM_GETTEXT, sent|defwinproc|optional },
10213 { WM_ACTIVATE, sent|wparam, 1 },
10214 { HCBT_SETFOCUS, hook },
10215 { WM_KILLFOCUS, sent|defwinproc },
10216 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 0 },
10217 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10218 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
10219 { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
10220 { WM_SETFOCUS, sent|defwinproc },
10221 { 0 }
10222 };
10223
10224
10225 static void test_SetActiveWindow(void)
10226 {
10227 HWND hwnd, popup, ret;
10228
10229 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
10230 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10231 100, 100, 200, 200, 0, 0, 0, NULL);
10232
10233 popup = CreateWindowExA(0, "TestWindowClass", "Test SetActiveWindow",
10234 WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_POPUP,
10235 100, 100, 200, 200, hwnd, 0, 0, NULL);
10236
10237 ok(hwnd != 0, "Failed to create overlapped window\n");
10238 flush_sequence();
10239
10240 ok(popup != 0, "Failed to create popup window\n");
10241 flush_sequence();
10242
10243 trace("SetActiveWindow(0)\n");
10244 ret = SetActiveWindow(0);
10245 ok( ret == popup, "Failed to SetActiveWindow(0)\n");
10246 ok_sequence(SetActiveWindowSeq0, "SetActiveWindow(0)", TRUE);
10247 flush_sequence();
10248
10249 trace("SetActiveWindow(hwnd), hwnd visible\n");
10250 ret = SetActiveWindow(hwnd);
10251 todo_wine
10252 {
10253 ok( ret == hwnd, "Failed to SetActiveWindow(hwnd), hwnd visible\n");
10254 }
10255 ok_sequence(SetActiveWindowSeq1, "SetActiveWindow(hwnd), hwnd visible", TRUE);
10256 flush_sequence();
10257
10258 trace("SetActiveWindow(popup), hwnd visible, popup visible\n");
10259 ret = SetActiveWindow(popup);
10260 ok( ret == hwnd, "Failed to SetActiveWindow(popup), popup visible\n");
10261 ok_sequence(SetActiveWindowSeq2, "SetActiveWindow(popup), hwnd visible, popup visible", TRUE);
10262 flush_sequence();
10263
10264 ShowWindow(hwnd, SW_HIDE);
10265 ShowWindow(popup, SW_HIDE);
10266 flush_sequence();
10267
10268 trace("SetActiveWindow(hwnd), hwnd not visible\n");
10269 ret = SetActiveWindow(hwnd);
10270 ok( ret == NULL, "Failed to SetActiveWindow(hwnd), hwnd not visible\n");
10271 ok_sequence(SetActiveWindowSeq3, "SetActiveWindow(hwnd), hwnd not visible", TRUE);
10272 flush_sequence();
10273
10274 trace("SetActiveWindow(popup), hwnd not visible, popup not visible\n");
10275 ret = SetActiveWindow(popup);
10276 ok( ret == hwnd, "Failed to SetActiveWindow(popup)\n");
10277 ok_sequence(SetActiveWindowSeq4, "SetActiveWindow(popup), hwnd not visible, popup not visible", TRUE);
10278 flush_sequence();
10279
10280 trace("done\n");
10281
10282 DestroyWindow(hwnd);
10283 }
10284
10285 static const struct message SetForegroundWindowSeq[] =
10286 {
10287 { WM_NCACTIVATE, sent|wparam, 0 },
10288 { WM_GETTEXT, sent|defwinproc|optional },
10289 { WM_ACTIVATE, sent|wparam, 0 },
10290 { WM_ACTIVATEAPP, sent|wparam, 0 },
10291 { WM_KILLFOCUS, sent },
10292 { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
10293 { WM_IME_NOTIFY, sent|wparam|optional|defwinproc, 1 },
10294 { 0 }
10295 };
10296
10297 static void test_SetForegroundWindow(void)
10298 {
10299 HWND hwnd;
10300
10301 hwnd = CreateWindowExA(0, "TestWindowClass", "Test SetForegroundWindow",
10302 WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10303 100, 100, 200, 200, 0, 0, 0, NULL);
10304 ok (hwnd != 0, "Failed to create overlapped window\n");
10305 flush_sequence();
10306
10307 trace("SetForegroundWindow( 0 )\n");
10308 SetForegroundWindow( 0 );
10309 ok_sequence(WmEmptySeq, "SetForegroundWindow( 0 ) away from foreground top level window", FALSE);
10310 trace("SetForegroundWindow( GetDesktopWindow() )\n");
10311 SetForegroundWindow( GetDesktopWindow() );
10312 ok_sequence(SetForegroundWindowSeq, "SetForegroundWindow( desktop ) away from "
10313 "foreground top level window", FALSE);
10314 trace("done\n");
10315
10316 DestroyWindow(hwnd);
10317 }
10318
10319 static void test_dbcs_wm_char(void)
10320 {
10321 BYTE dbch[2];
10322 WCHAR wch, bad_wch;
10323 HWND hwnd, hwnd2;
10324 MSG msg;
10325 DWORD time;
10326 POINT pt;
10327 DWORD_PTR res;
10328 CPINFOEXA cpinfo;
10329 UINT i, j, k;
10330 struct message wmCharSeq[2];
10331
10332 if (!pGetCPInfoExA)
10333 {
10334 skip("GetCPInfoExA is not available\n");
10335 return;
10336 }
10337
10338 pGetCPInfoExA( CP_ACP, 0, &cpinfo );
10339 if (cpinfo.MaxCharSize != 2)
10340 {
10341 skip( "Skipping DBCS WM_CHAR test in SBCS codepage '%s'\n", cpinfo.CodePageName );
10342 return;
10343 }
10344
10345 dbch[0] = dbch[1] = 0;
10346 wch = 0;
10347 bad_wch = cpinfo.UnicodeDefaultChar;
10348 for (i = 0; !wch && i < MAX_LEADBYTES && cpinfo.LeadByte[i]; i += 2)
10349 for (j = cpinfo.LeadByte[i]; !wch && j <= cpinfo.LeadByte[i+1]; j++)
10350 for (k = 128; k <= 255; k++)
10351 {
10352 char str[2];
10353 WCHAR wstr[2];
10354 str[0] = j;
10355 str[1] = k;
10356 if (MultiByteToWideChar( CP_ACP, 0, str, 2, wstr, 2 ) == 1 &&
10357 WideCharToMultiByte( CP_ACP, 0, wstr, 1, str, 2, NULL, NULL ) == 2 &&
10358 (BYTE)str[0] == j && (BYTE)str[1] == k &&
10359 HIBYTE(wstr[0]) && HIBYTE(wstr[0]) != 0xff)
10360 {
10361 dbch[0] = j;
10362 dbch[1] = k;
10363 wch = wstr[0];
10364 break;
10365 }
10366 }
10367
10368 if (!wch)
10369 {
10370 skip( "Skipping DBCS WM_CHAR test, no appropriate char found\n" );
10371 return;
10372 }
10373 trace( "using dbcs char %02x,%02x wchar %04x bad wchar %04x codepage '%s'\n",
10374 dbch[0], dbch[1], wch, bad_wch, cpinfo.CodePageName );
10375
10376 hwnd = CreateWindowExW(0, testWindowClassW, NULL,
10377 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
10378 hwnd2 = CreateWindowExW(0, testWindowClassW, NULL,
10379 WS_OVERLAPPEDWINDOW, 100, 100, 200, 200, 0, 0, 0, NULL);
10380 ok (hwnd != 0, "Failed to create overlapped window\n");
10381 ok (hwnd2 != 0, "Failed to create overlapped window\n");
10382 flush_sequence();
10383
10384 memset( wmCharSeq, 0, sizeof(wmCharSeq) );
10385 wmCharSeq[0].message = WM_CHAR;
10386 wmCharSeq[0].flags = sent|wparam;
10387 wmCharSeq[0].wParam = wch;
10388
10389 /* posted message */
10390 PostMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10391 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10392 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10393 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10394 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10395 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
10396 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10397
10398 /* posted thread message */
10399 PostThreadMessageA( GetCurrentThreadId(), WM_CHAR, dbch[0], 0 );
10400 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10401 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10402 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10403 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10404 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
10405 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10406
10407 /* sent message */
10408 flush_sequence();
10409 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10410 ok_sequence( WmEmptySeq, "no messages", FALSE );
10411 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10412 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10413 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10414
10415 /* sent message with timeout */
10416 flush_sequence();
10417 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
10418 ok_sequence( WmEmptySeq, "no messages", FALSE );
10419 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
10420 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10421 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10422
10423 /* sent message with timeout and callback */
10424 flush_sequence();
10425 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[0], 0, SMTO_NORMAL, 0, &res );
10426 ok_sequence( WmEmptySeq, "no messages", FALSE );
10427 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
10428 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10429 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10430
10431 /* sent message with callback */
10432 flush_sequence();
10433 SendNotifyMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10434 ok_sequence( WmEmptySeq, "no messages", FALSE );
10435 SendMessageCallbackA( hwnd, WM_CHAR, dbch[1], 0, NULL, 0 );
10436 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10437 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10438
10439 /* direct window proc call */
10440 flush_sequence();
10441 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
10442 ok_sequence( WmEmptySeq, "no messages", FALSE );
10443 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
10444 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10445
10446 /* dispatch message */
10447 msg.hwnd = hwnd;
10448 msg.message = WM_CHAR;
10449 msg.wParam = dbch[0];
10450 msg.lParam = 0;
10451 DispatchMessageA( &msg );
10452 ok_sequence( WmEmptySeq, "no messages", FALSE );
10453 msg.wParam = dbch[1];
10454 DispatchMessageA( &msg );
10455 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10456
10457 /* window handle is irrelevant */
10458 flush_sequence();
10459 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
10460 ok_sequence( WmEmptySeq, "no messages", FALSE );
10461 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10462 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10463 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10464
10465 /* interleaved post and send */
10466 flush_sequence();
10467 PostMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
10468 SendMessageA( hwnd2, WM_CHAR, dbch[0], 0 );
10469 ok_sequence( WmEmptySeq, "no messages", FALSE );
10470 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10471 PostMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10472 ok_sequence( WmEmptySeq, "no messages", FALSE );
10473 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10474 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10475 ok( msg.wParam == wch, "bad wparam %lx/%x\n", msg.wParam, wch );
10476 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10477 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10478 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10479 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10480
10481 /* interleaved sent message and winproc */
10482 flush_sequence();
10483 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10484 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
10485 ok_sequence( WmEmptySeq, "no messages", FALSE );
10486 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10487 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10488 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
10489 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10490
10491 /* interleaved winproc and dispatch */
10492 msg.hwnd = hwnd;
10493 msg.message = WM_CHAR;
10494 msg.wParam = dbch[0];
10495 msg.lParam = 0;
10496 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[0], 0 );
10497 DispatchMessageA( &msg );
10498 ok_sequence( WmEmptySeq, "no messages", FALSE );
10499 msg.wParam = dbch[1];
10500 DispatchMessageA( &msg );
10501 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10502 CallWindowProcA( (WNDPROC)GetWindowLongPtrA( hwnd, GWLP_WNDPROC ), hwnd, WM_CHAR, dbch[1], 0 );
10503 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10504
10505 /* interleaved sends */
10506 flush_sequence();
10507 SendMessageA( hwnd, WM_CHAR, dbch[0], 0 );
10508 SendMessageCallbackA( hwnd, WM_CHAR, dbch[0], 0, NULL, 0 );
10509 ok_sequence( WmEmptySeq, "no messages", FALSE );
10510 SendMessageTimeoutA( hwnd, WM_CHAR, dbch[1], 0, SMTO_NORMAL, 0, &res );
10511 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10512 SendMessageA( hwnd, WM_CHAR, dbch[1], 0 );
10513 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10514
10515 /* dbcs WM_CHAR */
10516 flush_sequence();
10517 SendMessageA( hwnd2, WM_CHAR, (dbch[1] << 8) | dbch[0], 0 );
10518 ok_sequence( wmCharSeq, "Unicode WM_CHAR", FALSE );
10519 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10520
10521 /* other char messages are not magic */
10522 PostMessageA( hwnd, WM_SYSCHAR, dbch[0], 0 );
10523 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10524 ok( msg.message == WM_SYSCHAR, "unexpected message %x\n", msg.message );
10525 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
10526 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10527 PostMessageA( hwnd, WM_DEADCHAR, dbch[0], 0 );
10528 ok( PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10529 ok( msg.message == WM_DEADCHAR, "unexpected message %x\n", msg.message );
10530 ok( msg.wParam == bad_wch, "bad wparam %lx/%x\n", msg.wParam, bad_wch );
10531 ok( !PeekMessageW( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10532
10533 /* test retrieving messages */
10534
10535 PostMessageW( hwnd, WM_CHAR, wch, 0 );
10536 ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10537 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10538 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10539 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10540 ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10541 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10542 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10543 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10544 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10545
10546 /* message filters */
10547 PostMessageW( hwnd, WM_CHAR, wch, 0 );
10548 ok( PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "no message\n" );
10549 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10550 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10551 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10552 /* message id is filtered, hwnd is not */
10553 ok( !PeekMessageA( &msg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ), "no message\n" );
10554 ok( PeekMessageA( &msg, hwnd2, 0, 0, PM_REMOVE ), "no message\n" );
10555 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10556 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10557 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10558 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10559
10560 /* mixing GetMessage and PostMessage */
10561 PostMessageW( hwnd, WM_CHAR, wch, 0xbeef );
10562 ok( GetMessageA( &msg, hwnd, 0, 0 ), "no message\n" );
10563 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10564 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10565 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10566 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
10567 time = msg.time;
10568 pt = msg.pt;
10569 ok( time - GetTickCount() <= 100, "bad time %x\n", msg.time );
10570 ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
10571 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10572 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10573 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10574 ok( msg.lParam == 0xbeef, "bad lparam %lx\n", msg.lParam );
10575 ok( msg.time == time, "bad time %x/%x\n", msg.time, time );
10576 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 );
10577 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10578
10579 /* without PM_REMOVE */
10580 PostMessageW( hwnd, WM_CHAR, wch, 0 );
10581 ok( PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "no message\n" );
10582 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10583 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10584 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10585 ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
10586 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10587 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10588 ok( msg.wParam == dbch[0], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10589 ok( PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE ), "no message\n" );
10590 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10591 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10592 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10593 ok( PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ), "no message\n" );
10594 ok( msg.hwnd == hwnd, "unexpected hwnd %p\n", msg.hwnd );
10595 ok( msg.message == WM_CHAR, "unexpected message %x\n", msg.message );
10596 ok( msg.wParam == dbch[1], "bad wparam %lx/%x\n", msg.wParam, dbch[0] );
10597 ok( !PeekMessageA( &msg, hwnd, 0, 0, PM_REMOVE ), "got message %x\n", msg.message );
10598
10599 DestroyWindow(hwnd);
10600 }
10601
10602 #define ID_LISTBOX 0x000f
10603
10604 static const struct message wm_lb_setcursel_0[] =
10605 {
10606 { LB_SETCURSEL, sent|wparam|lparam, 0, 0 },
10607 { WM_CTLCOLORLISTBOX, sent|parent },
10608 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
10609 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10610 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10611 { 0 }
10612 };
10613 static const struct message wm_lb_setcursel_1[] =
10614 {
10615 { LB_SETCURSEL, sent|wparam|lparam, 1, 0 },
10616 { WM_CTLCOLORLISTBOX, sent|parent },
10617 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000020f2 },
10618 { WM_CTLCOLORLISTBOX, sent|parent },
10619 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000121f2 },
10620 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
10621 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 2 },
10622 { 0 }
10623 };
10624 static const struct message wm_lb_setcursel_2[] =
10625 {
10626 { LB_SETCURSEL, sent|wparam|lparam, 2, 0 },
10627 { WM_CTLCOLORLISTBOX, sent|parent },
10628 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000021f2 },
10629 { WM_CTLCOLORLISTBOX, sent|parent },
10630 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000122f2 },
10631 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
10632 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
10633 { 0 }
10634 };
10635 static const struct message wm_lb_click_0[] =
10636 {
10637 { WM_LBUTTONDOWN, sent|wparam|lparam, 0, MAKELPARAM(1,1) },
10638 { HCBT_SETFOCUS, hook },
10639 { WM_KILLFOCUS, sent|parent },
10640 { WM_IME_SETCONTEXT, sent|wparam|optional|parent, 0 },
10641 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
10642 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 0 },
10643 { WM_SETFOCUS, sent|defwinproc },
10644
10645 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001142f2 },
10646 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SETFOCUS) },
10647 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 3 },
10648 { WM_LBTRACKPOINT, sent|wparam|lparam|parent, 0, MAKELPARAM(1,1) },
10649 { EVENT_SYSTEM_CAPTURESTART, winevent_hook|wparam|lparam, 0, 0 },
10650
10651 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000142f2 },
10652 { WM_CTLCOLORLISTBOX, sent|parent },
10653 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000022f2 },
10654 { WM_CTLCOLORLISTBOX, sent|parent },
10655 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x000120f2 },
10656 { WM_DRAWITEM, sent|wparam|lparam|parent, ID_LISTBOX, 0x001140f2 },
10657
10658 { EVENT_OBJECT_FOCUS, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10659 { EVENT_OBJECT_SELECTION, winevent_hook|wparam|lparam, OBJID_CLIENT, 1 },
10660
10661 { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
10662 { EVENT_SYSTEM_CAPTUREEND, winevent_hook|wparam|lparam, 0, 0 },
10663 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0 },
10664 { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_LISTBOX, LBN_SELCHANGE) },
10665 { 0 }
10666 };
10667
10668 #define check_lb_state(a1, a2, a3, a4, a5) check_lb_state_dbg(a1, a2, a3, a4, a5, __LINE__)
10669
10670 static LRESULT (WINAPI *listbox_orig_proc)(HWND, UINT, WPARAM, LPARAM);
10671
10672 static LRESULT WINAPI listbox_hook_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
10673 {
10674 static long defwndproc_counter = 0;
10675 LRESULT ret;
10676 struct message msg;
10677
10678 /* do not log painting messages */
10679 if (message != WM_PAINT &&
10680 message != WM_NCPAINT &&
10681 message != WM_SYNCPAINT &&
10682 message != WM_ERASEBKGND &&
10683 message != WM_NCHITTEST &&
10684 message != WM_GETTEXT &&
10685 message != WM_GETICON &&
10686 message != WM_DEVICECHANGE)
10687 {
10688 trace("listbox: %p, %04x, %08lx, %08lx\n", hwnd, message, wp, lp);
10689
10690 msg.message = message;
10691 msg.flags = sent|wparam|lparam;
10692 if (defwndproc_counter) msg.flags |= defwinproc;
10693 msg.wParam = wp;
10694 msg.lParam = lp;
10695 add_message(&msg);
10696 }
10697
10698 defwndproc_counter++;
10699 ret = CallWindowProcA(listbox_orig_proc, hwnd, message, wp, lp);
10700 defwndproc_counter--;
10701
10702 return ret;
10703 }
10704
10705 static void check_lb_state_dbg(HWND listbox, int count, int cur_sel,
10706 int caret_index, int top_index, int line)
10707 {
10708 LRESULT ret;
10709
10710 /* calling an orig proc helps to avoid unnecessary message logging */
10711 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCOUNT, 0, 0);
10712 ok_(__FILE__, line)(ret == count, "expected count %d, got %ld\n", count, ret);
10713 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCURSEL, 0, 0);
10714 ok_(__FILE__, line)(ret == cur_sel, "expected cur sel %d, got %ld\n", cur_sel, ret);
10715 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETCARETINDEX, 0, 0);
10716 ok_(__FILE__, line)(ret == caret_index, "expected caret index %d, got %ld\n", caret_index, ret);
10717 ret = CallWindowProcA(listbox_orig_proc, listbox, LB_GETTOPINDEX, 0, 0);
10718 ok_(__FILE__, line)(ret == top_index, "expected top index %d, got %ld\n", top_index, ret);
10719 }
10720
10721 static void test_listbox_messages(void)
10722 {
10723 HWND parent, listbox;
10724 LRESULT ret;
10725
10726 parent = CreateWindowExA(0, "TestParentClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10727 100, 100, 200, 200, 0, 0, 0, NULL);
10728 listbox = CreateWindowExA(WS_EX_NOPARENTNOTIFY, "ListBox", NULL,
10729 WS_CHILD | LBS_NOTIFY | LBS_OWNERDRAWVARIABLE | LBS_HASSTRINGS | WS_VISIBLE,
10730 10, 10, 80, 80, parent, (HMENU)ID_LISTBOX, 0, NULL);
10731 listbox_orig_proc = (WNDPROC)SetWindowLongPtrA(listbox, GWLP_WNDPROC, (ULONG_PTR)listbox_hook_proc);
10732
10733 check_lb_state(listbox, 0, LB_ERR, 0, 0);
10734
10735 ret = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM)"item 0");
10736 ok(ret == 0, "expected 0, got %ld\n", ret);
10737 ret = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM)"item 1");
10738 ok(ret == 1, "expected 1, got %ld\n", ret);
10739 ret = SendMessage(listbox, LB_ADDSTRING, 0, (LPARAM)"item 2");
10740 ok(ret == 2, "expected 2, got %ld\n", ret);
10741
10742 check_lb_state(listbox, 3, LB_ERR, 0, 0);
10743
10744 flush_sequence();
10745
10746 log_all_parent_messages++;
10747
10748 trace("selecting item 0\n");
10749 ret = SendMessage(listbox, LB_SETCURSEL, 0, 0);
10750 ok(ret == 0, "expected 0, got %ld\n", ret);
10751 ok_sequence(wm_lb_setcursel_0, "LB_SETCURSEL 0", FALSE );
10752 check_lb_state(listbox, 3, 0, 0, 0);
10753 flush_sequence();
10754
10755 trace("selecting item 1\n");
10756 ret = SendMessage(listbox, LB_SETCURSEL, 1, 0);
10757 ok(ret == 1, "expected 1, got %ld\n", ret);
10758 ok_sequence(wm_lb_setcursel_1, "LB_SETCURSEL 1", FALSE );
10759 check_lb_state(listbox, 3, 1, 1, 0);
10760
10761 trace("selecting item 2\n");
10762 ret = SendMessage(listbox, LB_SETCURSEL, 2, 0);
10763 ok(ret == 2, "expected 2, got %ld\n", ret);
10764 ok_sequence(wm_lb_setcursel_2, "LB_SETCURSEL 2", FALSE );
10765 check_lb_state(listbox, 3, 2, 2, 0);
10766
10767 trace("clicking on item 0\n");
10768 ret = SendMessage(listbox, WM_LBUTTONDOWN, 0, MAKELPARAM(1, 1));
10769 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
10770 ret = SendMessage(listbox, WM_LBUTTONUP, 0, 0);
10771 ok(ret == LB_OKAY, "expected LB_OKAY, got %ld\n", ret);
10772 ok_sequence(wm_lb_click_0, "WM_LBUTTONDOWN 0", FALSE );
10773 check_lb_state(listbox, 3, 0, 0, 0);
10774 flush_sequence();
10775
10776 log_all_parent_messages--;
10777
10778 DestroyWindow(listbox);
10779 DestroyWindow(parent);
10780 }
10781
10782 /*************************** Menu test ******************************/
10783 static const struct message wm_popup_menu_1[] =
10784 {
10785 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
10786 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
10787 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0x20000001 },
10788 { WM_SYSKEYDOWN, sent|wparam|lparam, 'E', 0x20000001 },
10789 { WM_SYSCHAR, sent|wparam|lparam, 'e', 0x20000001 },
10790 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'e' },
10791 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
10792 { WM_INITMENU, sent|lparam, 0, 0 },
10793 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(1,MF_HILITE|MF_POPUP) },
10794 { WM_INITMENUPOPUP, sent|lparam, 0, 1 },
10795 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't create a window */
10796 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(200,MF_HILITE) },
10797 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'E', 0xf0000001 },
10798 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
10799 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
10800 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't create a window */
10801 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
10802 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
10803 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
10804 { WM_MENUCOMMAND, sent }, /* |wparam, 200 - Win9x */
10805 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
10806 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
10807 { 0 }
10808 };
10809 static const struct message wm_popup_menu_2[] =
10810 {
10811 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
10812 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
10813 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
10814 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
10815 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
10816 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
10817 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
10818 { WM_INITMENU, sent|lparam, 0, 0 },
10819 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
10820 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
10821 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
10822 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
10823 { HCBT_CREATEWND, hook },
10824 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
10825 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
10826 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
10827 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
10828 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
10829 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
10830 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
10831 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
10832 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
10833 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
10834 { HCBT_DESTROYWND, hook },
10835 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
10836 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
10837 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
10838 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
10839 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
10840 { WM_MENUCOMMAND, sent }, /* |wparam, 100 - Win9x */
10841 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
10842 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
10843 { 0 }
10844 };
10845 static const struct message wm_popup_menu_3[] =
10846 {
10847 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0x20000001 },
10848 { WM_SYSKEYDOWN, sent|wparam|lparam, VK_MENU, 0x20000001 },
10849 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0x20000001 },
10850 { WM_SYSKEYDOWN, sent|wparam|lparam, 'F', 0x20000001 },
10851 { WM_SYSCHAR, sent|wparam|lparam, 'f', 0x20000001 },
10852 { HCBT_SYSCOMMAND, hook|wparam|lparam, SC_KEYMENU, 'f' },
10853 { WM_ENTERMENULOOP, sent|wparam|lparam, 0, 0 },
10854 { WM_INITMENU, sent|lparam, 0, 0 },
10855 { WM_MENUSELECT, sent|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) },
10856 { WM_INITMENUPOPUP, sent|lparam, 0, 0 },
10857 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(0,MF_HILITE|MF_POPUP) }, /* Win9x */
10858 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x */
10859 { HCBT_CREATEWND, hook },
10860 { WM_MENUSELECT, sent }, /*|wparam, MAKEWPARAM(0,MF_HILITE|MF_POPUP) - XP
10861 |wparam, MAKEWPARAM(100,MF_HILITE) - Win9x */
10862 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, 'F', 0xf0000001 },
10863 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_MENU, 0xd0000001 },
10864 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0x10000001 },
10865 { WM_INITMENUPOPUP, sent|lparam|optional, 0, 0 }, /* Win9x doesn't send it */
10866 { HCBT_CREATEWND, hook|optional }, /* Win9x doesn't send it */
10867 { WM_MENUSELECT, sent|wparam|optional, MAKEWPARAM(100,MF_HILITE) },
10868 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RIGHT, 0xd0000001 },
10869 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0x10000001 },
10870 { HCBT_DESTROYWND, hook },
10871 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
10872 { HCBT_DESTROYWND, hook|optional }, /* Win9x doesn't send it */
10873 { WM_UNINITMENUPOPUP, sent|lparam, 0, 0 },
10874 { WM_MENUSELECT, sent|wparam|lparam, MAKEWPARAM(0,0xffff), 0 },
10875 { WM_EXITMENULOOP, sent|wparam|lparam, 0, 0 },
10876 { WM_COMMAND, sent|wparam|lparam, 100, 0 },
10877 { HCBT_KEYSKIPPED, hook|wparam|lparam|optional, VK_RETURN, 0xc0000001 },
10878 { WM_KEYUP, sent|wparam|lparam, VK_RETURN, 0xc0000001 },
10879 { 0 }
10880 };
10881
10882 static LRESULT WINAPI parent_menu_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
10883 {
10884 if (message == WM_ENTERIDLE ||
10885 message == WM_INITMENU ||
10886 message == WM_INITMENUPOPUP ||
10887 message == WM_MENUSELECT ||
10888 message == WM_PARENTNOTIFY ||
10889 message == WM_ENTERMENULOOP ||
10890 message == WM_EXITMENULOOP ||
10891 message == WM_UNINITMENUPOPUP ||
10892 message == WM_KEYDOWN ||
10893 message == WM_KEYUP ||
10894 message == WM_CHAR ||
10895 message == WM_SYSKEYDOWN ||
10896 message == WM_SYSKEYUP ||
10897 message == WM_SYSCHAR ||
10898 message == WM_COMMAND ||
10899 message == WM_MENUCOMMAND)
10900 {
10901 struct message msg;
10902
10903 trace("parent_menu_proc: %p, %04x, %08lx, %08lx\n", hwnd, message, wp, lp);
10904
10905 msg.message = message;
10906 msg.flags = sent|wparam|lparam;
10907 msg.wParam = wp;
10908 msg.lParam = lp;
10909 add_message(&msg);
10910 }
10911
10912 return DefWindowProcA(hwnd, message, wp, lp);
10913 }
10914
10915 static void set_menu_style(HMENU hmenu, DWORD style)
10916 {
10917 MENUINFO mi;
10918 BOOL ret;
10919
10920 mi.cbSize = sizeof(mi);
10921 mi.fMask = MIM_STYLE;
10922 mi.dwStyle = style;
10923 SetLastError(0xdeadbeef);
10924 ret = pSetMenuInfo(hmenu, &mi);
10925 ok(ret, "SetMenuInfo error %u\n", GetLastError());
10926 }
10927
10928 static DWORD get_menu_style(HMENU hmenu)
10929 {
10930 MENUINFO mi;
10931 BOOL ret;
10932
10933 mi.cbSize = sizeof(mi);
10934 mi.fMask = MIM_STYLE;
10935 mi.dwStyle = 0;
10936 SetLastError(0xdeadbeef);
10937 ret = pGetMenuInfo(hmenu, &mi);
10938 ok(ret, "GetMenuInfo error %u\n", GetLastError());
10939
10940 return mi.dwStyle;
10941 }
10942
10943 static void test_menu_messages(void)
10944 {
10945 MSG msg;
10946 WNDCLASSA cls;
10947 HMENU hmenu, hmenu_popup;
10948 HWND hwnd;
10949 DWORD style;
10950
10951 if (!pGetMenuInfo || !pSetMenuInfo)
10952 {
10953 skip("GetMenuInfo and/or SetMenuInfo are not available\n");
10954 return;
10955 }
10956 cls.style = 0;
10957 cls.lpfnWndProc = parent_menu_proc;
10958 cls.cbClsExtra = 0;
10959 cls.cbWndExtra = 0;
10960 cls.hInstance = GetModuleHandleA(0);
10961 cls.hIcon = 0;
10962 cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
10963 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
10964 cls.lpszMenuName = NULL;
10965 cls.lpszClassName = "TestMenuClass";
10966 UnregisterClass(cls.lpszClassName, cls.hInstance);
10967 if (!RegisterClassA(&cls)) assert(0);
10968
10969 SetLastError(0xdeadbeef);
10970 hwnd = CreateWindowExA(0, "TestMenuClass", NULL, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
10971 100, 100, 200, 200, 0, 0, 0, NULL);
10972 ok(hwnd != 0, "LoadMenuA error %u\n", GetLastError());
10973
10974 SetLastError(0xdeadbeef);
10975 hmenu = LoadMenuA(GetModuleHandle(0), MAKEINTRESOURCE(1));
10976 ok(hmenu != 0, "LoadMenuA error %u\n", GetLastError());
10977
10978 SetMenu(hwnd, hmenu);
10979 SetForegroundWindow( hwnd );
10980
10981 set_menu_style(hmenu, MNS_NOTIFYBYPOS);
10982 style = get_menu_style(hmenu);
10983 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
10984
10985 hmenu_popup = GetSubMenu(hmenu, 0);
10986 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
10987 style = get_menu_style(hmenu_popup);
10988 ok(style == 0, "expected 0, got %u\n", style);
10989
10990 hmenu_popup = GetSubMenu(hmenu_popup, 0);
10991 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
10992 style = get_menu_style(hmenu_popup);
10993 ok(style == 0, "expected 0, got %u\n", style);
10994
10995 /* Alt+E, Enter */
10996 trace("testing a popup menu command\n");
10997 flush_sequence();
10998 keybd_event(VK_MENU, 0, 0, 0);
10999 keybd_event('E', 0, 0, 0);
11000 keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
11001 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
11002 keybd_event(VK_RETURN, 0, 0, 0);
11003 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
11004 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
11005 {
11006 TranslateMessage(&msg);
11007 DispatchMessage(&msg);
11008 }
11009 ok_sequence(wm_popup_menu_1, "popup menu command", FALSE);
11010
11011 /* Alt+F, Right, Enter */
11012 trace("testing submenu of a popup menu command\n");
11013 flush_sequence();
11014 keybd_event(VK_MENU, 0, 0, 0);
11015 keybd_event('F', 0, 0, 0);
11016 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
11017 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
11018 keybd_event(VK_RIGHT, 0, 0, 0);
11019 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
11020 keybd_event(VK_RETURN, 0, 0, 0);
11021 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
11022 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
11023 {
11024 TranslateMessage(&msg);
11025 DispatchMessage(&msg);
11026 }
11027 ok_sequence(wm_popup_menu_2, "submenu of a popup menu command", FALSE);
11028
11029 set_menu_style(hmenu, 0);
11030 style = get_menu_style(hmenu);
11031 ok(style == 0, "expected 0, got %u\n", style);
11032
11033 hmenu_popup = GetSubMenu(hmenu, 0);
11034 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
11035 set_menu_style(hmenu_popup, MNS_NOTIFYBYPOS);
11036 style = get_menu_style(hmenu_popup);
11037 ok(style == MNS_NOTIFYBYPOS, "expected MNS_NOTIFYBYPOS, got %u\n", style);
11038
11039 hmenu_popup = GetSubMenu(hmenu_popup, 0);
11040 ok(hmenu_popup != 0, "GetSubMenu returned 0 for submenu 0\n");
11041 style = get_menu_style(hmenu_popup);
11042 ok(style == 0, "expected 0, got %u\n", style);
11043
11044 /* Alt+F, Right, Enter */
11045 trace("testing submenu of a popup menu command\n");
11046 flush_sequence();
11047 keybd_event(VK_MENU, 0, 0, 0);
11048 keybd_event('F', 0, 0, 0);
11049 keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
11050 keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
11051 keybd_event(VK_RIGHT, 0, 0, 0);
11052 keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
11053 keybd_event(VK_RETURN, 0, 0, 0);
11054 keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
11055 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
11056 {
11057 TranslateMessage(&msg);
11058 DispatchMessage(&msg);
11059 }
11060 ok_sequence(wm_popup_menu_3, "submenu of a popup menu command", FALSE);
11061
11062 DestroyWindow(hwnd);
11063 DestroyMenu(hmenu);
11064 }
11065
11066
11067 static void test_paintingloop(void)
11068 {
11069 HWND hwnd;
11070
11071 paint_loop_done = 0;
11072 hwnd = CreateWindowExA(0x0,"PaintLoopWindowClass",
11073 "PaintLoopWindowClass",WS_OVERLAPPEDWINDOW,
11074 100, 100, 100, 100, 0, 0, 0, NULL );
11075 ok(hwnd != 0, "PaintLoop window error %u\n", GetLastError());
11076 ShowWindow(hwnd,SW_NORMAL);
11077 SetFocus(hwnd);
11078
11079 while (!paint_loop_done)
11080 {
11081 MSG msg;
11082 if (PeekMessageA(&msg, 0, 0, 0, 1))
11083 {
11084 TranslateMessage(&msg);
11085 DispatchMessage(&msg);
11086 }
11087 }
11088 DestroyWindow(hwnd);
11089 }
11090
11091 START_TEST(msg)
11092 {
11093 BOOL ret;
11094 FARPROC pIsWinEventHookInstalled = 0;/*GetProcAddress(user32, "IsWinEventHookInstalled");*/
11095
11096 init_procs();
11097
11098 if (!RegisterWindowClasses()) assert(0);
11099
11100 if (pSetWinEventHook)
11101 {
11102 hEvent_hook = (HWINEVENTHOOK)pSetWinEventHook(EVENT_MIN, EVENT_MAX,
11103 GetModuleHandleA(0),
11104 win_event_proc,
11105 0,
11106 GetCurrentThreadId(),
11107 WINEVENT_INCONTEXT);
11108 assert(hEvent_hook);
11109
11110 if (pIsWinEventHookInstalled)
11111 {
11112 UINT event;
11113 for (event = EVENT_MIN; event <= EVENT_MAX; event++)
11114 ok(pIsWinEventHookInstalled(event), "IsWinEventHookInstalled(%u) failed\n", event);
11115 }
11116 }
11117
11118 cbt_hook_thread_id = GetCurrentThreadId();
11119 hCBT_hook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
11120 assert(hCBT_hook);
11121
11122 test_winevents();
11123
11124 /* Fix message sequences before removing 4 lines below */
11125 #if 1
11126 if (pUnhookWinEvent && hEvent_hook)
11127 {
11128 ret = pUnhookWinEvent(hEvent_hook);
11129 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
11130 pUnhookWinEvent = 0;
11131 }
11132 hEvent_hook = 0;
11133 #endif
11134
11135 test_ShowWindow();
11136 test_PeekMessage();
11137 test_PeekMessage2();
11138 test_scrollwindowex();
11139 test_messages();
11140 test_setwindowpos();
11141 test_showwindow();
11142 invisible_parent_tests();
11143 test_mdi_messages();
11144 test_button_messages();
11145 test_static_messages();
11146 test_listbox_messages();
11147 test_combobox_messages();
11148 test_wmime_keydown_message();
11149 test_paint_messages();
11150 test_interthread_messages();
11151 test_message_conversion();
11152 test_accelerators();
11153 test_timers();
11154 test_timers_no_wnd();
11155 test_set_hook();
11156 test_DestroyWindow();
11157 test_DispatchMessage();
11158 test_SendMessageTimeout();
11159 test_edit_messages();
11160 test_quit_message();
11161 test_SetActiveWindow();
11162
11163 if (!pTrackMouseEvent)
11164 skip("TrackMouseEvent is not available\n");
11165 else
11166 test_TrackMouseEvent();
11167
11168 test_SetWindowRgn();
11169 test_sys_menu();
11170 test_dialog_messages();
11171 test_nullCallback();
11172 test_dbcs_wm_char();
11173 test_menu_messages();
11174 test_paintingloop();
11175 /* keep it the last test, under Windows it tends to break the tests
11176 * which rely on active/foreground windows being correct.
11177 */
11178 test_SetForegroundWindow();
11179
11180 UnhookWindowsHookEx(hCBT_hook);
11181 if (pUnhookWinEvent)
11182 {
11183 ret = pUnhookWinEvent(hEvent_hook);
11184 ok( ret, "UnhookWinEvent error %d\n", GetLastError());
11185 SetLastError(0xdeadbeef);
11186 ok(!pUnhookWinEvent(hEvent_hook), "UnhookWinEvent succeeded\n");
11187 ok(GetLastError() == ERROR_INVALID_HANDLE || /* Win2k */
11188 GetLastError() == 0xdeadbeef, /* Win9x */
11189 "unexpected error %d\n", GetLastError());
11190 }
11191 else
11192 skip("UnhookWinEvent is not available\n");
11193 }
Maarten's multimedia branch